@remnic/core 9.15.2 → 9.16.0

package/dist/{chunk-XJT6LNLY.js → chunk-V6LYAXGW.js}

@@ -9,11 +9,20 @@ import {
 } from "./chunk-666A3MOW.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-P53HGVJS.js";
+} from "./chunk-LMVAIZR5.js";
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-5MDE5MIC.js";
+} from "./chunk-SESF64QR.js";
+import {
+  activityDayWindow,
+  activityDigestPath,
+  composeActivityDigestBody,
+  composeActivityDigestMeta,
+  isValidActivityDate,
+  serializeActivityDigest,
+  validateActivityBaseUrl
+} from "./chunk-GSQASASV.js";
 import {
   STATE_FILE_MAX_DECRYPT_BYTES,
   drainPendingLifecycleLedgerIfAny,
@@ -26,6 +35,10 @@ import {
   assertPathInsideRoot,
   listContainedSpillFiles
 } from "./chunk-GCASGYIO.js";
+import {
+  displayErrorDetail,
+  openBetterSqlite3
+} from "./chunk-RL6NEVXT.js";
 import {
   resolveHomeDir
 } from "./chunk-JUC24CTX.js";
@@ -51,8 +64,770 @@ import {
 
 // src/orchestration/maintenance.ts
 import { existsSync } from "fs";
-import { appendFile, lstat, mkdir, readFile, readdir, realpath, stat, writeFile } from "fs/promises";
+import { appendFile, lstat, mkdir as mkdir3, readFile as readFile2, readdir, realpath, stat, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+
+// 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;
+  }
+  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, path4, query) {
+  const url = new URL(path4, 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/runner.ts
+function localDateInTimezone(instant, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }).formatToParts(instant);
+    const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
+    return `${get("year")}-${get("month")}-${get("day")}`;
+  } catch {
+    return instant.toISOString().slice(0, 10);
+  }
+}
+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 = localDateInTimezone(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: []
+    };
+  }
+  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 = [];
+  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;
+            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;
+    }
+  } 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
+  };
+}
+
+// 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 }
+    }));
+    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),
+        // 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();
+          }
+        }
+      });
+      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;
@@ -60,6 +835,14 @@ function qmdMaintenanceSkipReasonForError(error) {
 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")
+    });
   }
   deps;
   // ── Consolidation scheduling state ──
