@remnic/core 9.69.33 → 9.69.35

package/dist/{chunk-2C3S7J2S.js → chunk-2BQ4ZIWC.js}

@@ -1,3 +1,6 @@
+import {
+  startLocationAutoSync
+} from "./chunk-776GVKL7.js";
 import {
   ensureContradictionScanCron,
   ensureDaySummaryCron,
@@ -7,28 +10,41 @@ import {
   ensureProceduralMiningCron,
   graphEdgeDecayCadenceToCronExpr
 } from "./chunk-666A3MOW.js";
-import {
-  startLocationAutoSync
-} from "./chunk-H4VH5VIB.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-KCB7F4J7.js";
+} from "./chunk-QURNMKME.js";
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-X35W4S3L.js";
+} from "./chunk-ZBEGS7OB.js";
 import {
   rebuildMemoryProjection
-} from "./chunk-NB5BCFUY.js";
+} from "./chunk-WHHEPAO3.js";
+import {
+  DEFAULT_TIMELINE_CATEGORIES,
+  TIMELINE_RESERVED_IDLE,
+  TIMELINE_RESERVED_PAUSE,
+  TIMELINE_RESERVED_UNKNOWN,
+  analyzeTimelineCards,
+  buildAnalysisRunMetadata,
+  timelineAnalysisCompleteFromClients,
+  validateActivityBaseUrl,
+  validateTimelineCategories
+} from "./chunk-5HYUUFMQ.js";
+import {
+  LocalLlmClient
+} from "./chunk-MVAQ2WM3.js";
 import {
-  validateActivityBaseUrl
-} from "./chunk-5VCDKQWQ.js";
+  FallbackLlmClient,
+  fallbackLlmRuntimeContextFromConfig
+} from "./chunk-YEN4TREG.js";
 import {
   activityDateInTimezone,
   activityDayWindow,
   activityDigestPath,
   composeActivityDigestBody,
   composeActivityDigestMeta,
+  hashActivityBody,
   isValidActivityDate,
   serializeActivityDigest
 } from "./chunk-353C5UNV.js";
