@remnic/core 9.69.55 → 9.69.57

package/dist/chunk-SJV3AOZ2.js

@@ -0,0 +1,2453 @@
+import {
+  ensureContradictionScanCron,
+  ensureDaySummaryCron,
+  ensureGraphEdgeDecayCron,
+  ensureNightlyGovernanceCron,
+  ensurePatternReinforcementCron,
+  ensureProceduralMiningCron,
+  graphEdgeDecayCadenceToCronExpr
+} from "./chunk-666A3MOW.js";
+import {
+  startLocationAutoSync
+} from "./chunk-34ZGBAGE.js";
+import {
+  rebuildMemoryLifecycleLedger
+} from "./chunk-5R3C5LEZ.js";
+import {
+  planNamespaceMaintenance,
+  runNamespaceMaintenanceBatchPlan
+} from "./chunk-AULKCNZW.js";
+import {
+  rebuildMemoryProjection
+} from "./chunk-RDESQOEE.js";
+import {
+  DEFAULT_TIMELINE_CATEGORIES,
+  TIMELINE_RESERVED_IDLE,
+  TIMELINE_RESERVED_PAUSE,
+  TIMELINE_RESERVED_UNKNOWN,
+  analyzeTimelineCards,
+  buildAnalysisRunMetadata,
+  timelineAnalysisCompleteFromClients,
+  validateActivityBaseUrl,
+  validateTimelineCategories
+} from "./chunk-QOPB6KE3.js";
+import {
+  LocalLlmClient
+} from "./chunk-G2XZFGYN.js";
+import {
+  FallbackLlmClient
+} from "./chunk-ZTHGFTMW.js";
+import {
+  fallbackLlmRuntimeContextFromConfig
+} from "./chunk-EP6BA7VV.js";
+import {
+  activityDateInTimezone,
+  activityDayWindow,
+  activityDigestPath,
+  composeActivityDigestBody,
+  composeActivityDigestMeta,
+  hashActivityBody,
+  isValidActivityDate,
+  serializeActivityDigest
+} from "./chunk-353C5UNV.js";
+import {
+  STATE_FILE_MAX_DECRYPT_BYTES,
+  drainPendingLifecycleLedgerIfAny,
+  pendingLifecycleLedgerDir,
+  readProjectionRebuiltAt
+} from "./chunk-JE334SIA.js";
+import {
+  displayErrorDetail,
+  openBetterSqlite3
+} from "./chunk-RL6NEVXT.js";
+import {
+  assertPathInsideRoot,
+  listContainedSpillFiles
+} from "./chunk-C7HJ3NEI.js";
+import {
+  isSafeRouteNamespace
+} from "./chunk-PCXDUHQH.js";
+import {
+  namespaceIdentityFromToken
+} from "./chunk-VUFL7X3H.js";
+import {
+  resolveConsolidationCapabilities,
+  resolveMemoryLifecycleCapabilities,
+  resolveNamespaceCapabilities,
+  resolveQmdCapabilities,
+  resolveRecallAuxiliaryCapabilities
+} from "./chunk-JUOZ62Y7.js";
+import {
+  resolveHomeDir
+} from "./chunk-P2QRMMVQ.js";
+import {
+  SECURE_STORE_ENVELOPE_OVERHEAD_BYTES,
+  probeEncryptedRegularFileHeader
+} from "./chunk-JN72EPOE.js";
+import {
+  isErrnoCode
+} from "./chunk-KNA3BXXL.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/orchestration/maintenance.ts
+import { existsSync } from "fs";
+import { appendFile, lstat, mkdir as mkdir3, readFile as readFile2, readdir, realpath, stat, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+
+// src/maintenance/day-summary-cron.ts
+function resolveDaySummaryCronModel(config) {
+  const rawSummaryModel = config.summaryModel;
+  const taskPrimary = config.taskModelChain?.primary;
+  const isGateway = config.modelSource === "gateway";
+  const model = isGateway ? rawSummaryModel || taskPrimary || void 0 : void 0;
+  const fallbacks = [];
+  if (model && taskPrimary && model === taskPrimary) {
+    const seen = new Set(model ? [model] : []);
+    const addUnique = (value) => {
+      if (typeof value !== "string") return;
+      const trimmed = value.trim();
+      if (trimmed.length > 0 && !seen.has(trimmed)) {
+        seen.add(trimmed);
+        fallbacks.push(trimmed);
+      }
+    };
+    for (const fb of config.taskModelChain?.fallbacks ?? []) addUnique(fb);
+    const gwDefaults = config.gatewayConfig?.agents?.defaults?.model;
+    addUnique(gwDefaults?.primary);
+    if (Array.isArray(gwDefaults?.fallbacks)) {
+      for (const fb of gwDefaults.fallbacks) addUnique(fb);
+    }
+  }
+  return { ...model ? { model } : {}, fallbacks };
+}
+
+// src/orchestration/projection-rebuild-schedule.ts
+var FAILURE_RETRY_BACKOFF_MS = 5 * 60 * 1e3;
+function createProjectionRebuildScheduleState() {
+  return { inFlight: false, lastRebuildAtMs: 0, lastFailureAtMs: 0 };
+}
+async function maybeRebuildMemoryProjectionScheduled(opts) {
+  const { config, state } = opts;
+  if (!resolveMemoryLifecycleCapabilities(config).projectionRebuild) return;
+  if (state.inFlight) return;
+  const intervalMs = config.projectionRebuildIntervalMs;
+  const now = Date.now();
+  if (now - state.lastRebuildAtMs < intervalMs) return;
+  if (now - state.lastFailureAtMs < FAILURE_RETRY_BACKOFF_MS) return;
+  const rootStorage = opts.getStorage?.();
+  const memoryDir = rootStorage ? rootStorage.dir : config.memoryDir;
+  const rebuiltAt = readProjectionRebuiltAt(memoryDir);
+  const rebuiltAtMs = rebuiltAt ? Date.parse(rebuiltAt) : Number.NaN;
+  if (Number.isFinite(rebuiltAtMs) && now - rebuiltAtMs < intervalMs) {
+    state.lastRebuildAtMs = rebuiltAtMs;
+    return;
+  }
+  state.inFlight = true;
+  try {
+    const result = await rebuildMemoryProjection({
+      memoryDir,
+      // Reuse the daemon's live storage so secure-store deployments rebuild
+      // through the unlocked instance instead of a fresh locked one.
+      ...rootStorage ? { storage: rootStorage } : {},
+      defaultNamespace: config.defaultNamespace,
+      dryRun: false,
+      now: new Date(now)
+    });
+    state.lastRebuildAtMs = Date.now();
+    const lag = Number.isFinite(rebuiltAtMs) ? `${Math.max(0, Math.round((now - rebuiltAtMs) / 6e4))}m stale` : "never previously built";
+    log.info(
+      `memory projection rebuilt (scheduled) for ${memoryDir}: was ${lag}; ${result.currentRows} current, ${result.timelineRows} timeline, ${result.entityMentionRows} entity-mention rows`
+    );
+  } catch (err) {
+    state.lastFailureAtMs = Date.now();
+    log.warn(`memory projection scheduled rebuild failed (non-fatal) for ${memoryDir}: ${err}`);
+  } finally {
+    state.inFlight = false;
+  }
+}
+
+// src/activity/reindex.ts
+async function refreshActivityIndex(qmd, collection, signal) {
+  const execution = signal === void 0 ? void 0 : { signal };
+  if (typeof qmd.updateCollectionStrict === "function" && collection.trim().length > 0) {
+    await qmd.updateCollectionStrict(collection, execution);
+    return;
+  }
+  if (typeof qmd.updateStrict === "function") {
+    await qmd.updateStrict(execution);
+    return;
+  }
+  await qmd.update(execution);
+}
+
+// src/activity/store.ts
+import { mkdirSync } from "fs";
+import { mkdir } from "fs/promises";
+import path from "path";
+var ACTIVITY_SCHEMA_VERSION = 1;
+var MAX_SEARCH_RESULTS = 100;
+function activityDatabasePath(memoryDir) {
+  return path.join(memoryDir, "state", "activity.sqlite");
+}
+async function ensureActivityStateDir(memoryDir) {
+  await mkdir(path.join(memoryDir, "state"), { recursive: true });
+}
+function openActivityDatabase(memoryDir) {
+  mkdirSync(path.join(memoryDir, "state"), { recursive: true });
+  const db = openBetterSqlite3(activityDatabasePath(memoryDir));
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 5000");
+  db.pragma("synchronous = NORMAL");
+  applySchema(db);
+  return db;
+}
+function applyActivitySchema(db) {
+  applySchema(db);
+}
+function applySchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS activity_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS activity_snapshots (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      machine         TEXT NOT NULL,
+      captured_at_utc TEXT NOT NULL,
+      app_name        TEXT NOT NULL,
+      window_title    TEXT NOT NULL,
+      browser_url     TEXT,
+      text            TEXT NOT NULL,
+      text_source     TEXT NOT NULL,
+      content_hash    TEXT NOT NULL,
+      simhash         TEXT
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_activity_snapshots_dedup
+      ON activity_snapshots(machine, captured_at_utc, content_hash);
+    CREATE INDEX IF NOT EXISTS idx_activity_snapshots_time
+      ON activity_snapshots(captured_at_utc, id);
+
+    CREATE TABLE IF NOT EXISTS activity_sync_state (
+      machine        TEXT PRIMARY KEY,
+      cursor         TEXT,
+      updated_at_utc TEXT NOT NULL
+    );
+  `);
+  const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='activity_snapshots_fts'").get();
+  if (!hasFts) {
+    db.exec(`
+      CREATE VIRTUAL TABLE activity_snapshots_fts USING fts5(
+        text, app_name, window_title, browser_url
+      );
+    `);
+  }
+  db.prepare("INSERT OR REPLACE INTO activity_meta (key, value) VALUES ('schema_version', ?)").run(
+    String(ACTIVITY_SCHEMA_VERSION)
+  );
+}
+function canonicalizeUtc(iso) {
+  const parsed = Date.parse(iso);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : iso;
+}
+function assertRequiredSnapshotFields(s) {
+  const required = [
+    ["machine", s.machine],
+    ["app", s.app],
+    ["windowTitle", s.windowTitle],
+    ["text", s.text],
+    ["textSource", s.textSource],
+    ["contentHash", s.contentHash]
+  ];
+  for (const [field, value] of required) {
+    if (typeof value !== "string") {
+      throw new RangeError(`activity: snapshot field "${field}" is required (got ${value === null ? "null" : typeof value}).`);
+    }
+  }
+  if (s.machine.length === 0 || s.contentHash.length === 0) {
+    throw new RangeError('activity: snapshot "machine" and "contentHash" must be non-empty.');
+  }
+  if (s.textSource !== "ax" && s.textSource !== "ocr") {
+    throw new RangeError(`activity: snapshot "textSource" must be "ax" or "ocr" (got "${s.textSource}").`);
+  }
+}
+function assertValidUtcInstant(iso, what) {
+  const m = iso.match(
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-](?:0\d:[0-5]\d|1[0-3]:[0-5]\d|14:00))$/
+  );
+  if (m === null || !Number.isFinite(Date.parse(iso))) {
+    throw new RangeError(`activity: invalid ${what} "${iso}".`);
+  }
+  const [year, month, day, hour, minute, second] = m.slice(1).map(Number);
+  const daysInMonth = month >= 1 && month <= 12 ? new Date(Date.UTC(year, month, 0)).getUTCDate() : 0;
+  if (day < 1 || day > daysInMonth || hour > 23 || minute > 59 || second > 59) {
+    throw new RangeError(`activity: ${what} "${iso}" is not a real calendar instant.`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function optStr(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function ftsMatchFor(query) {
+  if (typeof query !== "string") return null;
+  const tokens = query.match(/[\p{L}\p{N}_]+/gu);
+  if (!tokens || tokens.length === 0) return null;
+  return tokens.map((token) => `"${token}"`).join(" ");
+}
+function rowToSnapshot(row) {
+  if (!isRecord(row)) {
+    throw new Error("activity store: unexpected non-object row");
+  }
+  const textSource = row.text_source === "ocr" ? "ocr" : "ax";
+  return {
+    id: typeof row.id === "number" ? row.id : void 0,
+    machine: str(row.machine),
+    capturedAtUtc: str(row.captured_at_utc),
+    app: str(row.app_name),
+    windowTitle: str(row.window_title),
+    ...optStr(row.browser_url) !== void 0 ? { browserUrl: optStr(row.browser_url) } : {},
+    text: str(row.text),
+    textSource,
+    contentHash: str(row.content_hash),
+    ...optStr(row.simhash) !== void 0 ? { simhash: optStr(row.simhash) } : {}
+  };
+}
+var ActivityStore = class _ActivityStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static open(memoryDir) {
+    return new _ActivityStore(openActivityDatabase(memoryDir));
+  }
+  /**
+   * Insert a snapshot, idempotent on (machine, captured_at_utc, content_hash):
+   * the same screen content recurring at a *different* time is kept; only an
+   * exact re-ingestion of the same capture dedups. Returns `inserted: false`
+   * for a duplicate. The FTS row is written only on a real insert (atomically),
+   * so it never drifts from the base table.
+   */
+  insertSnapshot(snapshot) {
+    const runInsert = this.db.transaction((s) => {
+      assertValidUtcInstant(s.capturedAtUtc, "capture timestamp");
+      assertRequiredSnapshotFields(s);
+      const capturedAtUtc = canonicalizeUtc(s.capturedAtUtc);
+      const info = this.db.prepare(
+        `INSERT OR IGNORE INTO activity_snapshots
+             (machine, captured_at_utc, app_name, window_title, browser_url, text, text_source, content_hash, simhash)
+           VALUES (@machine, @captured_at_utc, @app_name, @window_title, @browser_url, @text, @text_source, @content_hash, @simhash)`
+      ).run({
+        machine: s.machine,
+        captured_at_utc: capturedAtUtc,
+        app_name: s.app,
+        window_title: s.windowTitle,
+        browser_url: s.browserUrl ?? null,
+        text: s.text,
+        text_source: s.textSource,
+        content_hash: s.contentHash,
+        simhash: s.simhash ?? null
+      });
+      if (info.changes === 0) {
+        const existing = this.db.prepare("SELECT id FROM activity_snapshots WHERE machine = ? AND captured_at_utc = ? AND content_hash = ?").get(s.machine, capturedAtUtc, s.contentHash);
+        const id2 = isRecord(existing) && typeof existing.id === "number" ? existing.id : -1;
+        return { inserted: false, id: id2 };
+      }
+      const id = Number(info.lastInsertRowid);
+      this.db.prepare(
+        `INSERT INTO activity_snapshots_fts (rowid, text, app_name, window_title, browser_url)
+           VALUES (?, ?, ?, ?, ?)`
+      ).run(id, s.text, s.app, s.windowTitle, s.browserUrl ?? "");
+      return { inserted: true, id };
+    });
+    return runInsert(snapshot);
+  }
+  /** Snapshots whose capture instant is in the half-open [start, end) window. */
+  listSnapshotsForDay(machine, startUtcInclusive, endUtcExclusive) {
+    assertValidUtcInstant(startUtcInclusive, "range start");
+    assertValidUtcInstant(endUtcExclusive, "range end");
+    const start = canonicalizeUtc(startUtcInclusive);
+    const end = canonicalizeUtc(endUtcExclusive);
+    const rows = machine === null ? this.db.prepare(
+      `SELECT * FROM activity_snapshots
+                 WHERE captured_at_utc >= ? AND captured_at_utc < ?
+                 ORDER BY captured_at_utc ASC, id ASC`
+    ).all(start, end) : this.db.prepare(
+      `SELECT * FROM activity_snapshots
+                 WHERE machine = ? AND captured_at_utc >= ? AND captured_at_utc < ?
+                 ORDER BY captured_at_utc ASC, id ASC`
+    ).all(machine, start, end);
+    return rows.map(rowToSnapshot);
+  }
+  getCursor(machine) {
+    const row = this.db.prepare("SELECT cursor FROM activity_sync_state WHERE machine = ?").get(machine);
+    return isRecord(row) && typeof row.cursor === "string" ? row.cursor : null;
+  }
+  setCursor(machine, cursor, updatedAtUtc = (/* @__PURE__ */ new Date()).toISOString()) {
+    this.db.prepare(
+      `INSERT INTO activity_sync_state (machine, cursor, updated_at_utc)
+         VALUES (?, ?, ?)
+         ON CONFLICT(machine) DO UPDATE SET cursor = excluded.cursor, updated_at_utc = excluded.updated_at_utc`
+    ).run(machine, cursor, updatedAtUtc);
+  }
+  /** Full-text search over snapshot text/app/window/url; newest first. */
+  searchSnapshots(query, limit) {
+    const capped = Number.isInteger(limit) && limit > 0 ? Math.min(limit, MAX_SEARCH_RESULTS) : 20;
+    const match = ftsMatchFor(query);
+    if (match === null) return [];
+    const rows = this.db.prepare(
+      `SELECT s.* FROM activity_snapshots_fts f
+           JOIN activity_snapshots s ON s.id = f.rowid
+           WHERE activity_snapshots_fts MATCH ?
+           ORDER BY s.captured_at_utc DESC, s.id DESC
+           LIMIT ?`
+    ).all(match, capped);
+    return rows.map(rowToSnapshot);
+  }
+  /** Retention: drop snapshots captured strictly before `cutoffUtc`. */
+  pruneOlderThan(cutoffUtc) {
+    assertValidUtcInstant(cutoffUtc, "prune cutoff");
+    const ids = this.db.prepare("SELECT id FROM activity_snapshots WHERE captured_at_utc < ?").all(canonicalizeUtc(cutoffUtc)).map((row) => isRecord(row) && typeof row.id === "number" ? row.id : -1).filter((id) => id >= 0);
+    const deleteFts = this.db.prepare("DELETE FROM activity_snapshots_fts WHERE rowid = ?");
+    const deleteRow = this.db.prepare("DELETE FROM activity_snapshots WHERE id = ?");
+    const tx = this.db.transaction((rowIds) => {
+      for (const id of rowIds) {
+        deleteFts.run(id);
+        deleteRow.run(id);
+      }
+    });
+    tx(ids);
+    return ids.length;
+  }
+  /**
+   * First and last stored capture instants (canonical UTC strings), or null
+   * when no snapshots exist. Backs the unbounded timeline search window.
+   */
+  snapshotCaptureExtent() {
+    const row = this.db.prepare("SELECT MIN(captured_at_utc) AS first, MAX(captured_at_utc) AS last FROM activity_snapshots").get();
+    if (!isRecord(row) || typeof row.first !== "string" || typeof row.last !== "string") {
+      return null;
+    }
+    return { firstUtc: row.first, lastUtc: row.last };
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/activity/pipeline.ts
+import { mkdir as mkdir2, readFile, rename, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import path2 from "path";
+var MAX_SYNC_PAGES = 1e4;
+function activityCursorKey(machine, date) {
+  return `${machine}\0${date}`;
+}
+var digestLocks = /* @__PURE__ */ new Map();
+function withDigestLock(key, fn) {
+  const prior = digestLocks.get(key) ?? Promise.resolve();
+  const next = prior.then(fn, fn);
+  const tail = next.then(
+    () => void 0,
+    () => void 0
+  );
+  digestLocks.set(key, tail);
+  void tail.then(() => {
+    if (digestLocks.get(key) === tail) digestLocks.delete(key);
+  });
+  return next;
+}
+function snapshotForMachine(snapshot, machine) {
+  return {
+    machine,
+    capturedAtUtc: snapshot.capturedAtUtc,
+    app: snapshot.app,
+    windowTitle: snapshot.windowTitle,
+    ...snapshot.browserUrl === void 0 ? {} : { browserUrl: snapshot.browserUrl },
+    text: snapshot.text,
+    textSource: snapshot.textSource,
+    contentHash: snapshot.contentHash,
+    ...snapshot.simhash === void 0 ? {} : { simhash: snapshot.simhash }
+  };
+}
+async function writeDigestIfChanged(memoryDir, date, serialized) {
+  const target = activityDigestPath(memoryDir, date);
+  try {
+    if (await readFile(target, "utf8") === serialized) return false;
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
+  }
+  await mkdir2(path2.dirname(target), { recursive: true, mode: 448 });
+  const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(temporary, serialized, { encoding: "utf8", mode: 384 });
+  await rename(temporary, target);
+  return true;
+}
+async function syncActivitySource(source, options) {
+  if (!isValidActivityDate(options.date)) {
+    throw new RangeError(`Invalid activity date "${options.date}"; expected a real YYYY-MM-DD day.`);
+  }
+  if (source.machineLabel.trim().length === 0) {
+    throw new RangeError("activity source machine label must not be empty");
+  }
+  const maxPages = options.maxPages ?? MAX_SYNC_PAGES;
+  if (!Number.isInteger(maxPages) || maxPages < 1) {
+    throw new RangeError("activity sync maxPages must be a positive integer");
+  }
+  const cursorKey = activityCursorKey(source.machineLabel, options.date);
+  let cursor = options.store.getCursor(cursorKey);
+  let pages = 0;
+  let fetched = 0;
+  let inserted = 0;
+  let duplicates = 0;
+  const seenCursors = /* @__PURE__ */ new Set();
+  let completed = false;
+  while (pages < maxPages) {
+    options.signal?.throwIfAborted();
+    const page = await source.fetchSnapshots({
+      date: options.date,
+      timezone: options.timezone,
+      cursor,
+      signal: options.signal
+    });
+    pages += 1;
+    fetched += page.snapshots.length;
+    for (const snapshot of page.snapshots) {
+      const result = options.store.insertSnapshot(snapshotForMachine(snapshot, source.machineLabel));
+      if (result.inserted) inserted += 1;
+      else duplicates += 1;
+    }
+    if (page.nextCursor === null) {
+      completed = true;
+      break;
+    }
+    if (typeof page.nextCursor !== "string" || page.nextCursor.length === 0) {
+      throw new TypeError("activity source returned an invalid cursor");
+    }
+    if (seenCursors.has(page.nextCursor)) {
+      throw new Error("activity source returned a repeated cursor");
+    }
+    seenCursors.add(page.nextCursor);
+    cursor = page.nextCursor;
+  }
+  if (!completed) {
+    throw new Error(`activity source exceeded ${maxPages} pages`);
+  }
+  options.signal?.throwIfAborted();
+  const digestWritten = await withDigestLock(`${options.memoryDir}\0${options.date}`, async () => {
+    options.signal?.throwIfAborted();
+    const { startUtc, endUtc } = activityDayWindow(options.date, options.timezone);
+    const snapshots = options.store.listSnapshotsForDay(null, startUtc, endUtc);
+    const body = composeActivityDigestBody(options.date, options.timezone, snapshots);
+    const machines = [...new Set(snapshots.map((snapshot) => snapshot.machine))].sort(
+      (a, b) => a < b ? -1 : a > b ? 1 : 0
+    );
+    const serialized = serializeActivityDigest(composeActivityDigestMeta(options.date, machines, snapshots, body), body);
+    return writeDigestIfChanged(options.memoryDir, options.date, serialized);
+  });
+  options.signal?.throwIfAborted();
+  options.store.setCursor(cursorKey, cursor);
+  let reindexError;
+  if (digestWritten && options.afterWrites !== void 0) {
+    try {
+      await options.afterWrites(options.signal);
+    } catch (error) {
+      reindexError = error instanceof Error && error.message.startsWith("QMD ") ? error.message : displayErrorDetail(error) || "reindex failed";
+    }
+  }
+  return {
+    machine: source.machineLabel,
+    fetched,
+    inserted,
+    duplicates,
+    cursor,
+    digestWritten,
+    ...reindexError === void 0 ? {} : { reindexError }
+  };
+}
+
+// src/activity/source-client.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringField(value, field) {
+  const result = value[field];
+  if (typeof result !== "string" || result.length === 0) {
+    throw new TypeError(`activity source response has no valid ${field}`);
+  }
+  return result;
+}
+function contentStringField(value, field) {
+  const result = value[field];
+  if (typeof result !== "string") {
+    throw new TypeError(`activity source response has invalid ${field}`);
+  }
+  return result;
+}
+function optionalStringField(value, field) {
+  const result = value[field];
+  if (result === void 0 || result === null) return void 0;
+  if (typeof result !== "string") throw new TypeError(`activity source response has invalid ${field}`);
+  return result;
+}
+function snapshotFromWire(value, machine) {
+  if (!isRecord2(value)) throw new TypeError("activity source returned a non-object snapshot");
+  const textSource = stringField(value, "textSource");
+  if (textSource !== "ax" && textSource !== "ocr") {
+    throw new TypeError("activity source response has invalid textSource");
+  }
+  const browserUrl = optionalStringField(value, "browserUrl");
+  const simhash = optionalStringField(value, "simhash");
+  return {
+    machine,
+    capturedAtUtc: stringField(value, "capturedAtUtc"),
+    app: contentStringField(value, "app"),
+    windowTitle: contentStringField(value, "windowTitle"),
+    ...browserUrl === void 0 ? {} : { browserUrl },
+    text: contentStringField(value, "text"),
+    textSource,
+    contentHash: stringField(value, "contentHash"),
+    ...simhash === void 0 ? {} : { simhash }
+  };
+}
+function responsePage(value, machine) {
+  if (!isRecord2(value) || !Array.isArray(value.snapshots)) {
+    throw new TypeError("activity source response has no snapshots array");
+  }
+  const nextCursor = value.nextCursor === void 0 ? null : value.nextCursor;
+  if (nextCursor !== null && typeof nextCursor !== "string") {
+    throw new TypeError("activity source response has invalid nextCursor");
+  }
+  return {
+    snapshots: value.snapshots.map((snapshot) => snapshotFromWire(snapshot, machine)),
+    nextCursor
+  };
+}
+function requestUrl(baseUrl, path6, query) {
+  const url = new URL(path6, baseUrl);
+  const parts = Object.entries(query).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+  url.search = parts.join("&");
+  return url.toString();
+}
+var ActivityHttpSourceClient = class {
+  machineLabel;
+  baseUrl;
+  token;
+  timeoutMs;
+  constructor(options) {
+    if (options.machineLabel.trim().length === 0) throw new RangeError("activity source machine label must not be empty");
+    if (options.timeoutMs !== void 0 && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+      throw new RangeError("activity source timeoutMs must be a positive number");
+    }
+    this.machineLabel = options.machineLabel;
+    this.baseUrl = validateActivityBaseUrl(options.baseUrl).toString();
+    this.token = options.token;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  async request(url, signal) {
+    const timeout = AbortSignal.timeout(this.timeoutMs);
+    const composed = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+    const response = await fetch(url, {
+      headers: this.token === void 0 ? void 0 : { authorization: `Bearer ${this.token}` },
+      signal: composed
+    });
+    if (!response.ok) throw new Error(`activity source HTTP ${response.status}`);
+    return response;
+  }
+  async verify(signal) {
+    try {
+      await this.request(requestUrl(this.baseUrl, "/v1/health", {}), signal);
+      return { ok: true };
+    } catch (error) {
+      const detail = error instanceof Error && error.message.startsWith("activity source HTTP ") ? error.message.slice("activity source ".length) : displayErrorDetail(error) || "request failed";
+      return { ok: false, detail };
+    }
+  }
+  async fetchSnapshots(opts) {
+    const response = await this.request(
+      requestUrl(this.baseUrl, "/v1/snapshots", {
+        date: opts.date,
+        timezone: opts.timezone,
+        cursor: opts.cursor ?? void 0
+      }),
+      opts.signal
+    );
+    return responsePage(await response.json(), this.machineLabel);
+  }
+};
+
+// src/activity/timeline/regenerate.ts
+import { randomBytes } from "crypto";
+import { mkdirSync as mkdirSync3, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import path4 from "path";
+
+// src/activity/timeline/corrections.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import path3 from "path";
+function timelineCorrectionDatabasePath(memoryDir) {
+  return path3.join(memoryDir, "state", "activity-timeline.sqlite");
+}
+function rowToCorrection(row) {
+  return {
+    cardId: row.card_id,
+    categoryId: row.category_id ?? void 0,
+    title: row.title ?? void 0,
+    editedAtUtc: row.edited_at_utc
+  };
+}
+var TimelineCorrectionStore = class _TimelineCorrectionStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static open(memoryDir) {
+    mkdirSync2(path3.join(memoryDir, "state"), { recursive: true });
+    const db = openBetterSqlite3(timelineCorrectionDatabasePath(memoryDir));
+    db.pragma("journal_mode = WAL");
+    db.pragma("busy_timeout = 5000");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS timeline_corrections (
+        card_id       TEXT PRIMARY KEY,
+        category_id   TEXT,
+        title         TEXT,
+        edited_at_utc TEXT NOT NULL
+      );
+    `);
+    return new _TimelineCorrectionStore(db);
+  }
+  /**
+   * Persist one correction. `categoryId`, when set, must exist in `categories`
+   * (defaults to the built-in registry) — an unknown category is a malformed
+   * edit and must fail rather than silently strand the card.
+   */
+  upsert(correction, categories = DEFAULT_TIMELINE_CATEGORIES) {
+    validateTimelineCategories(categories);
+    if (typeof correction.cardId !== "string" || correction.cardId.length === 0) {
+      throw new RangeError("timeline correction requires a non-empty cardId");
+    }
+    if (typeof correction.editedAtUtc !== "string" || Number.isNaN(Date.parse(correction.editedAtUtc))) {
+      throw new RangeError("timeline correction requires a valid editedAtUtc instant");
+    }
+    if (correction.categoryId === void 0 && correction.title === void 0 || correction.title !== void 0 && correction.title.length === 0) {
+      throw new RangeError("timeline correction must set a categoryId and/or a non-empty title");
+    }
+    if (correction.categoryId !== void 0 && !categories.some((category) => category.id === correction.categoryId)) {
+      throw new RangeError(`timeline correction targets unknown category: ${correction.categoryId}`);
+    }
+    this.db.prepare(
+      `INSERT INTO timeline_corrections (card_id, category_id, title, edited_at_utc)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(card_id) DO UPDATE SET category_id = excluded.category_id, title = excluded.title, edited_at_utc = excluded.edited_at_utc`
+    ).run(correction.cardId, correction.categoryId ?? null, correction.title ?? null, correction.editedAtUtc);
+  }
+  get(cardId) {
+    const row = this.db.prepare("SELECT card_id, category_id, title, edited_at_utc FROM timeline_corrections WHERE card_id = ?").get(cardId);
+    return row === void 0 ? void 0 : rowToCorrection(row);
+  }
+  /** All corrections ordered by card id (deterministic listing). */
+  list() {
+    return this.db.prepare("SELECT card_id, category_id, title, edited_at_utc FROM timeline_corrections ORDER BY card_id ASC").all().map((row) => rowToCorrection(row));
+  }
+  /** Explicitly reset a card to its derived values; true when a correction existed. */
+  reset(cardId) {
+    return this.db.prepare("DELETE FROM timeline_corrections WHERE card_id = ?").run(cardId).changes > 0;
+  }
+  close() {
+    this.db.close();
+  }
+};
+function correctionsForCards(cards, corrections) {
+  const ids = new Set(cards.map((card) => card.id));
+  return corrections.filter((correction) => ids.has(correction.cardId));
+}
+function applyTimelineCorrections(cards, corrections) {
+  const byCardId = new Map(corrections.map((correction) => [correction.cardId, correction]));
+  return cards.map((card) => {
+    const correction = byCardId.get(card.id);
+    if (correction === void 0) return card;
+    return {
+      id: card.id,
+      kind: card.kind,
+      title: correction.title ?? card.title,
+      summary: card.summary,
+      categoryId: correction.categoryId ?? card.categoryId,
+      confidence: 1,
+      startUtc: card.startUtc,
+      endUtc: card.endUtc,
+      dayKey: card.dayKey,
+      timezone: card.timezone,
+      machine: card.machine,
+      evidenceIds: card.evidenceIds,
+      evidenceRange: card.evidenceRange,
+      manualEdit: {
+        ...correction.categoryId !== void 0 ? { categoryId: correction.categoryId } : {},
+        ...correction.title !== void 0 ? { title: correction.title } : {},
+        editedAtUtc: correction.editedAtUtc
+      }
+    };
+  });
+}
+
+// src/activity/timeline/build.ts
+import { createHash } from "crypto";
+
+// src/activity/timeline/classify.ts
+var DOMAIN_CONFIDENCE = 0.85;
+var APP_CONFIDENCE = 0.9;
+var TITLE_CONFIDENCE = 0.7;
+var UNKNOWN_CONFIDENCE = 0;
+var RULES = [
+  { categoryId: "development", domains: ["github.com", "gitlab.com", "stackoverflow.com", "linear.app", "atlassian.net"] },
+  { categoryId: "communication", domains: ["mail.google.com", "gmail.com", "outlook.com", "outlook.office.com", "slack.com"] },
+  { categoryId: "design", domains: ["figma.com", "canva.com"] },
+  { categoryId: "documents", domains: ["docs.google.com", "notion.so", "dropbox.com"] },
+  { categoryId: "entertainment", domains: ["youtube.com", "netflix.com", "spotify.com"] },
+  { categoryId: "data", domains: ["metabase", "tableau", "grafana"] },
+  { categoryId: "development", apps: ["code", "cursor", "neovim", "vim", "emacs", "xcode", "intellij", "terminal", "iterm", "warp", "wezterm", "kitty", "alacritty", "zed", "sublime", "datagrip"] },
+  { categoryId: "communication", apps: ["slack", "discord", "teams", "mail", "outlook", "thunderbird", "messages", "signal", "whatsapp", "telegram", "zoom", "facetime", "meet"] },
+  { categoryId: "design", apps: ["figma", "sketch", "photoshop", "illustrator", "indesign", "premiere", "after effects", "davinci", "blender", "ableton", "logic pro", "final cut"] },
+  { categoryId: "documents", apps: ["word", "pages", "notion", "obsidian", "notes", "typora", "bear", "preview", "acrobat"] },
+  { categoryId: "data", apps: ["excel", "numbers", "sheets", "tableau"] },
+  { categoryId: "admin", apps: ["finder", "settings", "system preferences", "activity monitor", "files", "explorer"] },
+  { categoryId: "entertainment", apps: ["spotify", "music", "youtube", "vlc", "quicktime", "steam", "netflix", "podcast", "tv"] },
+  { categoryId: "browsing", apps: ["chrome", "safari", "firefox", "edge", "arc", "brave", "browser"] },
+  { categoryId: "development", titles: ["pull request", "merge conflict", "terminal \u2014", "repository"] },
+  { categoryId: "communication", titles: ["inbox"] },
+  { categoryId: "data", titles: ["spreadsheet", "pivot table"] }
+];
+function classifyTimelineObservation(observation, categories) {
+  const app = observation.app.toLowerCase();
+  const title = observation.windowTitle.toLowerCase();
+  const domain = observation.browserUrl === void 0 ? "" : hostOf(observation.browserUrl);
+  for (const rule of RULES) {
+    if (rule.domains !== void 0 && domain !== "" && rule.domains.some((pattern) => domain.includes(pattern))) {
+      return checkedRule(rule, DOMAIN_CONFIDENCE, categories);
+    }
+  }
+  for (const rule of RULES) {
+    if (rule.apps !== void 0 && rule.apps.some((pattern) => app.includes(pattern))) {
+      return checkedRule(rule, APP_CONFIDENCE, categories);
+    }
+  }
+  for (const rule of RULES) {
+    if (rule.titles !== void 0 && rule.titles.some((pattern) => title.includes(pattern))) {
+      return checkedRule(rule, TITLE_CONFIDENCE, categories);
+    }
+  }
+  return { categoryId: TIMELINE_RESERVED_UNKNOWN, confidence: UNKNOWN_CONFIDENCE };
+}
+function checkedRule(rule, confidence, categories) {
+  if (!categories.some((category) => category.id === rule.categoryId)) {
+    throw new RangeError(`timeline classification rule targets unknown category: ${rule.categoryId}`);
+  }
+  return { categoryId: rule.categoryId, confidence };
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
+
+// src/activity/timeline/build.ts
+var TIMELINE_FORMAT_VERSION = 1;
+var TIMELINE_MERGE_GAP_MS = 12e4;
+var TIMELINE_MAX_DWELL_MS = 15 * 6e4;
+function canonicalMs(iso) {
+  const parsed = Date.parse(iso);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+}
+function isoOf(ms) {
+  return new Date(ms).toISOString();
+}
+function evidenceKeyOf(observation) {
+  return `${observation.machine}|${isoOf(canonicalMs(observation.capturedAtUtc))}|${observation.contentHash}`;
+}
+function stableCardId(identity) {
+  return `tlc_${createHash("sha256").update(identity, "utf8").digest("hex").slice(0, 16)}`;
+}
+function formatDurationMinutes(ms) {
+  return `${Math.round(ms / 6e4)}m`;
+}
+function unionIntervals(intervals) {
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const merged = [];
+  for (const interval of sorted) {
+    const last = merged[merged.length - 1];
+    if (last !== void 0 && interval[0] <= last[1]) {
+      last[1] = Math.max(last[1], interval[1]);
+    } else {
+      merged.push([interval[0], interval[1]]);
+    }
+  }
+  return merged;
+}
+function subtractInterval(start, end, cutStart, cutEnd) {
+  if (cutEnd <= start || cutStart >= end) return [[start, end]];
+  const pieces = [];
+  if (cutStart > start) pieces.push([start, cutStart]);
+  if (cutEnd < end) pieces.push([cutEnd, end]);
+  return pieces;
+}
+function mergeTrack(machine, track, pauses) {
+  const cards = [];
+  let current = [];
+  const pauseStartsAfter = (fromMs, toMs) => pauses.some(([ps, pe]) => ps >= fromMs && ps < toMs && pe > ps);
+  for (const observation of track) {
+    const last = current[current.length - 1];
+    if (last !== void 0) {
+      const gap = canonicalMs(observation.capturedAtUtc) - canonicalMs(last.capturedAtUtc);
+      const sameKey = observation.app === last.app && observation.windowTitle === last.windowTitle;
+      const pauseBetween = pauseStartsAfter(canonicalMs(last.capturedAtUtc), canonicalMs(observation.capturedAtUtc));
+      if (!sameKey || gap > TIMELINE_MERGE_GAP_MS || pauseBetween) {
+        cards.push({ machine, observations: current });
+        current = [];
+      }
+    }
+    current.push(observation);
+  }
+  if (current.length > 0) cards.push({ machine, observations: current });
+  return cards;
+}
+function buildTimelineDay(input) {
+  const categories = input.categories ?? DEFAULT_TIMELINE_CATEGORIES;
+  validateTimelineCategories(categories);
+  const window = activityDayWindow(input.date, input.timezone);
+  const dayStartMs = Date.parse(window.startUtc);
+  const dayEndMs = Date.parse(window.endUtc);
+  const observations = input.observations.filter((observation) => Number.isFinite(canonicalMs(observation.capturedAtUtc))).filter((observation) => {
+    const ms = canonicalMs(observation.capturedAtUtc);
+    return ms >= dayStartMs && ms < dayEndMs;
+  });
+  for (const pause of input.pauses ?? []) {
+    const startMs = canonicalMs(pause.startUtc);
+    const endMs = canonicalMs(pause.endUtc);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs >= endMs) {
+      throw new RangeError("timeline pause must be a valid half-open [startUtc, endUtc) interval");
+    }
+  }
+  const pauseIntervals = unionIntervals(
+    (input.pauses ?? []).map((pause) => [canonicalMs(pause.startUtc), canonicalMs(pause.endUtc)]).map(([startMs, endMs]) => [Math.max(startMs, dayStartMs), Math.min(endMs, dayEndMs)]).filter(([startMs, endMs]) => endMs > startMs)
+  );
+  const tracks = /* @__PURE__ */ new Map();
+  for (const observation of observations) {
+    const track = tracks.get(observation.machine) ?? [];
+    track.push(observation);
+    tracks.set(observation.machine, track);
+  }
+  for (const track of tracks.values()) {
+    track.sort(
+      (a, b) => canonicalMs(a.capturedAtUtc) - canonicalMs(b.capturedAtUtc) || (a.contentHash < b.contentHash ? -1 : a.contentHash > b.contentHash ? 1 : 0)
+    );
+  }
+  const cards = [];
+  const machines = [...tracks.keys()].sort();
+  for (const machine of machines) {
+    const track = tracks.get(machine) ?? [];
+    const merged = mergeTrack(machine, track, pauseIntervals);
+    const trackIntervals = [];
+    for (let index = 0; index < merged.length; index++) {
+      const group = merged[index];
+      const first = group.observations[0];
+      const last = group.observations[group.observations.length - 1];
+      const startMs = canonicalMs(first.capturedAtUtc);
+      const lastMs = canonicalMs(last.capturedAtUtc);
+      const nextObsMs = index + 1 < merged.length ? canonicalMs(merged[index + 1].observations[0].capturedAtUtc) : Number.POSITIVE_INFINITY;
+      const pauseStartMs = pauseIntervals.find(([ps]) => ps > lastMs)?.[0] ?? Number.POSITIVE_INFINITY;
+      const endMs = Math.max(lastMs, Math.min(lastMs + TIMELINE_MAX_DWELL_MS, nextObsMs, pauseStartMs, dayEndMs));
+      trackIntervals.push([startMs, endMs]);
+      const evidenceIds = group.observations.map((observation) => observation.id);
+      const classification = classifyTimelineObservation(first, categories);
+      cards.push({
+        id: stableCardId(`activity|${machine}|${evidenceKeyOf(first)}|${evidenceKeyOf(last)}`),
+        kind: "activity",
+        title: first.windowTitle.length > 0 ? first.windowTitle : first.app,
+        summary: `${first.app} \xB7 ${machine} \xB7 ${evidenceIds.length} obs \xB7 ${formatDurationMinutes(endMs - startMs)}`,
+        categoryId: classification.categoryId,
+        confidence: classification.confidence,
+        startUtc: isoOf(startMs),
+        endUtc: isoOf(endMs),
+        dayKey: input.date,
+        timezone: input.timezone,
+        machine,
+        evidenceIds,
+        evidenceRange: { firstKey: evidenceKeyOf(first), lastKey: evidenceKeyOf(last) }
+      });
+    }
+    for (let index = 0; index + 1 < trackIntervals.length; index++) {
+      const gapStart = trackIntervals[index][1];
+      const gapEnd = trackIntervals[index + 1][0];
+      if (gapEnd <= gapStart) continue;
+      let pieces = [[gapStart, gapEnd]];
+      for (const [pauseStart, pauseEnd] of pauseIntervals) {
+        pieces = pieces.flatMap(([start, end]) => subtractInterval(start, end, pauseStart, pauseEnd));
+      }
+      for (const [start, end] of pieces) {
+        cards.push({
+          id: stableCardId(`idle|${machine}|${isoOf(start)}|${isoOf(end)}`),
+          kind: "idle",
+          title: "Idle",
+          summary: `${formatDurationMinutes(end - start)} gap on ${machine}`,
+          categoryId: TIMELINE_RESERVED_IDLE,
+          confidence: 1,
+          startUtc: isoOf(start),
+          endUtc: isoOf(end),
+          dayKey: input.date,
+          timezone: input.timezone,
+          machine,
+          evidenceIds: [],
+          evidenceRange: null
+        });
+      }
+    }
+  }
+  for (const [pauseStart, pauseEnd] of pauseIntervals) {
+    const reason = (input.pauses ?? []).find((pause) => canonicalMs(pause.startUtc) === pauseStart)?.reason;
+    cards.push({
+      id: stableCardId(`pause|${isoOf(pauseStart)}|${isoOf(pauseEnd)}`),
+      kind: "pause",
+      title: "Paused",
+      summary: reason === void 0 ? `${formatDurationMinutes(pauseEnd - pauseStart)} user pause` : `${formatDurationMinutes(pauseEnd - pauseStart)} user pause \u2014 ${reason}`,
+      categoryId: TIMELINE_RESERVED_PAUSE,
+      confidence: 1,
+      startUtc: isoOf(pauseStart),
+      endUtc: isoOf(pauseEnd),
+      dayKey: input.date,
+      timezone: input.timezone,
+      machine: null,
+      evidenceIds: [],
+      evidenceRange: null
+    });
+  }
+  cards.sort((a, b) => a.startUtc < b.startUtc ? -1 : a.startUtc > b.startUtc ? 1 : a.endUtc < b.endUtc ? -1 : a.endUtc > b.endUtc ? 1 : (a.machine ?? "") < (b.machine ?? "") ? -1 : (a.machine ?? "") > (b.machine ?? "") ? 1 : a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return {
+    formatVersion: TIMELINE_FORMAT_VERSION,
+    date: input.date,
+    timezone: input.timezone,
+    startUtc: window.startUtc,
+    endUtc: window.endUtc,
+    cards
+  };
+}
+function serializeTimelineDay(day) {
+  return JSON.stringify(day);
+}
+
+// src/activity/timeline/analysis-run.ts
+async function runTimelineCardAnalysis(input) {
+  const { startUtc, endUtc } = activityDayWindow(input.date, input.timezone);
+  if (!input.config.enabled) {
+    return { status: "disabled", cards: input.cards };
+  }
+  const start = Date.parse(startUtc);
+  const end = Date.parse(endUtc);
+  const observations = input.observations.filter((observation) => {
+    const captured = Date.parse(observation.capturedAtUtc);
+    return Number.isFinite(captured) && captured >= start && captured < end;
+  });
+  const result = await analyzeTimelineCards({
+    enabled: true,
+    cards: input.cards,
+    observations,
+    provider: input.config.provider,
+    model: input.config.model,
+    complete: timelineAnalysisCompleteFromClients({
+      localLlm: input.deps.localLlm ?? null,
+      remoteLlm: input.deps.remoteLlm ?? null
+    }),
+    ...input.config.timeoutMs === void 0 ? {} : { timeoutMs: input.config.timeoutMs },
+    date: input.date,
+    timezone: input.timezone,
+    ...input.categories === void 0 ? {} : { categories: input.categories },
+    ...input.config.preferences === void 0 ? {} : { preferences: input.config.preferences },
+    ...input.corrections === void 0 ? {} : { priorEdits: input.corrections },
+    ...input.signal === void 0 ? {} : { signal: input.signal }
+  });
+  if (result.status !== "ok") {
+    return {
+      status: result.status,
+      cards: result.cards,
+      ...result.failure === void 0 ? {} : { failure: result.failure }
+    };
+  }
+  return {
+    status: "ok",
+    cards: result.cards,
+    metadata: buildAnalysisRunMetadata({
+      provider: result.provider ?? "unknown",
+      model: result.model ?? "unknown",
+      promptVersion: String(result.promptVersion ?? "v0"),
+      observationCount: observations.length
+    })
+  };
+}
+
+// src/activity/timeline/regenerate.ts
+var TIMELINE_DAY_FORMAT_VERSION = 1;
+var TIMELINE_DAY_DIR = path4.join("activity", "timeline");
+var inflight = /* @__PURE__ */ new Map();
+function requireToken(value, name) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function timelineDayPath(memoryDir, date) {
+  const root = requireToken(memoryDir, "memoryDir");
+  if (!isValidActivityDate(date)) {
+    throw new RangeError("date must be a real YYYY-MM-DD day");
+  }
+  return path4.join(path4.resolve(root), TIMELINE_DAY_DIR, `${date}.json`);
+}
+function snapshotToObservation(snapshot) {
+  if (typeof snapshot.id !== "number") return null;
+  return {
+    id: snapshot.id,
+    machine: snapshot.machine,
+    capturedAtUtc: snapshot.capturedAtUtc,
+    app: snapshot.app,
+    windowTitle: snapshot.windowTitle,
+    ...snapshot.browserUrl === void 0 ? {} : { browserUrl: snapshot.browserUrl },
+    contentHash: snapshot.contentHash
+  };
+}
+function localDatesForUtcRange(fromMs, toMs, timezone) {
+  if (!Number.isFinite(fromMs) || !Number.isFinite(toMs) || toMs <= fromMs) return [];
+  const dates = [];
+  let date = activityDateInTimezone(new Date(fromMs), timezone);
+  const last = activityDateInTimezone(new Date(toMs - 1), timezone);
+  while (dates.length < 3660) {
+    dates.push(date);
+    if (date === last) break;
+    const { endUtc } = activityDayWindow(date, timezone);
+    date = activityDateInTimezone(new Date(Date.parse(endUtc)), timezone);
+  }
+  return dates;
+}
+function listPersistedTimelineDates(memoryDir) {
+  let entries;
+  try {
+    entries = readdirSync(path4.join(path4.resolve(requireToken(memoryDir, "memoryDir")), TIMELINE_DAY_DIR));
+  } catch {
+    return [];
+  }
+  const dates = [];
+  for (const entry of entries) {
+    const day = entry.endsWith(".json") ? entry.slice(0, -".json".length) : entry;
+    if (isValidActivityDate(day)) dates.push(day);
+  }
+  return dates.sort();
+}
+function resolveTimelineLoadDates(input) {
+  const { window, timezone, today, store, persistedDates } = input;
+  if (window.from !== void 0 || window.to !== void 0) {
+    const parsedTo = window.to === void 0 ? Number.NaN : Date.parse(window.to);
+    const fromMs = window.from === void 0 ? parsedTo : Date.parse(window.from);
+    const toMs = window.to === void 0 ? fromMs + 1 : parsedTo;
+    if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) return [];
+    return localDatesForUtcRange(fromMs, toMs > fromMs ? toMs : fromMs + 1, timezone);
+  }
+  const days = new Set(persistedDates);
+  days.add(today);
+  const extent = store.snapshotCaptureExtent();
+  if (extent !== null) {
+    const firstMs = Date.parse(extent.firstUtc);
+    const lastMs = Date.parse(extent.lastUtc);
+    if (Number.isFinite(firstMs) && Number.isFinite(lastMs) && lastMs >= firstMs) {
+      for (const day of localDatesForUtcRange(firstMs, lastMs + 1, timezone)) days.add(day);
+    }
+  }
+  return [...days].sort();
+}
+function timelineAnalysisClientsFromConfig(config) {
+  return {
+    localLlm: new LocalLlmClient(config),
+    remoteLlm: new FallbackLlmClient(
+      config.gatewayConfig,
+      fallbackLlmRuntimeContextFromConfig(config)
+    )
+  };
+}
+function resolveClients(input) {
+  if (input.deps !== void 0) return input.deps;
+  if (input.pluginConfig !== void 0) return timelineAnalysisClientsFromConfig(input.pluginConfig);
+  return {};
+}
+function sourceHash(input) {
+  return hashActivityBody(
+    JSON.stringify({
+      // The timezone is a day-window determinant (it bounds which
+      // observations the day sees), so it belongs to the source identity:
+      // identical observations under a different timezone must not reuse
+      // the cached day (issue #2891).
+      timezone: input.timezone,
+      observations: input.observations.map((observation) => ({
+        id: observation.id,
+        contentHash: observation.contentHash,
+        capturedAtUtc: observation.capturedAtUtc
+      })),
+      analysis: {
+        enabled: input.analysis.enabled,
+        provider: input.analysis.provider ?? null,
+        model: input.analysis.model ?? null,
+        timeoutMs: input.analysis.timeoutMs ?? null,
+        preferences: input.analysis.preferences ?? null
+      },
+      corrections: input.corrections
+    })
+  );
+}
+function readPersisted(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    if (parsed?.formatVersion !== TIMELINE_DAY_FORMAT_VERSION || !Array.isArray(parsed.cards)) {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    return null;
+  }
+}
+function persistDay(filePath, payload) {
+  const text = `${JSON.stringify(payload)}
+`;
+  try {
+    if (readFileSync(filePath, "utf8") === text) return false;
+  } catch (error) {
+    if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
+  }
+  mkdirSync3(path4.dirname(filePath), { recursive: true, mode: 448 });
+  const tmpPath = `${filePath}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+  writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
+  try {
+    renameSync(tmpPath, filePath);
+  } catch (error) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw error;
+  }
+  return true;
+}
+function toResult(filePath, written, analyzed, day) {
+  return {
+    status: day.status,
+    cards: day.cards,
+    path: filePath,
+    written,
+    analyzed,
+    ...day.metadata === void 0 ? {} : { metadata: day.metadata },
+    ...day.failure === void 0 ? {} : { failure: day.failure }
+  };
+}
+function isCachedDayFinal(status, analysisEnabled) {
+  if (analysisEnabled) {
+    return status === "ok" || status === "provider_failed" || status === "invalid_output";
+  }
+  return status === "disabled";
+}
+async function regenerateUncached(input) {
+  const date = requireToken(input.date, "date");
+  const timezone = requireToken(input.timezone, "timezone");
+  const filePath = timelineDayPath(input.memoryDir, date);
+  if (!input.timelineEnabled) {
+    return toResult(filePath, false, false, { status: "timeline_disabled", cards: [] });
+  }
+  const { startUtc, endUtc } = activityDayWindow(date, timezone);
+  const observations = input.store.listSnapshotsForDay(null, startUtc, endUtc).map(snapshotToObservation).filter((observation) => observation !== null);
+  let corrections = input.corrections;
+  let opened;
+  if (corrections === void 0) {
+    opened = TimelineCorrectionStore.open(input.memoryDir);
+    corrections = opened.list();
+  }
+  try {
+    const rawCards = buildTimelineDay({ date, timezone, observations }).cards;
+    corrections = correctionsForCards(rawCards, corrections);
+    const built = applyTimelineCorrections(rawCards, corrections);
+    const hash = sourceHash({ timezone, observations, analysis: input.analysis, corrections });
+    const prior = readPersisted(filePath);
+    if (prior !== null && prior.sourceHash === hash && isCachedDayFinal(prior.status, input.analysis.enabled)) {
+      return toResult(filePath, false, false, prior);
+    }
+    const deterministic = {
+      formatVersion: TIMELINE_DAY_FORMAT_VERSION,
+      date,
+      timezone,
+      sourceHash: hash,
+      status: input.analysis.enabled ? "pending" : "disabled",
+      cards: built
+    };
+    persistDay(filePath, deterministic);
+    if (!input.analysis.enabled) {
+      return toResult(filePath, true, false, deterministic);
+    }
+    const deps = resolveClients(input);
+    const analyzed = await runTimelineCardAnalysis({
+      date,
+      timezone,
+      cards: built,
+      observations,
+      corrections,
+      config: input.analysis,
+      deps,
+      ...input.signal === void 0 ? {} : { signal: input.signal }
+    });
+    const next = {
+      formatVersion: TIMELINE_DAY_FORMAT_VERSION,
+      date,
+      timezone,
+      sourceHash: hash,
+      status: analyzed.status,
+      cards: analyzed.cards,
+      ...analyzed.metadata === void 0 ? {} : { metadata: analyzed.metadata },
+      ...analyzed.failure === void 0 ? {} : { failure: analyzed.failure }
+    };
+    persistDay(filePath, next);
+    return toResult(filePath, true, analyzed.status === "ok", next);
+  } finally {
+    opened?.close();
+  }
+}
+async function regenerateTimelineDay(input) {
+  const key = `${path4.resolve(requireToken(input.memoryDir, "memoryDir"))}\0${input.date}`;
+  const pending = inflight.get(key);
+  if (pending !== void 0) return pending;
+  const run = regenerateUncached(input).finally(() => {
+    if (inflight.get(key) === run) inflight.delete(key);
+  });
+  inflight.set(key, run);
+  return run;
+}
+
+// src/activity/runner.ts
+function previousIsoDate(date) {
+  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  parsed.setUTCDate(parsed.getUTCDate() - 1);
+  return parsed.toISOString().slice(0, 10);
+}
+function resolveActivitySyncDates(syncDays, timezone, now) {
+  const dates = [];
+  let cursor = activityDateInTimezone(now, timezone);
+  for (let count = 0; count < syncDays; count++) {
+    dates.unshift(cursor);
+    cursor = previousIsoDate(cursor);
+  }
+  return dates;
+}
+function sanitizedSyncError(error) {
+  return error instanceof Error && /^(activity|Invalid activity)/.test(error.message) ? error.message : displayErrorDetail(error) || "activity sync failed";
+}
+async function runActivitySyncOnce(options) {
+  const ranAt = typeof options.now === "function" ? options.now() : options.now ?? /* @__PURE__ */ new Date();
+  if (!options.config.enabled) {
+    return {
+      ranAt: ranAt.toISOString(),
+      enabled: false,
+      ranCount: 0,
+      errorCount: 0,
+      reindexErrorCount: 0,
+      totalInserted: 0,
+      results: [],
+      touchedDates: []
+    };
+  }
+  const dates = resolveActivitySyncDates(options.config.syncDays, options.config.timezone, ranAt);
+  const createSourceClient = options.createSourceClient ?? ((source) => new ActivityHttpSourceClient({
+    machineLabel: source.machineLabel,
+    baseUrl: source.baseUrl,
+    ...source.token === void 0 ? {} : { token: source.token }
+  }));
+  const ownStore = options.store === void 0;
+  const store = options.store ?? ActivityStore.open(options.memoryDir);
+  const results = [];
+  const touchedDates = /* @__PURE__ */ new Set();
+  try {
+    for (const sourceConfig of options.config.sources) {
+      const item = {
+        machineLabel: sourceConfig.machineLabel,
+        ran: false,
+        fetched: 0,
+        inserted: 0,
+        duplicates: 0,
+        digestsWritten: 0,
+        // Cursors are now per (machine, date); report the last synced day's
+        // cursor. Null until a day advances it.
+        cursor: null
+      };
+      try {
+        const client = createSourceClient(sourceConfig);
+        for (const date of dates) {
+          try {
+            const result = await syncActivitySource(client, {
+              date,
+              timezone: options.config.timezone,
+              memoryDir: options.memoryDir,
+              store,
+              signal: options.signal,
+              ...options.reindexSearch === void 0 ? {} : { afterWrites: options.reindexSearch }
+            });
+            item.fetched += result.fetched;
+            item.inserted += result.inserted;
+            if (result.inserted > 0) touchedDates.add(date);
+            item.duplicates += result.duplicates;
+            if (result.digestWritten) item.digestsWritten += 1;
+            item.cursor = result.cursor;
+            item.ran = true;
+            if (result.reindexError !== void 0) item.reindexError = result.reindexError;
+          } catch (dateError) {
+            item.error = sanitizedSyncError(dateError);
+            if (options.signal?.aborted) break;
+          }
+        }
+      } catch (error) {
+        item.error = sanitizedSyncError(error);
+      }
+      results.push(item);
+      if (options.signal?.aborted) break;
+    }
+    if (options.config.timeline.enabled && !options.signal?.aborted) {
+      for (const date of dates) {
+        try {
+          await regenerateTimelineDay({
+            date,
+            timezone: options.config.timezone,
+            memoryDir: options.memoryDir,
+            store,
+            timelineEnabled: true,
+            analysis: options.config.timeline.analysis,
+            ...options.pluginConfig === void 0 ? {} : { pluginConfig: options.pluginConfig },
+            ...options.analysisDeps === void 0 ? {} : { deps: options.analysisDeps },
+            ...options.signal === void 0 ? {} : { signal: options.signal }
+          });
+        } catch {
+        }
+      }
+    }
+  } finally {
+    if (ownStore) store.close();
+  }
+  return {
+    ranAt: ranAt.toISOString(),
+    enabled: true,
+    ranCount: results.filter((item) => item.ran).length,
+    errorCount: results.filter((item) => item.error !== void 0).length,
+    reindexErrorCount: results.filter((item) => item.reindexError !== void 0).length,
+    totalInserted: results.reduce((sum, item) => sum + item.inserted, 0),
+    results,
+    touchedDates: [...touchedDates].sort()
+  };
+}
+
+// src/activity/scheduler.ts
+var ACTIVITY_SYNC_DEFAULT_INTERVAL_MS = 9e5;
+var ActivitySyncScheduler = class {
+  config;
+  memoryDir;
+  intervalMs;
+  invoke;
+  setTimer;
+  clearTimer;
+  onRun;
+  onError;
+  handle = null;
+  stopped = false;
+  inFlight = false;
+  inFlightPromise = null;
+  abortController = new AbortController();
+  constructor(options) {
+    this.config = options.config;
+    this.memoryDir = options.memoryDir;
+    this.intervalMs = options.intervalMs ?? ACTIVITY_SYNC_DEFAULT_INTERVAL_MS;
+    this.invoke = options.invoke ?? ((signal) => runActivitySyncOnce({
+      config: this.config,
+      memoryDir: this.memoryDir,
+      signal,
+      ...options.reindexSearch === void 0 ? {} : { reindexSearch: options.reindexSearch },
+      ...options.pluginConfig === void 0 ? {} : { pluginConfig: options.pluginConfig }
+    }));
+    this.setTimer = options.setTimer ?? ((fn, ms) => {
+      const timer = setInterval(fn, ms);
+      timer.unref?.();
+      return timer;
+    });
+    this.clearTimer = options.clearTimer ?? ((handle) => clearInterval(handle));
+    this.onRun = options.onRun;
+    this.onError = options.onError;
+  }
+  /**
+   * Arm the periodic sync. Disabled config (default-off) registers nothing.
+   * Idempotent: a second call while running (or after stop) re-arms nothing.
+   */
+  start() {
+    if (this.handle !== null || this.stopped || !this.config.enabled) {
+      return { registered: this.handle !== null, intervalMs: this.intervalMs };
+    }
+    this.handle = this.setTimer(() => this.tick(), this.intervalMs);
+    return { registered: true, intervalMs: this.intervalMs };
+  }
+  /**
+   * Cancel the periodic sync and abort any in-flight tick, then resolve once it
+   * has unwound. The abort + timer-clear + stop-latch happen synchronously, so
+   * even a caller that cannot await (a sync teardown) still signals the running
+   * sync to stop; async callers can await the returned drain. Idempotent.
+   */
+  async stop() {
+    this.stopped = true;
+    this.abortController.abort();
+    if (this.handle !== null) {
+      this.clearTimer(this.handle);
+      this.handle = null;
+    }
+    await this.inFlightPromise?.catch(() => void 0);
+  }
+  tick() {
+    if (this.stopped || this.inFlight) return;
+    this.inFlight = true;
+    this.inFlightPromise = this.invoke(this.abortController.signal).then((summary) => this.onRun?.(summary)).catch((error) => this.onError?.(error)).finally(() => {
+      this.inFlight = false;
+      this.inFlightPromise = null;
+    });
+  }
+};
+
+// src/activity/sync-registration.ts
+var ActivitySyncRegistrar = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.createScheduler = deps.createScheduler ?? ((options) => new ActivitySyncScheduler(options));
+  }
+  deps;
+  scheduler = null;
+  /** Latched by dispose() so a draining tick's onRun cannot re-arm maintenance. */
+  disposed = false;
+  createScheduler;
+  /** True while a scheduler is armed (test/telemetry observability). */
+  get armed() {
+    return this.scheduler !== null;
+  }
+  /**
+   * Arm (or re-arm) the periodic sync for the current lifecycle. Idempotent and
+   * safe to call repeatedly; always stops a prior scheduler first.
+   */
+  async register(signal) {
+    const prior = this.scheduler;
+    this.scheduler = null;
+    await prior?.stop();
+    if (signal.aborted) return;
+    if (this.deps.secureStoreEnabled && this.deps.config.enabled) {
+      log.warn(
+        "activity sync disabled: secure store is enabled but activity digests/SQLite are not encrypted at rest"
+      );
+      return;
+    }
+    this.disposed = false;
+    try {
+      const scheduler = this.createScheduler({
+        config: this.deps.config,
+        memoryDir: this.deps.memoryDir,
+        intervalMs: this.deps.config.autoSyncIntervalMinutes * 6e4,
+        // Strict refresh after each digest write (rule 31): bypasses the
+        // min-interval gate and throws on a real failure.
+        reindexSearch: (sig) => refreshActivityIndex(this.deps.getQmd(), this.deps.qmdCollection, sig),
+        ...this.deps.pluginConfig === void 0 ? {} : { pluginConfig: this.deps.pluginConfig },
+        // A failed reindex (QMD down) leaves the next unchanged-digest tick
+        // skipping afterWrites, so route the retry through the durable,
+        // throttled QMD path — but never after teardown.
+        onRun: (summary) => {
+          if (summary.reindexErrorCount > 0 && !this.disposed) {
+            log.warn(
+              `activity sync: ${summary.reindexErrorCount} source(s) had a failed reindex; queuing a maintenance retry`
+            );
+            this.deps.requestReindexRetry();
+          }
+          if (summary.enabled && summary.totalInserted > 0 && !this.disposed) {
+            this.deps.onSynced?.(summary);
+          }
+        }
+      });
+      this.scheduler = scheduler;
+      scheduler.start();
+      if (signal.aborted) {
+        await scheduler.stop();
+        this.scheduler = null;
+      }
+    } catch (err) {
+      log.debug(`activity sync scheduler start failed (non-fatal): ${err}`);
+    }
+  }
+  /**
+   * Latch teardown and drain the scheduler. Latching first ensures a draining
+   * tick's onRun cannot queue a retry; the drain is awaited so no in-flight
+   * tick keeps writing after teardown.
+   */
+  async dispose() {
+    this.disposed = true;
+    const drain = this.scheduler?.stop();
+    this.scheduler = null;
+    await drain;
+  }
+};
+
+// src/orchestration/maintenance.ts
+function qmdMaintenanceSkipReasonForError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /^QMD (?:update|embed) skipped by .*min-interval gate$/.test(message) ? "throttled" : null;
+}
+var MaintenanceScheduler = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.activityRegistrar = new ActivitySyncRegistrar({
+      config: deps.config.activity,
+      memoryDir: deps.config.memoryDir,
+      qmdCollection: deps.config.qmdCollection,
+      secureStoreEnabled: resolveRecallAuxiliaryCapabilities(deps.config).secureStore,
+      getQmd: () => deps.getQmd(),
+      requestReindexRetry: () => this.requestQmdMaintenanceForTool("activity-reindex-retry"),
+      pluginConfig: deps.config,
+      ...deps.onActivitySynced ? { onSynced: deps.onActivitySynced } : {}
+    });
+  }
+  deps;
+  // ── Consolidation scheduling state ──
+  nonZeroExtractionsSinceConsolidation = 0;
+  lastConsolidationRunAtMs = 0;
+  consolidationRunPromise = null;
+  disposed = false;
+  // ── QMD maintenance scheduling state ──
+  qmdMaintenanceTimer = null;
+  qmdMaintenancePending = false;
+  qmdMaintenanceInFlight = false;
+  lastQmdEmbedAtMs = 0;
+  lastQmdEmbedAtMsByNamespace = /* @__PURE__ */ new Map();
+  // ── Lifecycle-ledger auto-compaction state (issue #1910) ──
+  lifecycleCompactionInFlight = false;
+  lastLifecycleCompactionAtMs = 0;
+  // Upper bound on a rewritten ledger; a preserving compaction is bounded to
+  // this so it can never leave the ledger over the whole-file read/decrypt cap
+  // (#2033). Defaults to the decrypt cap; overridable in focused tests to drive
+  // the bounding + post-write verification deterministically without a 400MB
+  // fixture.
+  lifecycleLedgerMaxBytes = STATE_FILE_MAX_DECRYPT_BYTES;
+  // ── Memory-projection scheduled-rebuild state (issue #2119) ──
+  projectionRebuild = createProjectionRebuildScheduleState();
+  // ── Activity (screen-capture) sync scheduler (issue #1900) ──
+  // The full arm/re-arm/teardown lifecycle lives in ActivitySyncRegistrar.
+  activityRegistrar;
+  // ── Location day-sync scheduler (issue #2047) — master default-off; the
+  // timer + lifecycle contract lives in location/scheduler.ts.
+  locationAutoSync = null;
+  // ───────────────────────────────────────────────────────────────────────
+  // Cron auto-registration
+  // ───────────────────────────────────────────────────────────────────────
+  /**
+   * Register every cron job the daemon should run, gated by its config flag.
+   * Each registration is independent and non-fatal — a failure in one does
+   * not block the others (mirrors the orchestrator's prior sequential try/
+   * catch behavior exactly).
+   *
+   * Returns when all eligible registrations have completed so callers that
+   * `await deferredReady` can rely on jobs.json being current.
+   */
+  async autoRegisterCrons(signal) {
+    if (resolveRecallAuxiliaryCapabilities(this.deps.config).daySummary) {
+      try {
+        await this.autoRegisterDaySummaryCron();
+      } catch (err) {
+        log.debug(`day-summary cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (this.deps.config.nightlyGovernanceCronAutoRegister) {
+      try {
+        await this.autoRegisterNightlyGovernanceCron();
+      } catch (err) {
+        log.debug(`nightly governance cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (this.deps.config.procedural?.proceduralMiningCronAutoRegister) {
+      try {
+        await this.autoRegisterProceduralMiningCron();
+      } catch (err) {
+        log.debug(`procedural mining cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (this.deps.config.contradictionScan?.enabled) {
+      try {
+        await this.autoRegisterContradictionScanCron();
+      } catch (err) {
+        log.debug(`contradiction scan cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (resolveConsolidationCapabilities(this.deps.config).patternReinforcement) {
+      try {
+        await this.autoRegisterPatternReinforcementCron();
+      } catch (err) {
+        log.debug(`pattern reinforcement cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (resolveConsolidationCapabilities(this.deps.config).graphEdgeDecay) {
+      try {
+        await this.autoRegisterGraphEdgeDecayCron();
+      } catch (err) {
+        log.debug(`graph edge decay cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    await this.activityRegistrar.register(signal);
+    if (!signal.aborted && this.deps.config.location.enabled && this.deps.config.location.sources.some((source) => source.enabled)) {
+      this.locationAutoSync = startLocationAutoSync({
+        config: this.deps.config.location,
+        memoryDir: this.deps.config.memoryDir
+      });
+    }
+  }
+  async autoRegisterDaySummaryCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync(jobsPath)) {
+        log.debug("day-summary cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const { model, fallbacks } = resolveDaySummaryCronModel(this.deps.config);
+      const timezone = this.deps.config.daySummaryTimezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const result = await ensureDaySummaryCron(jobsPath, {
+        timezone,
+        ...model ? { model } : {},
+        ...fallbacks.length > 0 ? { fallbacks } : {}
+      });
+      if (result.created) {
+        log.info(
+          `day-summary cron auto-registered (${result.jobId}, 23:47 ${timezone}${model ? `, model: ${model}` : ""})`
+        );
+      } else if (result.updated) {
+        log.info(
+          `day-summary cron reconciled (${result.jobId}, timezone: ${timezone}${model ? `, model: ${model}` : ""})`
+        );
+      } else {
+        log.debug("day-summary cron already up to date");
+      }
+    } catch (err) {
+      log.debug(`day-summary cron auto-register error: ${err}`);
+    }
+  }
+  async autoRegisterNightlyGovernanceCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync(jobsPath)) {
+        log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensureNightlyGovernanceCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(
+          `nightly governance cron auto-registered (${created.jobId}, 02:23 ${Intl.DateTimeFormat().resolvedOptions().timeZone})`
+        );
+      } else {
+        log.debug("nightly governance cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`nightly governance cron auto-register error: ${err}`);
+    }
+  }
+  async autoRegisterProceduralMiningCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync(jobsPath)) {
+        log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensureProceduralMiningCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(`procedural mining cron auto-registered (${created.jobId})`);
+      } else {
+        log.debug("procedural mining cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`procedural mining cron auto-register error: ${err}`);
+    }
+  }
+  async autoRegisterContradictionScanCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync(jobsPath)) {
+        log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensureContradictionScanCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(`contradiction scan cron auto-registered (${created.jobId})`);
+      } else {
+        log.debug("contradiction scan cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`contradiction scan cron auto-register error: ${err}`);
+    }
+  }
+  async autoRegisterPatternReinforcementCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync(jobsPath)) {
+        log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensurePatternReinforcementCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(`pattern reinforcement cron auto-registered (${created.jobId})`);
+      } else {
+        log.debug("pattern reinforcement cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`pattern reinforcement cron auto-register error: ${err}`);
+    }
+  }
+  async autoRegisterGraphEdgeDecayCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync(jobsPath)) {
+        log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const scheduleExpr = graphEdgeDecayCadenceToCronExpr(
+        this.deps.config.graphEdgeDecayCadenceMs
+      );
+      const created = await ensureGraphEdgeDecayCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        scheduleExpr
+      });
+      if (created.created) {
+        log.info(`graph edge decay cron auto-registered (${created.jobId}, ${scheduleExpr})`);
+      } else {
+        log.debug("graph edge decay cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`graph edge decay cron auto-register error: ${err}`);
+    }
+  }
+  // ───────────────────────────────────────────────────────────────────────
+  // Consolidation scheduling
+  // ───────────────────────────────────────────────────────────────────────
+  /**
+   * Maybe trigger a background consolidation pass after an extraction.
+   * Counted + interval gated so a burst of extractions does not fan into a
+   * burst of consolidation passes. The consolidation runner itself is
+   * passed in as a callback because it lives on the orchestrator (LLM +
+   * storage dependency surface) and is not owned by this module.
+   */
+  maybeScheduleConsolidation(nonZeroExtraction, runConsolidation) {
+    if (nonZeroExtraction) this.nonZeroExtractionsSinceConsolidation += 1;
+    if (this.deps.config.consolidationRequireNonZeroExtraction && !nonZeroExtraction) {
+      return;
+    }
+    if (this.nonZeroExtractionsSinceConsolidation < this.deps.config.consolidateEveryN) {
+      return;
+    }
+    const now = Date.now();
+    if (now - this.lastConsolidationRunAtMs < this.deps.config.consolidationMinIntervalMs) {
+      return;
+    }
+    if (this.disposed || this.consolidationRunPromise) return;
+    this.lastConsolidationRunAtMs = now;
+    this.nonZeroExtractionsSinceConsolidation = 0;
+    this.consolidationRunPromise = Promise.resolve().then(runConsolidation).catch((err) => {
+      log.error("background consolidation failed", err);
+    }).finally(() => {
+      this.consolidationRunPromise = null;
+    });
+  }
+  /** Whether a background consolidation pass is currently running. Exposed so
+   *  the orchestrator's waitForConsolidationIdle can poll idle state without
+   *  owning the cadence state (issue #1526 PR1). */
+  isConsolidationInFlight() {
+    return this.consolidationRunPromise !== null;
+  }
+  /** Whether a debounced QMD maintenance pass is armed and waiting for the
+   *  debounce timer. Exposed so drain/teardown diagnostics (e.g. the bench
+   *  adapter) can observe scheduler idle state after the #1526 PR1 extraction
+   *  moved this flag off the orchestrator. */
+  isQmdMaintenancePending() {
+    return this.qmdMaintenancePending;
+  }
+  /** Whether a QMD maintenance pass is currently running (singleflight guard).
+   *  Exposed for drain/teardown diagnostics (see isQmdMaintenancePending). */
+  isQmdMaintenanceInFlight() {
+    return this.qmdMaintenanceInFlight;
+  }
+  // ───────────────────────────────────────────────────────────────────────
+  // QMD maintenance scheduling (debounced + singleflight)
+  // ───────────────────────────────────────────────────────────────────────
+  /** Internal: queue a debounced QMD maintenance pass. */
+  requestQmdMaintenance() {
+    if (!this.deps.getQmd().isAvailable()) return;
+    if (!resolveQmdCapabilities(this.deps.config).qmdMaintenance) return;
+    this.qmdMaintenancePending = true;
+    if (this.qmdMaintenanceTimer) return;
+    this.qmdMaintenanceTimer = setTimeout(() => {
+      this.qmdMaintenanceTimer = null;
+      this.runQmdMaintenance().catch(
+        (err) => log.debug(`background qmd maintenance failed: ${err}`)
+      );
+    }, this.deps.config.qmdMaintenanceDebounceMs);
+  }
+  /**
+   * Public entrypoint for tool-driven QMD maintenance requests.
+   * Routes through existing debounced/singleflight maintenance controls.
+   */
+  requestQmdMaintenanceForTool(reason) {
+    try {
+      this.requestQmdMaintenance();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.warn(`qmd maintenance request failed (${reason}): ${msg}`);
+    }
+    void this.maybeCompactMemoryLifecycleLedger().catch(
+      (err) => log.debug(`lifecycle ledger auto-compaction check failed (non-fatal): ${err}`)
+    );
+    void maybeRebuildMemoryProjectionScheduled({
+      config: this.deps.config,
+      getStorage: this.deps.getStorage,
+      state: this.projectionRebuild
+    }).catch(
+      (err) => log.debug(`memory projection scheduled rebuild check failed (non-fatal): ${err}`)
+    );
+  }
+  /** Internal: run a single QMD maintenance pass under singleflight guard. */
+  async runQmdMaintenance() {
+    if (this.qmdMaintenanceInFlight) return;
+    if (!this.qmdMaintenancePending) return;
+    this.qmdMaintenanceInFlight = true;
+    this.qmdMaintenancePending = false;
+    try {
+      if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
+        const plan = await this.namespaceMaintenancePlan("qmd");
+        const now = Date.now();
+        const lastEmbedAtByNamespace = this.lastQmdEmbedAtMsByNamespace;
+        const dueEmbedNamespaces = (namespaces) => {
+          if (!resolveQmdCapabilities(this.deps.config).qmdAutoEmbed) return [];
+          return namespaces.filter(
+            (namespace) => now - (lastEmbedAtByNamespace.get(namespace) ?? 0) >= this.deps.config.qmdEmbedMinIntervalMs
+          );
+        };
+        const markEmbedded = (namespaces) => {
+          if (namespaces.length === 0) return;
+          for (const namespace of namespaces) {
+            lastEmbedAtByNamespace.set(namespace, now);
+          }
+          this.lastQmdEmbedAtMs = now;
+        };
+        await runNamespaceMaintenanceBatchPlan(
+          this.deps.config,
+          plan,
+          async (candidates) => {
+            const namespaces = candidates.map((candidate) => candidate.namespace);
+            const embedNamespaces = dueEmbedNamespaces(namespaces);
+            let result;
+            try {
+              result = await this.deps.namespaceSearchRouter.updateNamespacesDetailed(
+                namespaces,
+                void 0,
+                { strict: true }
+              );
+            } catch (error) {
+              if (embedNamespaces.length > 0 && qmdMaintenanceSkipReasonForError(error) === "throttled") {
+                await this.deps.namespaceSearchRouter.embedNamespaces(embedNamespaces, {
+                  strict: true
+                });
+                markEmbedded(embedNamespaces);
+              }
+              throw error;
+            }
+            if (result.backendCount <= 0) {
+              throw new Error("no eligible QMD backend for selected namespaces");
+            }
+            if (result.eligibleNamespaces.length !== namespaces.length) {
+              const eligible = new Set(result.eligibleNamespaces);
+              const missing = namespaces.filter(
+                (namespace) => !eligible.has(namespace)
+              );
+              throw new Error(
+                `QMD backend ineligible for selected namespaces (${missing.length})`
+              );
+            }
+            if (embedNamespaces.length > 0) {
+              await this.deps.namespaceSearchRouter.embedNamespaces(embedNamespaces, {
+                strict: true
+              });
+              markEmbedded(embedNamespaces);
+            }
+            return { itemCount: result.backendCount };
+          },
+          this.deps.namespaceCatalog,
+          {
+            skipReasonForError: qmdMaintenanceSkipReasonForError
+          }
+        );
+      } else {
+        await this.deps.getQmd().update();
+        const now = Date.now();
+        if (resolveQmdCapabilities(this.deps.config).qmdAutoEmbed && now - this.lastQmdEmbedAtMs >= this.deps.config.qmdEmbedMinIntervalMs) {
+          await this.deps.getQmd().embed();
+          this.lastQmdEmbedAtMs = now;
+        }
+      }
+    } finally {
+      this.qmdMaintenanceInFlight = false;
+      if (this.qmdMaintenancePending) {
+        this.requestQmdMaintenance();
+      }
+    }
+  }
+  /**
+   * Size-gated, throttled, single-flighted auto-compaction of the lifecycle
+   * ledger (issue #1910). Compacts the root ledger AND every namespace ledger
+   * (`memoryDir/namespaces/<token>/state/`) when namespaces are enabled, each
+   * through the existing `rebuildMemoryLifecycleLedger` so the
+   * archive-then-atomic-write discipline is reused verbatim. `0` disables.
+   *
+   * Before compacting, drain EVERY target's durable pending-append spill (the
+   * root ledger AND each namespace ledger) so a lifecycle event that spilled
+   * while a prior long rewrite held the lock is folded back into its ledger and
+   * cannot be silently lost (issue #2033). Draining is independent of both the
+   * compaction threshold and the min-interval throttle: targets are enumerated
+   * through the same safe (symlink/containment-checked) resolver and every
+   * eligible queue is drained BEFORE any throttle return, so a namespace spill
+   * created after the previous pass never waits out the whole interval.
+   * Encrypted-store safety is preserved — a keyed target drains through its
+   * secure StorageManager, a filesystem-fallback target only through a plaintext
+   * context that refuses encrypted ledgers/spills. Work stays bounded: one
+   * target enumeration plus a bounded per-queue drain.
+   *
+   * The min-interval throttle timestamp advances ONLY after real, fully
+   * successful compaction work: a failed OR deferred target leaves the throttle
+   * un-advanced so it stays eligible on the next maintenance pass, while
+   * `lifecycleCompactionInFlight` still prevents overlapping runs. A "deferred"
+   * target is oversized but could not be compacted because its encrypted ledger
+   * has no unlocked secure store — arming the throttle for it would suppress the
+   * retry of that still-oversized ledger for the whole interval (#2033).
+   *
+   * The min-interval throttle is bypassed for one case: an encrypted ledger
+   * already at/over the whole-file decrypt cap is unreadable, so it must be
+   * clamped on the next pass rather than wait out the interval. Ordinary
+   * below-cap (or plaintext) targets stay throttled (#2033).
+   */
+  async maybeCompactMemoryLifecycleLedger() {
+    const targets = await this.resolveLifecycleCompactionTargets();
+    for (const target of targets) {
+      await this.drainPendingForTarget(target);
+    }
+    const threshold = this.deps.config.memoryLifecycleLedgerCompactBytes;
+    if (!(threshold > 0)) return;
+    if (this.lifecycleCompactionInFlight) return;
+    const now = Date.now();
+    if (now - this.lastLifecycleCompactionAtMs < this.deps.config.memoryLifecycleLedgerCompactMinIntervalMs && !await this.hasOverCapEncryptedLifecycleLedger(targets)) {
+      return;
+    }
+    if (this.lifecycleCompactionInFlight) return;
+    this.lifecycleCompactionInFlight = true;
+    try {
+      let compacted = 0;
+      let failed = 0;
+      let deferred = 0;
+      for (const target of targets) {
+        const outcome = await this.compactLifecycleLedgerTarget(target, threshold);
+        if (outcome === "compacted") compacted += 1;
+        else if (outcome === "failed") failed += 1;
+        else if (outcome === "deferred") deferred += 1;
+      }
+      if (compacted > 0 && failed === 0 && deferred === 0) {
+        this.lastLifecycleCompactionAtMs = now;
+      }
+    } finally {
+      this.lifecycleCompactionInFlight = false;
+    }
+  }
+  /**
+   * True when any lifecycle target's ledger is encrypted at rest AND its
+   * on-disk size is at/over the whole-file decrypt cap. Such a ledger is already
+   * unreadable (the secure reader refuses at/over the cap), so it must reach the
+   * bounded compaction path on the next maintenance pass regardless of the
+   * global min-interval throttle — otherwise the throttle could keep an
+   * unreadable ledger un-clamped for a whole interval (#2033). Ordinary
+   * below-cap or plaintext targets never match, so the throttle still governs
+   * them. A stat/probe failure yields "no forced target" and is left to the
+   * normal compaction path, which classifies it as failed and retries.
+   */
+  async hasOverCapEncryptedLifecycleLedger(targets) {
+    for (const target of targets) {
+      const ledgerPath = path5.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+      let size;
+      try {
+        size = (await stat(ledgerPath)).size;
+      } catch {
+        continue;
+      }
+      if (size < this.lifecycleLedgerMaxBytes) continue;
+      try {
+        if (await probeEncryptedRegularFileHeader(ledgerPath)) return true;
+      } catch {
+        continue;
+      }
+    }
+    return false;
+  }
+  /**
+   * Drain one compaction target's durable pending spill. A catalog-backed
+   * target folds through its secure StorageManager; a filesystem-fallback
+   * target (no storage) folds through a path-scoped plaintext context that
+   * refuses encrypted ledgers/spills so a keyless drain never downgrades an
+   * encrypted ledger (issue #2033).
+   */
+  async drainPendingForTarget(target) {
+    if (target.storage) {
+      await this.drainPendingLifecycleAppends(target.storage);
+    } else {
+      await this.drainPendingLifecycleAppendsForPath(target.memoryDir);
+    }
+  }
+  /** Drain a target's durable pending lifecycle-append spill into its ledger
+   *  (issue #2033); non-fatal and a fast no-op when nothing is pending. */
+  async drainPendingLifecycleAppends(storage) {
+    if (!storage) return;
+    try {
+      await storage.drainPendingMemoryLifecycleEvents();
+    } catch (err) {
+      log.debug(`lifecycle pending drain failed (non-fatal): ${err}`);
+    }
+  }
+  /**
+   * Drain a filesystem-fallback target's pending lifecycle-append spill when no
+   * secure StorageManager is available (catalog-disabled namespace; issue
+   * #2033). Uses the safe path-scoped PLAINTEXT context this fallback already
+   * operates in: a keyless drain can only fold plaintext spills into a plaintext
+   * ledger, so it refuses when the ledger or ANY spill is encrypted at rest,
+   * leaving those pending for a keyed (catalog-path) drain — exactly mirroring
+   * the fallback compaction's encrypted-ledger deferral. Non-fatal; a fast
+   * no-op when nothing is pending. The shared spill lister enforces the symlink/
+   * containment guard on every spill file it reads or deletes.
+   */
+  async drainPendingLifecycleAppendsForPath(memoryDir) {
+    const ledgerPath = path5.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const spillDir = pendingLifecycleLedgerDir(ledgerPath);
+    let spillFiles;
+    let claimedOrphans;
+    try {
+      spillFiles = await listContainedSpillFiles(spillDir);
+      claimedOrphans = await listContainedSpillFiles(spillDir, ".jsonl.claimed");
+    } catch (err) {
+      log.debug(`fallback lifecycle pending scan failed (non-fatal) for ${memoryDir}: ${err}`);
+      return;
+    }
+    if (spillFiles.length === 0 && claimedOrphans.length === 0) return;
+    const io = {
+      writeSecure: async (filePath, payload) => {
+        await mkdir3(path5.dirname(filePath), { recursive: true });
+        await writeFile2(filePath, payload, "utf-8");
+      },
+      readSecure: async (filePath) => {
+        if (await probeEncryptedRegularFileHeader(filePath)) {
+          throw new Error(`fallback lifecycle drain deferred: encrypted spill at ${filePath}`);
+        }
+        return readFile2(filePath, "utf-8");
+      }
+    };
+    try {
+      await drainPendingLifecycleLedgerIfAny(
+        ledgerPath,
+        io,
+        async (payload) => {
+          if (await probeEncryptedRegularFileHeader(ledgerPath)) {
+            throw new Error(`fallback lifecycle drain deferred: ledger became encrypted at ${ledgerPath}`);
+          }
+          await appendFile(ledgerPath, payload, "utf-8");
+        },
+        async () => {
+          await mkdir3(path5.dirname(ledgerPath), { recursive: true });
+        }
+      );
+    } catch (err) {
+      log.debug(`fallback lifecycle pending drain failed (non-fatal) for ${memoryDir}: ${err}`);
+    }
+  }
+  /**
+   * Enumerate the lifecycle ledgers to consider for compaction: the root
+   * (through the secure-configured root storage when available) plus every
+   * cataloged namespace ledger when namespaces are enabled. Deduplicated by
+   * resolved storage dir so a namespace that collapses onto the root is not
+   * compacted twice. Namespace resolution failures are non-fatal.
+   */
+  async resolveLifecycleCompactionTargets() {
+    const targets = [];
+    const seen = /* @__PURE__ */ new Set();
+    const addTarget = (memoryDir, storage) => {
+      const key = path5.resolve(memoryDir);
+      if (seen.has(key)) return;
+      seen.add(key);
+      targets.push({ memoryDir, storage });
+    };
+    const rootStorage = this.deps.getStorage?.();
+    addTarget(rootStorage ? rootStorage.dir : this.deps.config.memoryDir, rootStorage);
+    const resolveNamespaceStorage = this.deps.storageForNamespace;
+    if (resolveNamespaceStorage && this.deps.namespaceCatalog?.enabled) {
+      let records = [];
+      try {
+        records = await this.deps.namespaceCatalog.listNamespaces();
+      } catch (err) {
+        log.debug(`lifecycle compaction: namespace enumeration failed (non-fatal): ${err}`);
+      }
+      for (const record of records) {
+        const namespace = record.namespace.trim();
+        if (!namespace) continue;
+        try {
+          const storage = await resolveNamespaceStorage(namespace);
+          addTarget(storage.dir, storage);
+        } catch (err) {
+          log.debug(
+            `lifecycle compaction: storage resolve failed for namespace ${namespace} (non-fatal): ${err}`
+          );
+        }
+      }
+    }
+    if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
+      const namespacesBase = path5.join(this.deps.config.memoryDir, "namespaces");
+      let memoryDirReal;
+      try {
+        memoryDirReal = await realpath(this.deps.config.memoryDir);
+        const baseStat = await lstat(namespacesBase);
+        if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
+          throw new Error("namespaces base is a symlink or not a directory");
+        }
+        assertPathInsideRoot(memoryDirReal, await realpath(namespacesBase), namespacesBase);
+      } catch (err) {
+        if (!isErrnoCode(err, "ENOENT")) {
+          log.debug(`lifecycle compaction: namespaces base rejected (non-fatal): ${err}`);
+        }
+        return targets;
+      }
+      let entries = [];
+      try {
+        entries = await readdir(namespacesBase, { withFileTypes: true });
+      } catch (err) {
+        if (!isErrnoCode(err, "ENOENT")) {
+          log.debug(`lifecycle compaction: namespaces dir scan failed (non-fatal): ${err}`);
+        }
+      }
+      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+        const childPath = path5.join(namespacesBase, entry.name);
+        try {
+          assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);
+        } catch (err) {
+          log.debug(`lifecycle compaction: skipping out-of-root namespace dir ${childPath}: ${err}`);
+          continue;
+        }
+        const decodedNamespace = namespaceIdentityFromToken(entry.name);
+        const routeNamespace = decodedNamespace !== null ? decodedNamespace : isSafeRouteNamespace(entry.name) ? entry.name : null;
+        if (resolveNamespaceStorage && routeNamespace !== null) {
+          try {
+            const storage = await resolveNamespaceStorage(routeNamespace);
+            if (path5.resolve(storage.dir) === path5.resolve(childPath)) {
+              addTarget(storage.dir, storage);
+              continue;
+            }
+            log.debug(
+              `lifecycle compaction: fallback resolver routed ${childPath} to ${storage.dir}; using keyless target`
+            );
+          } catch (err) {
+            log.debug(
+              `lifecycle compaction: fallback storage resolve failed for ${childPath} (non-fatal): ${err}`
+            );
+          }
+        }
+        addTarget(childPath);
+      }
+    }
+    return targets;
+  }
+  /**
+   * Compact one lifecycle ledger when it is at/over `threshold`. Returns
+   * `"skipped"` (absent or below threshold — nothing to do), `"compacted"`
+   * (rewritten and verified under the read/decrypt cap), `"failed"`
+   * (rebuild/probe threw, or the rewritten ledger is STILL over the cap — an
+   * ineffective compaction — non-fatal, retried next pass), or `"deferred"`
+   * (oversized but its encrypted ledger cannot be rewritten because no unlocked
+   * secure store is available — real work still pending, so the caller must NOT
+   * arm the throttle). #2033: a deferred/failed target is distinct from a genuine
+   * no-op so one namespace compacting cannot suppress retries for another, and
+   * an over-cap rewrite never arms the throttle.
+   */
+  async compactLifecycleLedgerTarget(target, threshold) {
+    const ledgerPath = path5.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    let size = 0;
+    try {
+      size = (await stat(ledgerPath)).size;
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) return "skipped";
+      log.warn(
+        `lifecycle ledger size check failed (non-fatal) for ${target.memoryDir}: ${err}`
+      );
+      return "failed";
+    }
+    if (size < Math.min(threshold, this.lifecycleLedgerMaxBytes)) return "skipped";
+    let encrypted;
+    try {
+      encrypted = await probeEncryptedRegularFileHeader(ledgerPath);
+    } catch (err) {
+      log.warn(`lifecycle ledger encryption probe failed (non-fatal) for ${ledgerPath}: ${err}`);
+      return "failed";
+    }
+    const effectiveThreshold = encrypted ? Math.min(threshold, this.lifecycleLedgerMaxBytes) : threshold;
+    if (size < effectiveThreshold) return "skipped";
+    if (encrypted && !(target.storage?.isSecureStoreUnlocked() ?? false)) {
+      log.warn(
+        `lifecycle ledger at ${ledgerPath} is encrypted at rest but no unlocked secure storage is available; deferring auto-compaction to avoid a plaintext rewrite. Run 'remnic rebuild-memory-lifecycle-ledger --write' after unlocking.`
+      );
+      return "deferred";
+    }
+    const replacementEncrypted = encrypted || (target.storage?.willEncryptStateWrites() ?? false);
+    const plaintextBudget = replacementEncrypted ? this.lifecycleLedgerMaxBytes - SECURE_STORE_ENVELOPE_OVERHEAD_BYTES - 1 : this.lifecycleLedgerMaxBytes - 1;
+    try {
+      const result = await rebuildMemoryLifecycleLedger({
+        memoryDir: target.memoryDir,
+        dryRun: false,
+        storage: target.storage,
+        // Background compaction must not lose append-only history that
+        // frontmatter cannot reconstruct (issue #1910); the manual CLI repair
+        // rebuild now preserves and bounds identically (#2033).
+        preserveExistingEvents: true,
+        // Bound the PLAINTEXT rewrite to a budget that reserves the secure-store
+        // envelope, so the on-disk ledger (plaintext, or plaintext+envelope when
+        // encrypted) is strictly below the read/decrypt cap; overflow lands in
+        // the verbatim backup (#2033 findings 2+4).
+        maxLedgerBytes: plaintextBudget
+      });
+      let rewrittenSize = 0;
+      try {
+        rewrittenSize = (await stat(ledgerPath)).size;
+      } catch (err) {
+        log.warn(`lifecycle ledger post-compaction size check failed (non-fatal) for ${target.memoryDir}: ${err}`);
+        return "failed";
+      }
+      if (rewrittenSize >= this.lifecycleLedgerMaxBytes) {
+        log.warn(
+          `lifecycle ledger auto-compaction ineffective for ${target.memoryDir}: rewritten ledger is ${rewrittenSize}B, still at/over the ${this.lifecycleLedgerMaxBytes}-byte read/decrypt cap; leaving the throttle un-armed to retry.`
+        );
+        return "failed";
+      }
+      if (result.rewritten === false) {
+        log.debug(
+          `lifecycle ledger already compact for ${target.memoryDir}: ${rewrittenSize}B, no rewrite needed (throttle armed to avoid re-archiving an unchanged ledger).`
+        );
+      } else {
+        log.info(
+          `lifecycle ledger auto-compacted (${target.memoryDir}): ${size}B -> ${rewrittenSize}B, ${result.rebuiltRows} rows (${result.preservedAppendOnlyRows ?? 0} append-only preserved, ${result.archivedOverflowRows ?? 0} overflow archived), backup=${result.backupPath ?? "none"}`
+        );
+      }
+      return "compacted";
+    } catch (err) {
+      log.warn(
+        `lifecycle ledger auto-compaction failed (non-fatal) for ${target.memoryDir}: ${err}`
+      );
+      return "failed";
+    }
+  }
+  /** Build the namespace-aware maintenance plan for one job. */
+  async namespaceMaintenancePlan(jobName) {
+    return planNamespaceMaintenance(this.deps.config, {
+      jobName,
+      catalog: this.deps.namespaceCatalog
+    });
+  }
+  // ───────────────────────────────────────────────────────────────────────
+  // Lifecycle
+  // ───────────────────────────────────────────────────────────────────────
+  /**
+   * Clear any pending debounce timer and drain the activity sync scheduler.
+   * Called from the orchestrator's destroy() so a late tick does not fire on a
+   * torn-down instance and no in-flight activity tick keeps writing after
+   * teardown. Async: awaits the scheduler's abort+drain before resolving.
+   */
+  async dispose() {
+    this.disposed = true;
+    const consolidationDrain = this.consolidationRunPromise;
+    const activityDrain = this.activityRegistrar.dispose();
+    const locationDrain = this.locationAutoSync?.stop() ?? Promise.resolve();
+    this.locationAutoSync = null;
+    if (this.qmdMaintenanceTimer) {
+      clearTimeout(this.qmdMaintenanceTimer);
+      this.qmdMaintenanceTimer = null;
+    }
+    this.qmdMaintenancePending = false;
+    await activityDrain;
+    await locationDrain;
+    if (this.qmdMaintenanceTimer) {
+      clearTimeout(this.qmdMaintenanceTimer);
+      this.qmdMaintenanceTimer = null;
+    }
+    this.qmdMaintenancePending = false;
+    if (consolidationDrain) await consolidationDrain;
+  }
+};
+
+export {
+  refreshActivityIndex,
+  activityDatabasePath,
+  ensureActivityStateDir,
+  openActivityDatabase,
+  applyActivitySchema,
+  ActivityStore,
+  activityCursorKey,
+  syncActivitySource,
+  ActivityHttpSourceClient,
+  timelineCorrectionDatabasePath,
+  TimelineCorrectionStore,
+  correctionsForCards,
+  applyTimelineCorrections,
+  classifyTimelineObservation,
+  TIMELINE_FORMAT_VERSION,
+  TIMELINE_MERGE_GAP_MS,
+  TIMELINE_MAX_DWELL_MS,
+  buildTimelineDay,
+  serializeTimelineDay,
+  runTimelineCardAnalysis,
+  TIMELINE_DAY_FORMAT_VERSION,
+  TIMELINE_DAY_DIR,
+  timelineDayPath,
+  snapshotToObservation,
+  localDatesForUtcRange,
+  listPersistedTimelineDates,
+  resolveTimelineLoadDates,
+  timelineAnalysisClientsFromConfig,
+  regenerateTimelineDay,
+  resolveActivitySyncDates,
+  runActivitySyncOnce,
+  ACTIVITY_SYNC_DEFAULT_INTERVAL_MS,
+  ActivitySyncScheduler,
+  MaintenanceScheduler
+};
+//# sourceMappingURL=chunk-SJV3AOZ2.js.map