@remnic/core 9.10.0 → 9.12.0

package/dist/{chunk-7PY55HMI.js → chunk-3VBXP5HS.js}

@@ -452,6 +452,9 @@ import {
 import {
   assertPathInsideRoot
 } from "./chunk-GCASGYIO.js";
+import {
+  openBetterSqlite3
+} from "./chunk-RL6NEVXT.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus
@@ -2075,7 +2078,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path31, preferredNamespace) => {
+        readMemoryFrontmatter: async (path33, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2087,7 +2090,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path31,
+            path33,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -19165,9 +19168,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path31 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path33 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
   const kind = typeof rec.kind === "string" && rec.kind.length > 0 ? rec.kind : void 0;
-  const item = path31 !== void 0 && kind !== void 0 ? { symbol, path: path31, kind } : path31 !== void 0 ? { symbol, path: path31 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path33 !== void 0 && kind !== void 0 ? { symbol, path: path33, kind } : path33 !== void 0 ? { symbol, path: path33 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -22912,10 +22915,580 @@ function publisherForConnector(connectorId) {
   return publisherFor(hostIdForConnector(connectorId));
 }
 
-// src/session-summaries/index.ts
-import { createHash as createHash9 } from "crypto";
-import { lstat as lstat2, mkdir as mkdir7, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
+// src/activity/store.ts
+import { mkdirSync } from "fs";
+import { mkdir as mkdir7 } from "fs/promises";
 import path29 from "path";
+var ACTIVITY_SCHEMA_VERSION = 1;
+var MAX_SEARCH_RESULTS = 100;
+function activityDatabasePath(memoryDir) {
+  return path29.join(memoryDir, "state", "activity.sqlite");
+}
+async function ensureActivityStateDir(memoryDir) {
+  await mkdir7(path29.join(memoryDir, "state"), { recursive: true });
+}
+function openActivityDatabase(memoryDir) {
+  mkdirSync(path29.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/digest.ts
+import { createHash as createHash9 } from "crypto";
+import path30 from "path";
+var ACTIVITY_DIGEST_FORMAT_VERSION = 1;
+var ACTIVITY_DIR_NAME = "activity";
+var MAX_DWELL_MS = 15 * 6e4;
+var NOTABLE_MAX_WINDOWS = 10;
+var NOTABLE_EXCERPT_CHARS = 280;
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function isValidActivityDate(date) {
+  if (typeof date !== "string" || !DATE_PATTERN.test(date)) return false;
+  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === date;
+}
+function activityDigestPath(memoryDir, date) {
+  if (!isValidActivityDate(date)) {
+    throw new RangeError(`Invalid activity date "${date}"; expected YYYY-MM-DD.`);
+  }
+  return path30.join(memoryDir, ACTIVITY_DIR_NAME, `${date}.md`);
+}
+function timezoneOffsetIso(instant, timezone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    timeZoneName: "longOffset"
+  }).formatToParts(instant);
+  const name = parts.find((part) => part.type === "timeZoneName")?.value ?? "GMT";
+  const match = name.match(/GMT([+-]\d{2}:\d{2})?/);
+  return match?.[1] ?? "+00:00";
+}
+function assertValidTimezone(timezone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+  } catch {
+    throw new RangeError(`Invalid IANA timezone "${timezone}" for the activity digest.`);
+  }
+}
+function zonedDayStartIso(date, timezone) {
+  const prevDate = shiftIsoDate(date, -1);
+  const probeOffsets = new Set(
+    [
+      `${prevDate}T12:00:00Z`,
+      `${prevDate}T23:00:00Z`,
+      `${date}T00:00:00Z`,
+      `${date}T12:00:00Z`,
+      `${date}T23:00:00Z`
+    ].map((iso) => timezoneOffsetIso(new Date(iso), timezone))
+  );
+  let best = null;
+  for (const offset of probeOffsets) {
+    const candidate = Date.parse(`${date}T00:00:00${offset}`);
+    if (!Number.isFinite(candidate)) continue;
+    if (timezoneOffsetIso(new Date(candidate), timezone) !== offset) continue;
+    if (best === null || candidate < best) best = candidate;
+  }
+  if (best === null) {
+    for (let minute = 1; minute <= 180 && best === null; minute++) {
+      const hh = String(Math.floor(minute / 60)).padStart(2, "0");
+      const mm = String(minute % 60).padStart(2, "0");
+      for (const offset of probeOffsets) {
+        const candidate = Date.parse(`${date}T${hh}:${mm}:00${offset}`);
+        if (!Number.isFinite(candidate)) continue;
+        if (timezoneOffsetIso(new Date(candidate), timezone) !== offset) continue;
+        if (best === null || candidate < best) best = candidate;
+      }
+    }
+  }
+  if (best === null) {
+    const noon = timezoneOffsetIso(/* @__PURE__ */ new Date(`${date}T12:00:00Z`), timezone);
+    best = Date.parse(`${date}T00:00:00${noon}`);
+  }
+  if (best === null || !Number.isFinite(best)) {
+    throw new RangeError(`activity: could not resolve a local day start for "${date}" in "${timezone}".`);
+  }
+  return new Date(best).toISOString();
+}
+function shiftIsoDate(date, days) {
+  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  parsed.setUTCDate(parsed.getUTCDate() + days);
+  return parsed.toISOString().slice(0, 10);
+}
+function nextIsoDate(date) {
+  return shiftIsoDate(date, 1);
+}
+function activityDayWindow(date, timezone) {
+  if (!isValidActivityDate(date)) {
+    throw new RangeError(`Invalid activity date "${date}"; expected a real YYYY-MM-DD day.`);
+  }
+  assertValidTimezone(timezone);
+  return {
+    startUtc: new Date(zonedDayStartIso(date, timezone)).toISOString(),
+    endUtc: new Date(zonedDayStartIso(nextIsoDate(date), timezone)).toISOString()
+  };
+}
+function sortedByTime(snapshots) {
+  return [...snapshots].sort((a, b) => {
+    const at2 = Date.parse(a.capturedAtUtc);
+    const bt = Date.parse(b.capturedAtUtc);
+    if (at2 !== bt && Number.isFinite(at2) && Number.isFinite(bt)) return at2 < bt ? -1 : 1;
+    const aid = a.id ?? 0;
+    const bid = b.id ?? 0;
+    if (aid < bid) return -1;
+    if (aid > bid) return 1;
+    if (a.contentHash !== b.contentHash) return a.contentHash < b.contentHash ? -1 : 1;
+    if (a.app !== b.app) return a.app < b.app ? -1 : 1;
+    if (a.windowTitle !== b.windowTitle) return a.windowTitle < b.windowTitle ? -1 : 1;
+    return 0;
+  });
+}
+function computeDwell(snapshots) {
+  const byMachine = /* @__PURE__ */ new Map();
+  for (const snapshot of snapshots) {
+    const list = byMachine.get(snapshot.machine);
+    if (list === void 0) byMachine.set(snapshot.machine, [snapshot]);
+    else list.push(snapshot);
+  }
+  const dwell = /* @__PURE__ */ new Map();
+  for (const list of byMachine.values()) {
+    const ordered = sortedByTime(list);
+    for (let index = 0; index < ordered.length; index++) {
+      const current = ordered[index];
+      if (current === void 0) continue;
+      const next = ordered[index + 1];
+      let value = 0;
+      if (next !== void 0) {
+        const delta = Date.parse(next.capturedAtUtc) - Date.parse(current.capturedAtUtc);
+        if (Number.isFinite(delta) && delta > 0) value = Math.min(delta, MAX_DWELL_MS);
+      }
+      dwell.set(current, value);
+    }
+  }
+  return dwell;
+}
+function formatDurationMinutes(ms) {
+  return `${Math.round(ms / 6e4)}m`;
+}
+function clockHhMm(iso, timezone) {
+  const ms = Date.parse(iso);
+  if (!Number.isFinite(ms)) return "??:??";
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone: timezone,
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).formatToParts(new Date(ms));
+  const hour = parts.find((p) => p.type === "hour")?.value ?? "00";
+  const minute = parts.find((p) => p.type === "minute")?.value ?? "00";
+  return `${hour}:${minute}`;
+}
+function collapseWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function perAppSection(ordered, dwell) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const snapshot of ordered) {
+    totals.set(snapshot.app, (totals.get(snapshot.app) ?? 0) + (dwell.get(snapshot) ?? 0));
+  }
+  const rows = [...totals.entries()].sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    if (a[0] < b[0]) return -1;
+    if (a[0] > b[0]) return 1;
+    return 0;
+  });
+  const lines = ["## Per-app time", ""];
+  if (rows.length === 0) {
+    lines.push("_No activity recorded._");
+  } else {
+    for (const [app, ms] of rows) {
+      lines.push(`- ${app}: ${formatDurationMinutes(ms)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function timelineSpans(ordered) {
+  const spans = [];
+  for (const snapshot of ordered) {
+    const last = spans[spans.length - 1];
+    if (last !== void 0 && last.machine === snapshot.machine && last.app === snapshot.app && last.windowTitle === snapshot.windowTitle && last.browserUrl === snapshot.browserUrl) {
+      continue;
+    }
+    spans.push({
+      startIso: snapshot.capturedAtUtc,
+      machine: snapshot.machine,
+      app: snapshot.app,
+      windowTitle: snapshot.windowTitle,
+      ...snapshot.browserUrl !== void 0 ? { browserUrl: snapshot.browserUrl } : {}
+    });
+  }
+  return spans;
+}
+function timelineSection(ordered, timezone) {
+  const lines = ["## Timeline", ""];
+  const spans = timelineSpans(ordered);
+  if (spans.length === 0) {
+    lines.push("_No activity recorded._");
+    return lines.join("\n");
+  }
+  for (const span of spans) {
+    const clock = clockHhMm(span.startIso, timezone);
+    const window = collapseWhitespace(span.windowTitle);
+    const url = span.browserUrl !== void 0 ? ` (${collapseWhitespace(span.browserUrl)})` : "";
+    lines.push(`- [${clock}] ${span.app}${window.length > 0 ? ` \u2014 ${window}` : ""}${url}`);
+  }
+  return lines.join("\n");
+}
+function notableSection(ordered, dwell) {
+  const withDwell = ordered.map((snapshot) => ({ snapshot, dwell: dwell.get(snapshot) ?? 0 }));
+  const ranked = withDwell.filter((entry) => collapseWhitespace(entry.snapshot.text).length > 0).sort((a, b) => {
+    if (b.dwell !== a.dwell) return b.dwell - a.dwell;
+    const at2 = Date.parse(a.snapshot.capturedAtUtc);
+    const bt = Date.parse(b.snapshot.capturedAtUtc);
+    if (at2 !== bt && Number.isFinite(at2) && Number.isFinite(bt)) return at2 < bt ? -1 : 1;
+    const idDelta = (a.snapshot.id ?? 0) - (b.snapshot.id ?? 0);
+    if (idDelta !== 0) return idDelta;
+    if (a.snapshot.contentHash !== b.snapshot.contentHash) {
+      return a.snapshot.contentHash < b.snapshot.contentHash ? -1 : 1;
+    }
+    return 0;
+  }).slice(0, NOTABLE_MAX_WINDOWS);
+  const lines = ["## Notable", ""];
+  if (ranked.length === 0) {
+    lines.push("_No notable text captured._");
+    return lines.join("\n");
+  }
+  for (const { snapshot } of ranked) {
+    const excerpt = collapseWhitespace(snapshot.text).slice(0, NOTABLE_EXCERPT_CHARS);
+    lines.push(`- **${snapshot.app}** \u2014 ${excerpt}`);
+  }
+  return lines.join("\n");
+}
+function composeActivityDigestBody(date, timezone, snapshots) {
+  assertValidTimezone(timezone);
+  const ordered = sortedByTime(snapshots);
+  const dwell = computeDwell(ordered);
+  return [
+    `# Activity \u2014 ${date}`,
+    "",
+    perAppSection(ordered, dwell),
+    "",
+    timelineSection(ordered, timezone),
+    "",
+    notableSection(ordered, dwell),
+    ""
+  ].join("\n");
+}
+function hashActivityBody(body) {
+  return createHash9("sha256").update(body, "utf8").digest("hex");
+}
+function composeActivityDigestMeta(date, machines, snapshots, body) {
+  const uniqueMachines = [...new Set(machines)].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return {
+    kind: "activity-digest",
+    date,
+    machines: uniqueMachines,
+    snapshotCount: snapshots.length,
+    contentHash: hashActivityBody(body),
+    formatVersion: ACTIVITY_DIGEST_FORMAT_VERSION
+  };
+}
+function serializeActivityDigest(meta, body) {
+  const frontmatter = [
+    "---",
+    `kind: ${meta.kind}`,
+    `date: ${meta.date}`,
+    `machines: ${JSON.stringify(meta.machines)}`,
+    `snapshotCount: ${meta.snapshotCount}`,
+    `contentHash: ${meta.contentHash}`,
+    `formatVersion: ${meta.formatVersion}`,
+    "---",
+    ""
+  ].join("\n");
+  return `${frontmatter}${body}`;
+}
+function parseActivityDigest(raw) {
+  if (typeof raw !== "string" || !raw.startsWith("---\n")) return null;
+  const end = raw.indexOf("\n---\n", 4);
+  if (end === -1) return null;
+  const frontmatter = raw.slice(4, end);
+  const body = raw.slice(end + 5).replace(/^\n/, "");
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of frontmatter.split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    fields.set(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+  }
+  const date = fields.get("date");
+  const contentHash = fields.get("contentHash");
+  if (date === void 0 || !isValidActivityDate(date) || contentHash === void 0) return null;
+  if (fields.get("kind") !== "activity-digest") return null;
+  const machines = parseMachinesList(fields.get("machines") ?? "[]");
+  const snapshotCount = parseNonNegativeInt(fields.get("snapshotCount"));
+  const formatVersion = parseNonNegativeInt(fields.get("formatVersion"));
+  if (snapshotCount === null || formatVersion === null) return null;
+  return {
+    meta: {
+      kind: "activity-digest",
+      date,
+      machines,
+      snapshotCount,
+      contentHash,
+      formatVersion
+    },
+    body
+  };
+}
+function parseNonNegativeInt(value) {
+  if (value === void 0) return null;
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) return null;
+  const parsed = Number(trimmed);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function parseMachinesList(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((entry) => typeof entry === "string");
+    }
+  } catch {
+  }
+  return raw.replace(/^\[/, "").replace(/\]$/, "").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+
+// src/session-summaries/index.ts
+import { createHash as createHash10 } from "crypto";
+import { lstat as lstat2, mkdir as mkdir8, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
+import path31 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -23415,12 +23988,12 @@ var DEFAULT_MAX_FILES = 5e3;
 var DEFAULT_MAX_SESSIONS = 500;
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".jsonl"]);
 function shortHash(value, length = 16) {
-  return createHash9("sha256").update(value).digest("hex").slice(0, length);
+  return createHash10("sha256").update(value).digest("hex").slice(0, length);
 }
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path29.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path31.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -23430,13 +24003,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path29.extname(entry.name).toLowerCase();
+      const ext = path31.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -23463,7 +24036,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path29.resolve(expandTildePath(inputDir.trim()));
+  return path31.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -23620,11 +24193,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path29.extname(filePath).toLowerCase();
+    const fileExtension = path31.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path29.basename(filePath),
+        fileName: path31.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -23680,7 +24253,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile6(path29.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile6(path31.resolve(expandTildePath(pathLike)), "utf-8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("redaction config must be a JSON object");
@@ -23693,15 +24266,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path29.join(
-    path29.resolve(expandTildePath(memoryDir)),
+  return path31.join(
+    path31.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path29.dirname(filePath), { recursive: true });
+  await mkdir8(path31.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -23719,7 +24292,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path29.resolve(expandTildePath(options.output));
+    const outputPath = path31.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -23753,20 +24326,20 @@ async function runLocalSessionSummaryCliCommand(options) {
 }
 
 // src/transfer/capsule-fork.ts
-import { lstat as lstat3, mkdir as mkdir8, readFile as readFile7, realpath as realpath2, writeFile as writeFile8 } from "fs/promises";
-import path30 from "path";
+import { lstat as lstat3, mkdir as mkdir9, readFile as readFile7, realpath as realpath2, writeFile as writeFile8 } from "fs/promises";
+import path32 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path30.resolve(opts.targetRoot);
+  const rootAbs = path32.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path30.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path32.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path30.resolve(opts.sourceArchive);
+  const archiveAbs = path32.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -23788,10 +24361,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path30.join(forkDirAbs, "lineage.json");
+  const lineagePath = path32.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath2(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path30.dirname(lineagePath), { recursive: true });
+  await mkdir9(path32.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -23805,11 +24378,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path30.resolve(targetRoot);
+  const rootAbs = path32.resolve(targetRoot);
   const rootReal = await realpath2(rootAbs).catch(() => rootAbs);
-  const lineagePath = path30.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path30.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path30.isAbsolute(rel)) {
+  const lineagePath = path32.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path32.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path32.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -23850,19 +24423,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path30.dirname(existing)) {
+  while (existing !== path32.dirname(existing)) {
     const st = await lstat3(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path30.basename(existing));
-    existing = path30.dirname(existing);
+    suffix.unshift(path32.basename(existing));
+    existing = path32.dirname(existing);
   }
   const existingReal = await realpath2(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path30.join(existingReal, ...suffix) : existingReal;
-  const rel = path30.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path32.join(existingReal, ...suffix) : existingReal;
+  const rel = path32.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path30.sep}`)) return false;
-  if (path30.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path32.sep}`)) return false;
+  if (path32.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -23989,6 +24562,21 @@ export {
   ensureBuiltInWearableConnectors,
   WearablesService,
   locateTranscriptPath,
+  activityDatabasePath,
+  ensureActivityStateDir,
+  openActivityDatabase,
+  applyActivitySchema,
+  ActivityStore,
+  ACTIVITY_DIGEST_FORMAT_VERSION,
+  ACTIVITY_DIR_NAME,
+  isValidActivityDate,
+  activityDigestPath,
+  activityDayWindow,
+  composeActivityDigestBody,
+  hashActivityBody,
+  composeActivityDigestMeta,
+  serializeActivityDigest,
+  parseActivityDigest,
   registerLocalSessionSourceAdapter,
   getLocalSessionSourceAdapter,
   listLocalSessionSourceAdapters,
@@ -24004,4 +24592,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-7PY55HMI.js.map
+//# sourceMappingURL=chunk-3VBXP5HS.js.map