@@ -76,7 +92,7 @@ import {
 // 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 path3 from "path";
+import path5 from "path";
 
 // src/maintenance/day-summary-cron.ts
 function resolveDaySummaryCronModel(config) {
@@ -407,6 +423,17 @@ var ActivityStore = class _ActivityStore {
     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();
   }
@@ -601,8 +628,8 @@ function responsePage(value, machine) {
     nextCursor
   };
 }
-function requestUrl(baseUrl, path4, query) {
-  const url = new URL(path4, baseUrl);
+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();
@@ -654,6 +681,651 @@ var ActivityHttpSourceClient = class {
   }
 };
 
+// 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 fromMs = window.from === void 0 ? Date.now() : Date.parse(window.from);
+    const toMs = window.to === void 0 ? fromMs + 1 : Date.parse(window.to);
+    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({
+      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({ 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`);
@@ -740,6 +1412,24 @@ async function runActivitySyncOnce(options) {
       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();
   }
@@ -779,7 +1469,8 @@ var ActivitySyncScheduler = class {
       config: this.config,
       memoryDir: this.memoryDir,
       signal,
-      ...options.reindexSearch === void 0 ? {} : { reindexSearch: options.reindexSearch }
+      ...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);
@@ -865,6 +1556,7 @@ var ActivitySyncRegistrar = class {
         // 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.
@@ -918,6 +1610,7 @@ var MaintenanceScheduler = class {
       secureStoreEnabled: resolveRecallAuxiliaryCapabilities(deps.config).secureStore,
       getQmd: () => deps.getQmd(),
       requestReindexRetry: () => this.requestQmdMaintenanceForTool("activity-reindex-retry"),
+      pluginConfig: deps.config,
       ...deps.onActivitySynced ? { onSynced: deps.onActivitySynced } : {}
     });
   }
@@ -1015,7 +1708,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    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");
@@ -1045,7 +1738,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    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");
@@ -1067,7 +1760,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    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");
@@ -1087,7 +1780,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    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");
@@ -1107,7 +1800,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    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");
@@ -1127,7 +1820,7 @@ var MaintenanceScheduler = class {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    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");
@@ -1399,7 +2092,7 @@ var MaintenanceScheduler = class {
    */
   async hasOverCapEncryptedLifecycleLedger(targets) {
     for (const target of targets) {
-      const ledgerPath = path3.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+      const ledgerPath = path5.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
       let size;
       try {
         size = (await stat(ledgerPath)).size;
@@ -1451,7 +2144,7 @@ var MaintenanceScheduler = class {
    * containment guard on every spill file it reads or deletes.
    */
   async drainPendingLifecycleAppendsForPath(memoryDir) {
-    const ledgerPath = path3.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path5.join(memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     const spillDir = pendingLifecycleLedgerDir(ledgerPath);
     let spillFiles;
     let claimedOrphans;
@@ -1465,7 +2158,7 @@ var MaintenanceScheduler = class {
     if (spillFiles.length === 0 && claimedOrphans.length === 0) return;
     const io = {
       writeSecure: async (filePath, payload) => {
-        await mkdir3(path3.dirname(filePath), { recursive: true });
+        await mkdir3(path5.dirname(filePath), { recursive: true });
         await writeFile2(filePath, payload, "utf-8");
       },
       readSecure: async (filePath) => {
@@ -1486,7 +2179,7 @@ var MaintenanceScheduler = class {
           await appendFile(ledgerPath, payload, "utf-8");
         },
         async () => {
-          await mkdir3(path3.dirname(ledgerPath), { recursive: true });
+          await mkdir3(path5.dirname(ledgerPath), { recursive: true });
         }
       );
     } catch (err) {
@@ -1504,7 +2197,7 @@ var MaintenanceScheduler = class {
     const targets = [];
     const seen = /* @__PURE__ */ new Set();
     const addTarget = (memoryDir, storage) => {
-      const key = path3.resolve(memoryDir);
+      const key = path5.resolve(memoryDir);
       if (seen.has(key)) return;
       seen.add(key);
       targets.push({ memoryDir, storage });
@@ -1533,7 +2226,7 @@ var MaintenanceScheduler = class {
       }
     }
     if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      const namespacesBase = path3.join(this.deps.config.memoryDir, "namespaces");
+      const namespacesBase = path5.join(this.deps.config.memoryDir, "namespaces");
       let memoryDirReal;
       try {
         memoryDirReal = await realpath(this.deps.config.memoryDir);
@@ -1558,7 +2251,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 = path3.join(namespacesBase, entry.name);
+        const childPath = path5.join(namespacesBase, entry.name);
         try {
           assertPathInsideRoot(memoryDirReal, await realpath(childPath), childPath);
         } catch (err) {
@@ -1570,7 +2263,7 @@ var MaintenanceScheduler = class {
         if (resolveNamespaceStorage && routeNamespace !== null) {
           try {
             const storage = await resolveNamespaceStorage(routeNamespace);
-            if (path3.resolve(storage.dir) === path3.resolve(childPath)) {
+            if (path5.resolve(storage.dir) === path5.resolve(childPath)) {
               addTarget(storage.dir, storage);
               continue;
             }
@@ -1601,7 +2294,7 @@ var MaintenanceScheduler = class {
    * an over-cap rewrite never arms the throttle.
    */
   async compactLifecycleLedgerTarget(target, threshold) {
-    const ledgerPath = path3.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+    const ledgerPath = path5.join(target.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
     let size = 0;
     try {
       size = (await stat(ledgerPath)).size;
@@ -1723,10 +2416,30 @@ export {
   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-2C3S7J2S.js.map
+//# sourceMappingURL=chunk-2BQ4ZIWC.js.map