@gmickel/gno 2.4.0 → 2.6.0

package/src/sessions/automation-state.ts

@@ -0,0 +1,444 @@
+/**
+ * Machine-written automation run state: one coalesced pending marker per
+ * profile plus the daemon heartbeat.
+ *
+ * Lives in `<archiveRoot>/.gno-sessions/automation.json` beside the import
+ * checkpoint, never in the owner's config. Every change is serialized by
+ * `automation.lock` and written atomically (private temp file, fsync,
+ * rename, directory fsync), so an admission is acknowledged only once it is
+ * durable. Transitions are pure functions over the loaded record so they can
+ * be driven with a fake clock.
+ *
+ * Generation contract: a trigger increments `generation`; a run records the
+ * generation it started with and a completed run consumes only that one, so a
+ * trigger arriving mid-run stays pending. Nothing here imports or parses
+ * sessions.
+ *
+ * @module src/sessions/automation-state
+ */
+
+// node:fs/promises: fsync (FileHandle.sync), rename, chmod and stat have no Bun equivalents.
+import { chmod, open, rename, stat, unlink } from "node:fs/promises";
+// node:path: no Bun path utilities.
+import { dirname, join } from "node:path";
+
+import type {
+  SessionRunRecord,
+  SessionTriggerKind,
+  SessionsErrorCode,
+} from "./types";
+
+import { acquireSqliteWriteLock } from "../core/file-lock";
+import { SESSION_STATE_DIRNAME } from "./archive";
+import { SessionsError } from "./types";
+
+export const AUTOMATION_STATE_VERSION = "1";
+/** Daemon wake-up: heartbeat, schedule check and pending drain. */
+export const AUTOMATION_TICK_MS = 30_000;
+/** A heartbeat older than this means the daemon is gone or stuck. */
+export const AUTOMATION_HEARTBEAT_STALE_MS = 3 * AUTOMATION_TICK_MS;
+/** Longest a hook waits for the marker lock before reporting a failure. */
+export const HOOK_ADMISSION_DEADLINE_MS = 1_000;
+/** Default changed units per source per run. */
+export const DEFAULT_AUTOMATION_LIMIT = 200;
+/** Default automatic retries after a failed run. */
+export const DEFAULT_AUTOMATION_RETRIES = 3;
+/** Shortest schedule cadence; imports enumerate every unit of a source. */
+export const MIN_AUTOMATION_CADENCE_MS = 60_000;
+/** A recorded run older than this is treated as interrupted (pid reuse). */
+export const AUTOMATION_RUN_STALE_MS = 2 * 60 * 60_000;
+const RETRY_BASE_MS = 60_000;
+const RETRY_MAX_MS = 30 * 60_000;
+
+export interface ProfileRunState {
+  /** Latest admitted trigger generation. */
+  generation: number;
+  /** Generation consumed by the last completed run. */
+  consumed: number;
+  pendingSince: string | null;
+  pendingTriggers: SessionTriggerKind[];
+  lastTrigger: { kind: SessionTriggerKind; at: string } | null;
+  running: {
+    generation: number;
+    triggers: SessionTriggerKind[];
+    startedAt: string;
+    pid: number;
+  } | null;
+  lastRun: SessionRunRecord | null;
+  lastSuccessAt: string | null;
+  /** Consecutive failed attempts since the last success or owner action. */
+  attempts: number;
+  /** A failure that needs owner correction; automatic triggers cannot clear it. */
+  blocked?: boolean;
+  retryAt: string | null;
+  nextDueAt: string | null;
+}
+
+export interface AutomationState {
+  schemaVersion: typeof AUTOMATION_STATE_VERSION;
+  daemon: { pid: number; startedAt: string; heartbeatAt: string } | null;
+  profiles: Record<string, ProfileRunState>;
+}
+
+export const emptyAutomationState = (): AutomationState => ({
+  schemaVersion: AUTOMATION_STATE_VERSION,
+  daemon: null,
+  profiles: {},
+});
+
+export const emptyProfileRunState = (): ProfileRunState => ({
+  generation: 0,
+  consumed: 0,
+  pendingSince: null,
+  pendingTriggers: [],
+  lastTrigger: null,
+  running: null,
+  lastRun: null,
+  lastSuccessAt: null,
+  attempts: 0,
+  retryAt: null,
+  nextDueAt: null,
+});
+
+const stateDir = (archiveRoot: string): string =>
+  join(archiveRoot, SESSION_STATE_DIRNAME);
+
+export const automationStatePath = (archiveRoot: string): string =>
+  join(stateDir(archiveRoot), "automation.json");
+
+const automationLockPath = (archiveRoot: string): string =>
+  join(stateDir(archiveRoot), "automation.lock");
+
+/** Read the state; a missing file is empty, a corrupt one is reported. */
+export async function loadAutomationState(
+  archiveRoot: string
+): Promise<{ state: AutomationState; corrupt: boolean }> {
+  const file = Bun.file(automationStatePath(archiveRoot));
+  if (!(await file.exists())) {
+    return { state: emptyAutomationState(), corrupt: false };
+  }
+  try {
+    const parsed = (await file.json()) as AutomationState;
+    if (
+      parsed?.schemaVersion === AUTOMATION_STATE_VERSION &&
+      typeof parsed.profiles === "object" &&
+      parsed.profiles !== null
+    ) {
+      return { state: parsed, corrupt: false };
+    }
+  } catch {
+    // Reported below; the next durable write replaces the file.
+  }
+  return { state: emptyAutomationState(), corrupt: true };
+}
+
+export type StateWriter = (path: string, content: string) => Promise<void>;
+
+/** Private (0600) atomic write that is on disk before it returns. */
+async function writeDurable(path: string, content: string): Promise<void> {
+  const temporary = `${path}.tmp.${process.pid}.${crypto.randomUUID()}`;
+  try {
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+      await handle.writeFile(content);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await chmod(temporary, 0o600);
+    await rename(temporary, path);
+  } catch (error) {
+    await unlink(temporary).catch(() => undefined);
+    throw error;
+  }
+  // Persist the rename itself. Directory fsync is unsupported on Windows.
+  const directory = await open(dirname(path), "r").catch(() => null);
+  await directory?.sync().catch(() => undefined);
+  await directory?.close();
+}
+
+/**
+ * Load, mutate and durably save the state under the marker lock. The
+ * archive's state directory must already exist: a removed destination is
+ * reported, never silently recreated.
+ */
+export async function mutateAutomationState<T>(
+  archiveRoot: string,
+  mutate: (state: AutomationState) => T | Promise<T>,
+  options: { lockWaitMs?: number; writeState?: StateWriter } = {}
+): Promise<T> {
+  const directory = await stat(stateDir(archiveRoot)).catch(() => null);
+  if (!directory?.isDirectory()) {
+    throw new SessionsError(
+      "SESSIONS_SOURCE_UNAVAILABLE",
+      "The session archive destination is missing; recreate it with gno sessions init, then re-enable automation."
+    );
+  }
+  const lock = await acquireSqliteWriteLock(
+    automationLockPath(archiveRoot),
+    options.lockWaitMs ?? 5_000
+  );
+  if (!lock) {
+    throw new SessionsError(
+      "SESSIONS_BUSY",
+      "Automation state is locked by another process; retry shortly."
+    );
+  }
+  try {
+    const { state } = await loadAutomationState(archiveRoot);
+    const result = await mutate(state);
+    await (options.writeState ?? writeDurable)(
+      automationStatePath(archiveRoot),
+      `${JSON.stringify(state)}\n`
+    );
+    return result;
+  } finally {
+    await lock.release();
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Pure transitions
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Own-property lookup: profile IDs such as `constructor` are valid. */
+export function ownProfile(
+  state: AutomationState,
+  id: string
+): ProfileRunState | undefined {
+  return Object.hasOwn(state.profiles, id) ? state.profiles[id] : undefined;
+}
+
+export function profileState(
+  state: AutomationState,
+  id: string
+): ProfileRunState {
+  const existing = ownProfile(state, id);
+  if (existing) return existing;
+  const created = emptyProfileRunState();
+  state.profiles[id] = created;
+  return created;
+}
+
+export const isPending = (profile: ProfileRunState): boolean =>
+  profile.generation > profile.consumed;
+
+/** Owner action (run now, reconfigure, enable): a fresh attempt budget. */
+export function unblock(profile: ProfileRunState): void {
+  profile.attempts = 0;
+  profile.retryAt = null;
+  profile.blocked = false;
+}
+
+/**
+ * Record one trigger. Duplicate triggers coalesce into the same pending run.
+ * An explicit `manual` trigger resets the retry budget; automatic triggers
+ * keep a pending backoff and a permanent block, and only re-arm a transient
+ * failure whose retries are used up.
+ */
+export function admit(
+  profile: ProfileRunState,
+  kind: SessionTriggerKind,
+  now: Date,
+  retries: number
+): number {
+  profile.generation += 1;
+  profile.pendingSince ??= now.toISOString();
+  if (!profile.pendingTriggers.includes(kind)) {
+    profile.pendingTriggers.push(kind);
+  }
+  profile.lastTrigger = { kind, at: now.toISOString() };
+  if (kind === "manual") unblock(profile);
+  else if (!profile.blocked && profile.attempts > retries) {
+    profile.attempts = 0;
+    profile.retryAt = null;
+  }
+  return profile.generation;
+}
+
+/** Disable/pause: drop admitted work that has not started. */
+export function clearPending(profile: ProfileRunState): void {
+  profile.consumed = profile.generation;
+  profile.pendingSince = null;
+  profile.pendingTriggers = [];
+  profile.attempts = 0;
+  profile.retryAt = null;
+}
+
+export function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/** A run is live while its process exists and it is not implausibly old. */
+export function isRunLive(
+  running: ProfileRunState["running"],
+  now: Date,
+  alive: (pid: number) => boolean = isProcessAlive
+): boolean {
+  if (!running) return false;
+  const age = now.getTime() - Date.parse(running.startedAt);
+  return alive(running.pid) && !(age > AUTOMATION_RUN_STALE_MS);
+}
+
+/**
+ * A run whose process is gone was interrupted: its generation was never
+ * consumed, so the work stays pending and is retried.
+ */
+export function recoverInterrupted(
+  profile: ProfileRunState,
+  now: Date,
+  alive: (pid: number) => boolean = isProcessAlive
+): boolean {
+  if (!profile.running || isRunLive(profile.running, now, alive)) return false;
+  profile.lastRun = {
+    triggers: profile.running.triggers,
+    startedAt: profile.running.startedAt,
+    finishedAt: now.toISOString(),
+    outcome: "failed",
+    reason: "interrupted",
+    threads: { imported: 0, updated: 0, unchanged: 0 },
+    units: { incomplete: 0, failed: 0, deferred: 0 },
+  };
+  profile.running = null;
+  profile.retryAt = null;
+  return true;
+}
+
+/** Whether pending work may start now (no live run, backoff elapsed, budget left). */
+export function canStart(
+  profile: ProfileRunState,
+  retries: number,
+  now: Date,
+  alive: (pid: number) => boolean = isProcessAlive
+): boolean {
+  if (!isPending(profile)) return false;
+  if (isRunLive(profile.running, now, alive)) return false;
+  if (profile.attempts > retries) return false;
+  return (
+    profile.retryAt === null || Date.parse(profile.retryAt) <= now.getTime()
+  );
+}
+
+export type StartedRun = NonNullable<ProfileRunState["running"]>;
+
+export function beginRun(
+  profile: ProfileRunState,
+  now: Date,
+  pid: number
+): StartedRun {
+  const started: StartedRun = {
+    generation: profile.generation,
+    triggers: [...profile.pendingTriggers],
+    startedAt: now.toISOString(),
+    pid,
+  };
+  profile.running = { ...started, triggers: [...started.triggers] };
+  return started;
+}
+
+/** Whether `profile` still records exactly this run (not a removed/replaced one). */
+export const ownsRun = (
+  profile: ProfileRunState,
+  started: StartedRun
+): boolean =>
+  profile.running?.pid === started.pid &&
+  profile.running.startedAt === started.startedAt &&
+  profile.running.generation === started.generation;
+
+/** Failure classes: contention and transient errors back off; the rest wait for a fix. */
+export type RunFailureClass = "contention" | "transient" | "permanent";
+
+export function retryDelayMs(attempt: number): number {
+  return Math.min(RETRY_BASE_MS * 2 ** Math.max(0, attempt - 1), RETRY_MAX_MS);
+}
+
+/**
+ * Settle a run. Success consumes the started generation (a trigger that
+ * arrived meanwhile stays pending); deferred work keeps it pending for the
+ * next tick; a failure keeps it pending with backoff or, when permanent or
+ * out of retries, until the next trigger.
+ */
+export function finishRun(
+  profile: ProfileRunState,
+  started: { generation: number },
+  run: SessionRunRecord,
+  options: { retries: number; failure?: RunFailureClass; now: Date }
+): void {
+  profile.running = null;
+  profile.lastRun = run;
+  if (run.outcome === "failed") {
+    if (options.failure === "permanent") profile.blocked = true;
+    profile.attempts =
+      options.failure === "permanent"
+        ? options.retries + 1
+        : profile.attempts + 1;
+    profile.retryAt =
+      profile.attempts <= options.retries
+        ? new Date(
+            options.now.getTime() + retryDelayMs(profile.attempts)
+          ).toISOString()
+        : null;
+    return;
+  }
+  // A partial run settles its generation but is not a successful completion.
+  if (run.outcome !== "partial") profile.lastSuccessAt = run.finishedAt;
+  unblock(profile);
+  if (run.units.deferred > 0) return;
+  profile.consumed = Math.max(profile.consumed, started.generation);
+  if (!isPending(profile)) {
+    profile.pendingSince = null;
+    profile.pendingTriggers = [];
+  }
+}
+
+/**
+ * Elapsed-cadence schedule. Missed intervals (sleep, restart, a stopped
+ * daemon) coalesce into one admission; a clock moved backwards cannot push
+ * the next run further than one cadence away.
+ */
+export function scheduleTick(
+  profile: ProfileRunState,
+  cadenceMs: number,
+  now: Date,
+  retries: number
+): boolean {
+  const nowMs = now.getTime();
+  const due = profile.nextDueAt ? Date.parse(profile.nextDueAt) : Number.NaN;
+  if (!Number.isFinite(due) || due - nowMs > cadenceMs) {
+    profile.nextDueAt = new Date(nowMs + cadenceMs).toISOString();
+    return false;
+  }
+  if (due > nowMs) return false;
+  admit(profile, "schedule", now, retries);
+  profile.nextDueAt = new Date(nowMs + cadenceMs).toISOString();
+  return true;
+}
+
+/** Stable, content-free classification of a failed run's error. */
+export function classifyRunError(code: SessionsErrorCode | null): {
+  failure: RunFailureClass;
+  reason: string;
+} {
+  switch (code) {
+    case "SESSIONS_BUSY":
+      return { failure: "contention", reason: "busy" };
+    case "SESSIONS_UNKNOWN_SOURCE":
+    case "SESSIONS_UNKNOWN_PROFILE":
+      return { failure: "permanent", reason: "source_revoked" };
+    case "SESSIONS_SOURCE_UNAVAILABLE":
+      return { failure: "permanent", reason: "source_unavailable" };
+    case "SESSIONS_UNKNOWN_COLLECTION":
+    case "SESSIONS_NOT_CONFIGURED":
+    case "SESSIONS_BINDING_MISMATCH":
+    case "SESSIONS_INVALID_INPUT":
+    case "SESSIONS_UNSAFE_PATH":
+      return { failure: "permanent", reason: "invalid_configuration" };
+    default:
+      return { failure: "transient", reason: "runtime_error" };
+  }
+}

package/src/sessions/automation-status.ts

@@ -0,0 +1,239 @@
+/**
+ * Reader-facing automation status, shared by every surface. Path-free: it
+ * reports profile and source IDs, collections, triggers, times, outcomes and
+ * recovery actions, never host paths or session content.
+ *
+ * @module src/sessions/automation-status
+ */
+
+import type { SessionAutomationProfile, SessionsConfig } from "./config";
+import type {
+  SessionAutomationStatus,
+  SessionProfileState,
+  SessionProfileStatus,
+} from "./types";
+
+import { parseFindingsCadenceMs } from "../config/types";
+import {
+  AUTOMATION_HEARTBEAT_STALE_MS,
+  type AutomationState,
+  DEFAULT_AUTOMATION_LIMIT,
+  DEFAULT_AUTOMATION_RETRIES,
+  isPending,
+  isProcessAlive,
+  isRunLive,
+  loadAutomationState,
+  MIN_AUTOMATION_CADENCE_MS,
+  ownProfile,
+  type ProfileRunState,
+} from "./automation-state";
+import { inspectClaudeHook } from "./claude-hook";
+
+/** Parse a profile cadence; null when malformed or below the minimum. */
+export function automationCadenceMs(
+  cadence: string | undefined
+): number | null {
+  if (!cadence) return null;
+  const ms = parseFindingsCadenceMs(cadence);
+  return ms !== null && ms >= MIN_AUTOMATION_CADENCE_MS ? ms : null;
+}
+
+/** Enabled with a valid cadence; a hand-edited invalid cadence never runs. */
+export const scheduleRunnable = (profile: SessionAutomationProfile): boolean =>
+  profile.schedule?.enabled === true &&
+  automationCadenceMs(profile.schedule.cadence) !== null;
+
+export const profileLimit = (profile: SessionAutomationProfile): number =>
+  profile.limit ?? DEFAULT_AUTOMATION_LIMIT;
+
+export const profileRetries = (profile: SessionAutomationProfile): number =>
+  profile.retries ?? DEFAULT_AUTOMATION_RETRIES;
+
+export function profileCollections(
+  sessions: SessionsConfig,
+  profile: SessionAutomationProfile
+): string[] {
+  const names = new Set<string>();
+  for (const source of sessions.sources) {
+    if (!profile.sources.includes(source.id)) continue;
+    names.add(source.collection);
+    for (const mapping of source.projects ?? []) names.add(mapping.collection);
+  }
+  return [...names].sort();
+}
+
+export function daemonState(
+  daemon: AutomationState["daemon"],
+  now: Date,
+  alive: (pid: number) => boolean = isProcessAlive
+): SessionAutomationStatus["daemon"]["state"] {
+  if (!daemon || !alive(daemon.pid)) return "not_running";
+  return now.getTime() - Date.parse(daemon.heartbeatAt) <=
+    AUTOMATION_HEARTBEAT_STALE_MS
+    ? "running"
+    : "stale";
+}
+
+const RECOVERY: Record<string, string> = {
+  source_revoked:
+    "A selected source is no longer registered: register it again or update the profile's sources with `gno sessions automation set`.",
+  source_unavailable:
+    "A selected source or the archive destination is missing or unreadable: fix it, then run `gno sessions automation run <profile>`.",
+  invalid_configuration:
+    "The archive config no longer matches this profile (collection, binding or source settings): correct it, then run `gno sessions automation run <profile>`.",
+  import_failed:
+    "Every processed unit failed: check `gno sessions status` and the receipt of `gno sessions automation run <profile>`.",
+};
+
+function recoveryFor(
+  profile: SessionAutomationProfile,
+  run: ProfileRunState | undefined,
+  state: SessionProfileState,
+  installed: boolean | null,
+  daemon: SessionAutomationStatus["daemon"]["state"]
+): string | null {
+  const id = profile.id;
+  if (
+    profile.schedule?.enabled &&
+    automationCadenceMs(profile.schedule.cadence) === null
+  ) {
+    return `The schedule cadence "${profile.schedule.cadence}" is invalid, so the schedule does not run: fix it with \`gno sessions automation set ${id} --source … --cadence 30m\` (<n>s|m|h|d, 1m to 30d).`;
+  }
+  if (profile.hook?.enabled && installed === false) {
+    return `The Claude Code hook entry is missing from its settings file: run \`gno sessions automation enable ${id} --hook claude-code\` to reinstall it.`;
+  }
+  if (profile.hook?.enabled && installed === null) {
+    return `The Claude Code settings file could not be read: fix it, then run \`gno sessions automation enable ${id} --hook claude-code\`.`;
+  }
+  if (state === "failed" || state === "retrying") {
+    const reason = run?.lastRun?.reason ?? "";
+    const known = RECOVERY[reason];
+    if (known) return known.replace("<profile>", id);
+    if (state === "failed") {
+      return `Automatic retries are exhausted: check \`gno sessions status\`, then run \`gno sessions automation run ${id}\`.`;
+    }
+  }
+  // A live run needs no action; suggesting "run now" would only hit busy.
+  if (state === "running") return null;
+  const scheduled = scheduleRunnable(profile);
+  if (
+    daemon !== "running" &&
+    (scheduled || state === "pending" || state === "retrying")
+  ) {
+    return `not running: no daemon. Schedules and admitted hook work run only while \`gno daemon\` runs on this archive's config and index; or run \`gno sessions automation run ${id}\` now.`;
+  }
+  if (state === "partial") {
+    return "The last run left incomplete or deferred units; the next run retries them.";
+  }
+  return null;
+}
+
+function deriveState(
+  profile: SessionAutomationProfile,
+  run: ProfileRunState | undefined,
+  now: Date,
+  alive: (pid: number) => boolean
+): SessionProfileState {
+  const retries = profile.retries ?? DEFAULT_AUTOMATION_RETRIES;
+  if (run && isRunLive(run.running, now, alive)) return "running";
+  if (run && isPending(run)) {
+    if (run.attempts > retries) return "failed";
+    return run.retryAt ? "retrying" : "pending";
+  }
+  const enabled = profile.hook?.enabled || scheduleRunnable(profile);
+  if (!enabled) return "off";
+  if (run?.lastRun?.outcome === "failed") return "failed";
+  if (run?.lastRun?.outcome === "partial") return "partial";
+  return "idle";
+}
+
+/** Automation status for one archive; `warnings` joins the sessions status. */
+export async function readAutomationStatus(input: {
+  sessions: SessionsConfig;
+  configPath: string;
+  indexName: string;
+  now?: Date;
+  alive?: (pid: number) => boolean;
+}): Promise<{ status: SessionAutomationStatus; warnings: string[] }> {
+  const now = input.now ?? new Date();
+  const alive = input.alive ?? isProcessAlive;
+  const profiles = input.sessions.automation ?? [];
+  const { state, corrupt } = await loadAutomationState(
+    input.sessions.archiveRoot
+  );
+  const warnings = corrupt
+    ? [
+        "automation run state was unreadable; pending admissions recorded in it are lost and the next trigger starts fresh",
+      ]
+    : [];
+  const daemon = daemonState(state.daemon, now, alive);
+  const result: SessionProfileStatus[] = [];
+  for (const profile of profiles) {
+    const run = ownProfile(state, profile.id);
+    const installed = profile.hook
+      ? await inspectClaudeHook(profile.hook.settings, {
+          configPath: input.configPath,
+          indexName: input.indexName,
+          profileId: profile.id,
+        })
+      : null;
+    const profileState = deriveState(profile, run, now, alive);
+    const cadenceValid = automationCadenceMs(profile.schedule?.cadence);
+    if (profile.schedule && cadenceValid === null) {
+      warnings.push(
+        `automation profile ${profile.id}: cadence "${profile.schedule.cadence}" is invalid (use <n>s|m|h|d, 1m to 30d); the schedule is reported off and does not run`
+      );
+    }
+    const pending = run && isPending(run) && run.pendingSince;
+    result.push({
+      id: profile.id,
+      sources: [...profile.sources],
+      collections: profileCollections(input.sessions, profile),
+      state: profileState,
+      hook: profile.hook
+        ? {
+            harness: profile.hook.harness,
+            enabled: profile.hook.enabled,
+            installed,
+          }
+        : null,
+      schedule: profile.schedule
+        ? {
+            // Effective state: an invalid cadence (warned above) never runs.
+            enabled: scheduleRunnable(profile),
+            cadence: profile.schedule.cadence,
+            // A due time is only real while a daemon is ticking.
+            nextDueAt:
+              scheduleRunnable(profile) && daemon === "running"
+                ? (run?.nextDueAt ?? null)
+                : null,
+          }
+        : null,
+      limit: profileLimit(profile),
+      retries: profileRetries(profile),
+      pending: pending
+        ? { since: pending, triggers: [...(run?.pendingTriggers ?? [])] }
+        : null,
+      running:
+        run?.running && isRunLive(run.running, now, alive)
+          ? {
+              startedAt: run.running.startedAt,
+              triggers: [...run.running.triggers],
+            }
+          : null,
+      lastTrigger: run?.lastTrigger ?? null,
+      lastRun: run?.lastRun ?? null,
+      lastSuccessAt: run?.lastSuccessAt ?? null,
+      retryAt: run?.retryAt ?? null,
+      recovery: recoveryFor(profile, run, profileState, installed, daemon),
+    });
+  }
+  return {
+    status: {
+      daemon: { state: daemon, heartbeatAt: state.daemon?.heartbeatAt ?? null },
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      profiles: result,
+    },
+    warnings,
+  };
+}