@remnic/core 9.15.2 → 9.16.0

package/src/activity/runner.test.ts

@@ -0,0 +1,452 @@
+import assert from "node:assert/strict";
+import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { activityDatabasePath, ActivityStore } from "./store.js";
+import { activityDigestPath } from "./digest.js";
+import { runActivitySyncOnce } from "./runner.js";
+import { activityCursorKey } from "./pipeline.js";
+import type {
+  ActivityConfig,
+  ActivitySnapshot,
+  ActivitySnapshotPage,
+  ActivitySourceClient,
+} from "./types.js";
+
+const NOW = new Date("2026-07-22T18:00:00.000Z");
+
+function snapshot(overrides: Partial<ActivitySnapshot> = {}): ActivitySnapshot {
+  return {
+    machine: "wire-payload-label",
+    capturedAtUtc: "2026-07-22T14:00:00.000Z",
+    app: "Browser",
+    windowTitle: "Example",
+    text: "A synthetic activity snapshot",
+    textSource: "ax",
+    contentHash: "hash-1",
+    ...overrides,
+  };
+}
+
+/** A recording fixture daemon: serves scripted pages keyed by inbound cursor. */
+function fixtureClient(
+  machineLabel: string,
+  pages: Map<string | null, ActivitySnapshotPage>,
+): ActivitySourceClient & { seenCursors: Array<string | null> } {
+  const seenCursors: Array<string | null> = [];
+  return {
+    machineLabel,
+    seenCursors,
+    async verify() {
+      return { ok: true };
+    },
+    async fetchSnapshots({ cursor, signal }) {
+      signal?.throwIfAborted();
+      const key = cursor ?? null;
+      seenCursors.push(key);
+      const page = pages.get(key);
+      if (page === undefined) throw new Error(`fixture has no page for cursor ${String(key)}`);
+      return page;
+    },
+  };
+}
+
+function enabledConfig(overrides: Partial<ActivityConfig> = {}): ActivityConfig {
+  return {
+    enabled: true,
+    timezone: "UTC",
+    syncDays: 1,
+    autoSyncIntervalMinutes: 15,
+    sources: [{ machineLabel: "workstation-a", baseUrl: "http://127.0.0.1:8760" }],
+    ...overrides,
+  };
+}
+
+test("disabled config makes no client, no HTTP call, and no store write", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  try {
+    let clientBuilt = false;
+    const summary = await runActivitySyncOnce({
+      config: {
+        enabled: false,
+        timezone: "UTC",
+        syncDays: 1,
+        autoSyncIntervalMinutes: 15,
+        sources: [{ machineLabel: "workstation-a", baseUrl: "http://127.0.0.1:8760" }],
+      },
+      memoryDir,
+      now: NOW,
+      createSourceClient: () => {
+        clientBuilt = true;
+        throw new Error("disabled runner must never build a source client");
+      },
+    });
+
+    assert.equal(summary.enabled, false);
+    assert.deepEqual(summary.results, []);
+    assert.equal(summary.ranCount, 0);
+    assert.equal(clientBuilt, false, "no client instantiated while disabled");
+    await assert.rejects(
+      access(activityDatabasePath(memoryDir)),
+      "disabled runner must not open (create) the activity store",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("enabled source syncs from parsed config: persists, renders digest, advances cursor", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const client = fixtureClient(
+      "workstation-a",
+      new Map([
+        [null, { snapshots: [snapshot()], nextCursor: "c1" }],
+        ["c1", { snapshots: [snapshot({ contentHash: "hash-2" })], nextCursor: null }],
+      ]),
+    );
+
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig(),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+    });
+
+    assert.equal(summary.enabled, true);
+    assert.equal(summary.ranCount, 1);
+    assert.equal(summary.errorCount, 0);
+    assert.equal(summary.totalInserted, 2);
+    assert.deepEqual(summary.results[0], {
+      machineLabel: "workstation-a",
+      ran: true,
+      fetched: 2,
+      inserted: 2,
+      duplicates: 0,
+      digestsWritten: 1,
+      cursor: "c1",
+    });
+    assert.equal(store.getCursor(activityCursorKey("workstation-a", "2026-07-22")), "c1");
+    assert.match(await readFile(activityDigestPath(memoryDir, "2026-07-22"), "utf8"), /snapshotCount: 2/);
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("multi-source: one source's fault is isolated and never advances the other", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const healthy = fixtureClient(
+      "workstation-a",
+      new Map([[null, { snapshots: [snapshot()], nextCursor: null }]]),
+    );
+    const faulty: ActivitySourceClient = {
+      machineLabel: "workstation-b",
+      async verify() {
+        return { ok: true };
+      },
+      async fetchSnapshots() {
+        // A network-shaped error whose message embeds a host: it must be
+        // sanitized to a name+code, not echoed verbatim, on ActivitySourceRunItem.
+        throw Object.assign(new Error("daemon connection refused at 10.0.0.5:8761"), { code: "ECONNREFUSED" });
+      },
+    };
+
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig({
+        sources: [
+          { machineLabel: "workstation-a", baseUrl: "http://127.0.0.1:8760" },
+          { machineLabel: "workstation-b", baseUrl: "http://127.0.0.1:8761" },
+        ],
+      }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: (source) => (source.machineLabel === "workstation-a" ? healthy : faulty),
+    });
+
+    assert.equal(summary.ranCount, 1);
+    assert.equal(summary.errorCount, 1);
+    const byLabel = new Map(summary.results.map((item) => [item.machineLabel, item]));
+    assert.equal(byLabel.get("workstation-a")?.ran, true);
+    assert.equal(byLabel.get("workstation-a")?.inserted, 1);
+    assert.equal(byLabel.get("workstation-a")?.error, undefined);
+    assert.equal(byLabel.get("workstation-b")?.ran, false);
+    assert.match(byLabel.get("workstation-b")?.error ?? "", /ECONNREFUSED/);
+    assert.ok(!byLabel.get("workstation-b")?.error?.includes("10.0.0.5"), "raw host is sanitized out of the error");
+    // The healthy source still committed; the faulty one never wrote a cursor.
+    assert.equal(store.getCursor(activityCursorKey("workstation-b", "2026-07-22")), null);
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("error stays distinguishable from an empty page", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const empty = fixtureClient(
+      "empty-src",
+      new Map([[null, { snapshots: [], nextCursor: null }]]),
+    );
+    const faulty: ActivitySourceClient = {
+      machineLabel: "fault-src",
+      async verify() {
+        return { ok: true };
+      },
+      async fetchSnapshots() {
+        throw new Error("HTTP 503");
+      },
+    };
+
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig({
+        sources: [
+          { machineLabel: "empty-src", baseUrl: "http://127.0.0.1:8760" },
+          { machineLabel: "fault-src", baseUrl: "http://127.0.0.1:8761" },
+        ],
+      }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: (source) => (source.machineLabel === "empty-src" ? empty : faulty),
+    });
+
+    const byLabel = new Map(summary.results.map((item) => [item.machineLabel, item]));
+    // Empty page: a real, successful sync that fetched and inserted nothing.
+    assert.equal(byLabel.get("empty-src")?.ran, true);
+    assert.equal(byLabel.get("empty-src")?.inserted, 0);
+    assert.equal(byLabel.get("empty-src")?.error, undefined);
+    // Fault: surfaced as an error, not silently conflated with an empty result.
+    assert.equal(byLabel.get("fault-src")?.ran, false);
+    assert.notEqual(byLabel.get("fault-src")?.error, undefined);
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("stop: an aborted run leaves the cursor unadvanced", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const client = fixtureClient(
+      "workstation-a",
+      new Map([[null, { snapshots: [snapshot()], nextCursor: null }]]),
+    );
+
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig(),
+      memoryDir,
+      store,
+      now: NOW,
+      signal: AbortSignal.abort(),
+      createSourceClient: () => client,
+    });
+
+    assert.equal(summary.errorCount, 1);
+    assert.equal(summary.ranCount, 0);
+    assert.equal(client.seenCursors.length, 0, "aborted before any fetch reached the daemon");
+    assert.equal(store.getCursor(activityCursorKey("workstation-a", "2026-07-22")), null, "no cursor persisted on abort");
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("abort halts the whole run: later sources never build a client or sync", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const built: string[] = [];
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig({
+        sources: [
+          { machineLabel: "workstation-a", baseUrl: "http://127.0.0.1:8760" },
+          { machineLabel: "workstation-b", baseUrl: "http://127.0.0.1:8761" },
+        ],
+      }),
+      memoryDir,
+      store,
+      now: NOW,
+      signal: AbortSignal.abort(),
+      createSourceClient: (source) => {
+        built.push(source.machineLabel);
+        return fixtureClient(source.machineLabel, new Map([[null, { snapshots: [snapshot()], nextCursor: null }]]));
+      },
+    });
+
+    // The first source's fast-failing (aborted) attempt is recorded; the run
+    // then halts — the second source is never even instantiated.
+    assert.deepEqual(built, ["workstation-a"], "abort stops the run before later sources build a client");
+    assert.equal(summary.results.length, 1);
+    assert.equal(summary.ranCount, 0);
+    assert.equal(summary.errorCount, 1);
+    assert.equal(store.getCursor(activityCursorKey("workstation-b", "2026-07-22")), null);
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("restart: a fresh run resumes from the persisted cursor", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const first = fixtureClient(
+      "workstation-a",
+      new Map([
+        [null, { snapshots: [snapshot()], nextCursor: "c1" }],
+        ["c1", { snapshots: [snapshot({ contentHash: "hash-2" })], nextCursor: null }],
+      ]),
+    );
+    await runActivitySyncOnce({
+      config: enabledConfig(),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => first,
+    });
+    assert.equal(store.getCursor(activityCursorKey("workstation-a", "2026-07-22")), "c1");
+
+    // Simulate a process restart: a brand-new client that only knows how to
+    // continue from the persisted cursor. If the runner ignored it, this
+    // fixture would throw ("no page for cursor null").
+    const second = fixtureClient(
+      "workstation-a",
+      new Map([["c1", { snapshots: [snapshot({ contentHash: "hash-3" })], nextCursor: null }]]),
+    );
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig(),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => second,
+    });
+
+    assert.deepEqual(second.seenCursors, ["c1"], "restart resumed from the stored cursor");
+    assert.equal(summary.results[0]?.inserted, 1);
+    assert.equal(store.getCursor(activityCursorKey("workstation-a", "2026-07-22")), "c1");
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("reindexSearch is forwarded per source and a failure never fails the run", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const client = fixtureClient(
+      "workstation-a",
+      new Map([[null, { snapshots: [snapshot()], nextCursor: null }]]),
+    );
+    let reindexCalls = 0;
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig(),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+      reindexSearch: async () => {
+        reindexCalls += 1;
+        // Realistic forced-strict failure surfaced by updateCollectionStrict.
+        throw new Error("QMD update skipped by per-collection failure backoff");
+      },
+    });
+
+    assert.equal(reindexCalls, 1, "the runner forwards reindexSearch to the source sync");
+    // Durable write still committed despite the reindex failure:
+    assert.equal(summary.ranCount, 1, "a reindex failure does not fail the source");
+    assert.equal(summary.errorCount, 0, "a reindex failure is not a sync error");
+    assert.equal(summary.results[0]?.ran, true);
+    assert.equal(summary.results[0]?.inserted, 1);
+    // ...but the failed refresh is surfaced as a signal, not a silent clean run:
+    assert.equal(summary.reindexErrorCount, 1, "the failed refresh is counted");
+    assert.match(summary.results[0]?.reindexError ?? "", /failure backoff/);
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("partial multi-day sync reports ran=true for days that synced before a later failure", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    let calls = 0;
+    const client: ActivitySourceClient = {
+      machineLabel: "workstation-a",
+      async verify() {
+        return { ok: true };
+      },
+      async fetchSnapshots() {
+        calls += 1;
+        // First local day (oldest) syncs; the second day's daemon call fails.
+        if (calls === 1) return { snapshots: [snapshot({ capturedAtUtc: "2026-07-21T14:00:00.000Z" })], nextCursor: null };
+        throw new Error("activity source HTTP 503");
+      },
+    };
+
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig({ syncDays: 2 }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+    });
+
+    const item = summary.results[0];
+    assert.equal(item?.ran, true, "the earlier day synced durably, so ran is true despite the later failure");
+    assert.equal(item?.inserted, 1);
+    assert.match(item?.error ?? "", /HTTP 503/);
+    assert.equal(summary.ranCount, 1, "a partially-synced source still counts as ran");
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("an older-day failure does not starve newer dates in a multi-day window", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    let calls = 0;
+    const client: ActivitySourceClient = {
+      machineLabel: "workstation-a",
+      async verify() {
+        return { ok: true };
+      },
+      async fetchSnapshots() {
+        calls += 1;
+        // Dates are oldest-first: the first call is the OLDER day and fails;
+        // the newer day (today) must still sync.
+        if (calls === 1) throw new Error("activity source HTTP 500");
+        return { snapshots: [snapshot()], nextCursor: null };
+      },
+    };
+
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig({ syncDays: 2 }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+    });
+
+    const item = summary.results[0];
+    assert.equal(item?.ran, true, "the newer day synced despite the older day's failure");
+    assert.equal(item?.inserted, 1, "the newer day's snapshot was persisted");
+    assert.match(item?.error ?? "", /HTTP 500/, "the failed older day is still reported");
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/activity/runner.ts