@@ -81,6 +864,9 @@ var MaintenanceScheduler = class {
   // the bounding + post-write verification deterministically without a 400MB
   // fixture.
   lifecycleLedgerMaxBytes = STATE_FILE_MAX_DECRYPT_BYTES;
+  // ── Activity (screen-capture) sync scheduler (issue #1900) ──
+  // The full arm/re-arm/teardown lifecycle lives in ActivitySyncRegistrar.
+  activityRegistrar;
   // ───────────────────────────────────────────────────────────────────────
   // Cron auto-registration
   // ───────────────────────────────────────────────────────────────────────
@@ -93,7 +879,7 @@ var MaintenanceScheduler = class {
    * Returns when all eligible registrations have completed so callers that
    * `await deferredReady` can rely on jobs.json being current.
    */
-  async autoRegisterCrons(_signal) {
+  async autoRegisterCrons(signal) {
     if (resolveRecallAuxiliaryCapabilities(this.deps.config).daySummary) {
       try {
         await this.autoRegisterDaySummaryCron();
@@ -136,10 +922,11 @@ var MaintenanceScheduler = class {
         log.debug(`graph edge decay cron auto-register failed (non-fatal): ${err}`);
       }
     }
+    await this.activityRegistrar.register(signal);
   }
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("day-summary cron: jobs.json not found, skipping auto-register");
@@ -190,7 +977,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -212,7 +999,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -232,7 +1019,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -252,7 +1039,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
@@ -272,7 +1059,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
@@ -536,7 +1323,7 @@ var MaintenanceScheduler = class {
    */
   async hasOverCapEncryptedLifecycleLedger(targets) {
     for (const target of targets) {
-      const ledgerPath = path.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+      const ledgerPath = path3.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
       let size;
       try {
         size = (await stat(ledgerPath)).size;
@@ -588,7 +1375,7 @@ var MaintenanceScheduler = class {
    * containment guard on every spill file it reads or deletes.
    */
   async drainPendingLifecycleAppendsForPath(memoryDir) {
-    const ledgerPath = path.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path3.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     const spillDir = pendingLifecycleLedgerDir(ledgerPath);
     let spillFiles;
     let claimedOrphans;
@@ -602,14 +1389,14 @@ var MaintenanceScheduler = class {
     if (spillFiles.length === 0 && claimedOrphans.length === 0) return;
     const io = {
       writeSecure: async (filePath, payload) => {
-        await mkdir(path.dirname(filePath), { recursive: true });
-        await writeFile(filePath, payload, "utf-8");
+        await mkdir3(path3.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 readFile(filePath, "utf-8");
+        return readFile2(filePath, "utf-8");
       }
     };
     try {
@@ -623,7 +1410,7 @@ var MaintenanceScheduler = class {
           await appendFile(ledgerPath, payload, "utf-8");
         },
         async () => {
-          await mkdir(path.dirname(ledgerPath), { recursive: true });
+          await mkdir3(path3.dirname(ledgerPath), { recursive: true });
         }
       );
     } catch (err) {
@@ -641,7 +1428,7 @@ var MaintenanceScheduler = class {
     const targets = [];
     const seen = /* @__PURE__ */ new Set();
     const addTarget = (memoryDir, storage) => {
-      const key = path.resolve(memoryDir);
+      const key = path3.resolve(memoryDir);
       if (seen.has(key)) return;
       seen.add(key);
       targets.push({ memoryDir, storage });
@@ -670,7 +1457,7 @@ var MaintenanceScheduler = class {
       }
     }
     if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      const namespacesBase = path.join(this.deps.config.memoryDir, "namespaces");
+      const namespacesBase = path3.join(this.deps.config.memoryDir, "namespaces");
       let memoryDirReal;
       try {
         memoryDirReal = await realpath(this.deps.config.memoryDir);
@@ -695,7 +1482,7 @@ var MaintenanceScheduler = class {
       }
       for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-        const childPath = path.join(namespacesBase, entry.name);
+        const childPath = path3.join(namespacesBase, entry.name);
         try {
           assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);
         } catch (err) {
@@ -707,7 +1494,7 @@ var MaintenanceScheduler = class {
         if (resolveNamespaceStorage && routeNamespace !== null) {
           try {
             const storage = await resolveNamespaceStorage(routeNamespace);
-            if (path.resolve(storage.dir) === path.resolve(childPath)) {
+            if (path3.resolve(storage.dir) === path3.resolve(childPath)) {
               addTarget(storage.dir, storage);
               continue;
             }
@@ -738,7 +1525,7 @@ var MaintenanceScheduler = class {
    * an over-cap rewrite never arms the throttle.
    */
   async compactLifecycleLedgerTarget(target, threshold) {
-    const ledgerPath = path.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path3.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     let size = 0;
     try {
       size = (await stat(ledgerPath)).size;
@@ -823,10 +1610,19 @@ var MaintenanceScheduler = class {
   // Lifecycle
   // ───────────────────────────────────────────────────────────────────────
   /**
-   * Clear any pending debounce timer. Called from the orchestrator's
-   * destroy() so a late tick does not fire on a torn-down instance.
+   * 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.
    */
-  dispose() {
+  async dispose() {
+    const activityDrain = this.activityRegistrar.dispose();
+    if (this.qmdMaintenanceTimer) {
+      clearTimeout(this.qmdMaintenanceTimer);
+      this.qmdMaintenanceTimer = null;
+    }
+    this.qmdMaintenancePending = false;
+    await activityDrain;
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;
@@ -836,6 +1632,19 @@ var MaintenanceScheduler = class {
 };
 
 export {
+  refreshActivityIndex,
+  activityDatabasePath,
+  ensureActivityStateDir,
+  openActivityDatabase,
+  applyActivitySchema,
+  ActivityStore,
+  activityCursorKey,
+  syncActivitySource,
+  ActivityHttpSourceClient,
+  resolveActivitySyncDates,
+  runActivitySyncOnce,
+  ACTIVITY_SYNC_DEFAULT_INTERVAL_MS,
+  ActivitySyncScheduler,
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-XJT6LNLY.js.map
+//# sourceMappingURL=chunk-V6LYAXGW.js.map