@@ -0,0 +1,237 @@
+/**
+ * Host-agnostic activity sync runner (issue #1900).
+ *
+ * Bridges parsed `config.activity` to the durable sync pipeline: the parser
+ * (config.ts) validates settings but never contacts a daemon, and
+ * `syncActivitySource` (pipeline.ts) syncs one source for one day. This runner
+ * is the missing middle — it instantiates one `ActivityHttpSourceClient` per
+ * configured source from the parsed config and drives a sync across the
+ * `syncDays` local-day window, but ONLY when the feature is enabled.
+ *
+ * The feature is master default-off: source config alone never starts a sync.
+ * When `config.enabled` is false the runner opens no store, builds no client,
+ * and makes no HTTP call or write — it returns a disabled summary. This mirrors
+ * `runLiveConnectorsOnce`'s disabled-vs-result reporting so a host scheduler
+ * (CLI, cron) can trigger it through the runtime with no OpenClaw imports.
+ *
+ * Cursor semantics are delegated wholesale to `syncActivitySource`: the
+ * per-machine cursor advances only after every page and the digest are durable,
+ * so a runtime failure (or an aborted stop) leaves the cursor unadvanced and a
+ * restart resumes from the persisted position. A per-source failure is captured
+ * as an error item and never aborts the other sources or the host flow.
+ */
+
+import { ActivityStore } from "./store.js";
+import { syncActivitySource } from "./pipeline.js";
+import { ActivityHttpSourceClient } from "./source-client.js";
+import { displayErrorDetail } from "../runtime/better-sqlite.js";
+import type { ActivityConfig, ActivitySourceClient, ActivitySourceConfig } from "./types.js";
+
+type ActivityNow = Date | (() => Date);
+
+/** One configured source's aggregate result across the synced day window. */
+export interface ActivitySourceRunItem {
+  machineLabel: string;
+  /** True when at least one day synced durably (no error). */
+  ran: boolean;
+  fetched: number;
+  inserted: number;
+  duplicates: number;
+  digestsWritten: number;
+  /** Persisted cursor after the run; unadvanced from prior on failure. */
+  cursor: string | null;
+  /** Set when the source failed; distinguishes a fault from an empty page. */
+  error?: string;
+  /**
+   * Set when a durable day synced but its post-digest search reindex failed.
+   * The rows/digest/cursor are committed; the index is stale until the next
+   * refresh, so this is a signal (not a sync failure) for the scheduler.
+   */
+  reindexError?: string;
+}
+
+export interface ActivitySyncRunSummary {
+  ranAt: string;
+  /** False means the feature is off: no client built, no HTTP, no write. */
+  enabled: boolean;
+  ranCount: number;
+  errorCount: number;
+  /** Sources whose durable sync succeeded but whose search reindex failed. */
+  reindexErrorCount: number;
+  totalInserted: number;
+  results: ActivitySourceRunItem[];
+}
+
+export interface ActivitySyncRunOptions {
+  config: ActivityConfig;
+  memoryDir: string;
+  /** Injectable store; opened from memoryDir when omitted (and closed here). */
+  store?: ActivityStore;
+  /** Clock injection for deterministic day-window resolution in tests. */
+  now?: ActivityNow;
+  /** Abort a run in flight (stop); an aborted source leaves its cursor intact. */
+  signal?: AbortSignal;
+  /** Injectable client factory; builds an ActivityHttpSourceClient by default. */
+  createSourceClient?: (source: ActivitySourceConfig) => ActivitySourceClient;
+  /**
+   * Search-index refresh forwarded to each source sync as `afterWrites`, run
+   * after a digest is (re)written so it becomes discoverable (rule 31).
+   * Host wires the core index seam (SearchBackend.update); best-effort.
+   */
+  reindexSearch?: (signal?: AbortSignal) => Promise<void>;
+}
+
+/** Format a Date as YYYY-MM-DD in an IANA timezone (local calendar day). */
+function localDateInTimezone(instant: Date, timezone: string): string {
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+    }).formatToParts(instant);
+    const get = (type: string): string => parts.find((part) => part.type === type)?.value ?? "";
+    return `${get("year")}-${get("month")}-${get("day")}`;
+  } catch {
+    return instant.toISOString().slice(0, 10);
+  }
+}
+
+/** Previous calendar date via pure date arithmetic (no DST wall-clock drift). */
+function previousIsoDate(date: string): string {
+  const parsed = new Date(`${date}T00:00:00Z`);
+  parsed.setUTCDate(parsed.getUTCDate() - 1);
+  return parsed.toISOString().slice(0, 10);
+}
+
+/**
+ * The local-day window to sync, oldest first: today back `syncDays` calendar
+ * days in the configured timezone. Walking by calendar days (not fixed 24h
+ * intervals) keeps the window correct across DST transitions.
+ */
+export function resolveActivitySyncDates(syncDays: number, timezone: string, now: Date): string[] {
+  const dates: string[] = [];
+  let cursor = localDateInTimezone(now, timezone);
+  for (let count = 0; count < syncDays; count++) {
+    dates.unshift(cursor);
+    cursor = previousIsoDate(cursor);
+  }
+  return dates;
+}
+
+/**
+ * Operator-facing detail for a per-source/per-day sync fault. Our own
+ * controlled messages (activity.../Invalid activity...) are informative and
+ * safe to surface; opaque network/runtime errors can embed hostnames or paths,
+ * so they are reduced to a sanitized name+code (matches ActivityHttpSourceClient.verify).
+ */
+function sanitizedSyncError(error: unknown): string {
+  return error instanceof Error && /^(activity|Invalid activity)/.test(error.message)
+    ? error.message
+    : displayErrorDetail(error) || "activity sync failed";
+}
+
+/**
+ * Run one activity sync pass across every configured source. Disabled config
+ * short-circuits before any store/client/HTTP work; an enabled config syncs
+ * each source across the `syncDays` window and isolates per-source faults.
+ */
+export async function runActivitySyncOnce(options: ActivitySyncRunOptions): Promise<ActivitySyncRunSummary> {
+  const ranAt = typeof options.now === "function" ? options.now() : options.now ?? 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: ActivitySourceConfig): ActivitySourceClient =>
+      new ActivityHttpSourceClient({
+        machineLabel: source.machineLabel,
+        baseUrl: source.baseUrl,
+        ...(source.token === undefined ? {} : { token: source.token }),
+      }));
+  const ownStore = options.store === undefined;
+  const store = options.store ?? ActivityStore.open(options.memoryDir);
+  const results: ActivitySourceRunItem[] = [];
+
+  try {
+    for (const sourceConfig of options.config.sources) {
+      const item: ActivitySourceRunItem = {
+        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 === undefined ? {} : { 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;
+            // A day that synced durably counts as ran, even if a later day in
+            // the window fails (ran = at least one durable day).
+            item.ran = true;
+            // The day's rows/digest/cursor are durable; a failed post-digest
+            // reindex is a separate, already-sanitized signal (not a sync
+            // failure) so the scheduler can observe a stale index.
+            if (result.reindexError !== undefined) item.reindexError = result.reindexError;
+          } catch (dateError) {
+            // One bad day (a malformed historical snapshot, a per-day daemon
+            // error) must not starve the remaining dates — record it and move
+            // on. Dates are processed oldest-first, so continuing keeps today's
+            // sync alive when an old backfill day is broken. An abort, though,
+            // halts the whole run.
+            item.error = sanitizedSyncError(dateError);
+            if (options.signal?.aborted) break;
+          }
+        }
+      } catch (error) {
+        // Client construction failed: no date could run for this source.
+        item.error = sanitizedSyncError(error);
+      }
+      results.push(item);
+      // An abort halts the WHOLE run: the in-flight source above is recorded
+      // (its fast-failing attempt reports an error), but no later source builds
+      // a client or contacts a daemon — teardown settles promptly.
+      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 !== undefined).length,
+    reindexErrorCount: results.filter((item) => item.reindexError !== undefined).length,
+    totalInserted: results.reduce((sum, item) => sum + item.inserted, 0),
+    results,
+  };
+}