@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/scheduler/clock-install.js

@@ -0,0 +1,284 @@
+import { realpathSync } from "node:fs";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CLOCK_INSTALL_SCHEMA_VERSION, DEFAULT_CLOCK_INTERVAL_SEC, classifyClockHealth, countActiveExecutionLeases, deriveClockUnitName, hashManagedConfig, readClockInstallReceipt, readClockReceipt, writeClockInstallReceipt, } from "./clock.js";
+import { darwinLaunchdAdapter } from "./clock-install/darwin-launchd.js";
+import { linuxSystemdUserAdapter } from "./clock-install/linux-systemd-user.js";
+import { win32SchtasksAdapter } from "./clock-install/win32-schtasks.js";
+import { SchedulerError, SCHEDULER_ERROR_CODES } from "./types.js";
+const ADAPTERS = [
+    darwinLaunchdAdapter,
+    linuxSystemdUserAdapter,
+    win32SchtasksAdapter,
+];
+export function selectClockAdapter(platform = process.platform) {
+    if (platform === "darwin")
+        return darwinLaunchdAdapter;
+    if (platform === "linux")
+        return linuxSystemdUserAdapter;
+    if (platform === "win32")
+        return win32SchtasksAdapter;
+    return null;
+}
+export async function resolveClockEntrypoints(input) {
+    const controlRepoRoot = realpathSafe(path.resolve(input.controlRepoRoot));
+    const nodeBin = realpathSafe(input.nodeBin ?? process.execPath);
+    const agentWorkerEntry = realpathSafe(input.agentWorkerEntry ?? resolveDefaultAgentWorkerEntry());
+    const loopAgentBin = realpathSafe(input.loopAgentBin ?? resolveDefaultLoopAgentBin());
+    return {
+        nodeBin,
+        agentWorkerEntry,
+        loopAgentBin,
+        controlRepoRoot,
+    };
+}
+function resolveDefaultAgentWorkerEntry() {
+    // Prefer package bin when running from published install; fall back to
+    // dist entry relative to this module when developing from source.
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // src/worker/scheduler → package root is ../../..
+    // dist/worker/scheduler → package root is ../../..
+    const packageRoot = path.resolve(here, "../../..");
+    const binEntry = path.join(packageRoot, "bin", "agent-worker.js");
+    const distEntry = path.join(packageRoot, "dist", "worker", "cli.js");
+    // Prefer bin wrapper (stable public entry).
+    try {
+        realpathSync(binEntry);
+        return binEntry;
+    }
+    catch {
+        return distEntry;
+    }
+}
+function resolveDefaultLoopAgentBin() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(here, "../../..");
+    const binEntry = path.join(packageRoot, "bin", "loop-agent.js");
+    try {
+        realpathSync(binEntry);
+        return binEntry;
+    }
+    catch {
+        return "loop-agent";
+    }
+}
+function realpathSafe(candidate) {
+    try {
+        return realpathSync(path.resolve(candidate));
+    }
+    catch {
+        return path.resolve(candidate);
+    }
+}
+export async function installClockTimer(input) {
+    const now = input.now ?? new Date();
+    const adapter = input.adapter ?? selectClockAdapter();
+    if (!adapter) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `No supported clock provider on platform ${process.platform}`);
+    }
+    const available = await adapter.isAvailable();
+    if (!available) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `Clock provider ${adapter.provider} is not available in this environment (unsupported or user manager missing)`);
+    }
+    const intervalSec = normalizeInterval(input.intervalSec);
+    const entrypoints = await resolveClockEntrypoints({
+        controlRepoRoot: input.controlRepoRoot,
+        loopAgentBin: input.loopAgentBin,
+        agentWorkerEntry: input.agentWorkerEntry,
+        nodeBin: input.nodeBin,
+    });
+    // Verify entrypoints exist.
+    for (const [label, p] of [
+        ["nodeBin", entrypoints.nodeBin],
+        ["agentWorkerEntry", entrypoints.agentWorkerEntry],
+    ]) {
+        try {
+            await access(p);
+        }
+        catch {
+            throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `Cannot resolve ${label} for clock install: ${p}`);
+        }
+    }
+    const unitName = adapter.unitName(entrypoints.controlRepoRoot);
+    const managedConfigHash = hashManagedConfig({
+        provider: adapter.provider,
+        unitName,
+        controlRepoRoot: entrypoints.controlRepoRoot,
+        intervalSec,
+        nodeBin: entrypoints.nodeBin,
+        agentWorkerEntry: entrypoints.agentWorkerEntry,
+        loopAgentBin: entrypoints.loopAgentBin,
+    });
+    const existing = await readClockInstallReceipt(entrypoints.controlRepoRoot);
+    if (existing &&
+        existing.managedConfigHash === managedConfigHash &&
+        existing.provider === adapter.provider &&
+        existing.unitName === unitName) {
+        // Still ensure OS unit is present (idempotent re-apply).
+        await adapter.install({
+            receipt: existing,
+            entrypoints,
+        });
+        return {
+            schemaVersion: 1,
+            action: "unchanged",
+            provider: adapter.provider,
+            receipt: existing,
+            message: "Clock timer already installed with matching config.",
+        };
+    }
+    const receipt = {
+        schemaVersion: CLOCK_INSTALL_SCHEMA_VERSION,
+        provider: adapter.provider,
+        unitName,
+        controlRepoRoot: entrypoints.controlRepoRoot,
+        intervalSec,
+        nodeBin: entrypoints.nodeBin,
+        agentWorkerEntry: entrypoints.agentWorkerEntry,
+        loopAgentBin: entrypoints.loopAgentBin,
+        managedConfigHash,
+        installedAt: existing?.installedAt ?? now.toISOString(),
+        updatedAt: now.toISOString(),
+    };
+    await adapter.install({ receipt, entrypoints });
+    await writeClockInstallReceipt(entrypoints.controlRepoRoot, receipt);
+    return {
+        schemaVersion: 1,
+        action: existing ? "updated" : "installed",
+        provider: adapter.provider,
+        receipt,
+        message: existing ? "Clock timer updated." : "Clock timer installed.",
+    };
+}
+export async function uninstallClockTimer(input) {
+    const controlRepoRoot = realpathSafe(path.resolve(input.controlRepoRoot));
+    const receipt = await readClockInstallReceipt(controlRepoRoot);
+    if (!receipt) {
+        return {
+            schemaVersion: 1,
+            action: "already-absent",
+            provider: null,
+            unitName: null,
+            message: "No managed clock install receipt found.",
+        };
+    }
+    const adapter = input.adapter ??
+        ADAPTERS.find((item) => item.provider === receipt.provider) ??
+        selectClockAdapter();
+    if (!adapter || adapter.provider !== receipt.provider) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `Cannot uninstall clock: provider ${receipt.provider} adapter unavailable on this host`);
+    }
+    await adapter.uninstall({ receipt });
+    // Keep install receipt for audit? Plan: uninstall removes managed unit but
+    // "保留 install receipt 历史" — we rewrite a tombstone by deleting active
+    // receipt content is ambiguous. Keep file but mark by rewriting unit gone:
+    // Plan says "uninstall 保留 clock.json、install receipt 历史". So do NOT delete.
+    // Status will see unit missing → drifted/missing via probe.
+    // Better: leave receipt; status uses probe.present=false → drifted with reinstall hint.
+    // For cleaner UX after intentional uninstall, write a soft marker by clearing
+    // is not specified. Follow plan: keep receipt file as audit.
+    return {
+        schemaVersion: 1,
+        action: "uninstalled",
+        provider: receipt.provider,
+        unitName: receipt.unitName,
+        message: "Managed clock timer removed. Install receipt and tick history retained.",
+    };
+}
+export async function statusClockTimer(input) {
+    const now = input.now ?? new Date();
+    const controlRepoRoot = realpathSafe(path.resolve(input.controlRepoRoot));
+    const install = await readClockInstallReceipt(controlRepoRoot);
+    const receipt = await readClockReceipt(controlRepoRoot);
+    const adapter = input.adapter ??
+        (install
+            ? (ADAPTERS.find((item) => item.provider === install.provider) ?? null)
+            : selectClockAdapter());
+    let providerSupported = true;
+    if (adapter) {
+        providerSupported = await adapter.isAvailable();
+    }
+    else {
+        providerSupported = false;
+    }
+    let probe = null;
+    if (adapter && install) {
+        const unitProbe = await adapter.probe({
+            receipt: install,
+            unitName: install.unitName,
+        });
+        probe = unitProbe;
+    }
+    else if (adapter) {
+        const unitName = deriveClockUnitName(controlRepoRoot);
+        const unitProbe = await adapter.probe({ receipt: null, unitName });
+        probe = unitProbe;
+    }
+    // Path drift: compare current entrypoints to install receipt.
+    let pathsMatch = null;
+    if (install) {
+        try {
+            const current = await resolveClockEntrypoints({
+                controlRepoRoot,
+                loopAgentBin: install.loopAgentBin,
+                agentWorkerEntry: install.agentWorkerEntry,
+                nodeBin: install.nodeBin,
+            });
+            // If operator upgraded package, default entry may differ from frozen receipt.
+            const liveDefault = await resolveClockEntrypoints({ controlRepoRoot });
+            pathsMatch =
+                install.nodeBin === current.nodeBin &&
+                    install.agentWorkerEntry === current.agentWorkerEntry &&
+                    // soft: live package entry still equals frozen entry
+                    install.agentWorkerEntry === liveDefault.agentWorkerEntry;
+        }
+        catch {
+            pathsMatch = false;
+        }
+    }
+    const activeLeaseCount = await countActiveExecutionLeases(controlRepoRoot, now);
+    const health = classifyClockHealth({
+        now,
+        receipt,
+        install,
+        unitPresent: probe?.present ?? null,
+        unitLoaded: probe?.loaded ?? null,
+        configMatches: probe?.configMatches ?? null,
+        pathsMatch,
+        providerSupported,
+        activeLeaseCount,
+        defaultMaxConcurrency: 1,
+    });
+    return {
+        schemaVersion: 1,
+        health,
+        install,
+        probe,
+    };
+}
+function normalizeInterval(raw) {
+    const value = raw ?? DEFAULT_CLOCK_INTERVAL_SEC;
+    if (!Number.isFinite(value) || value < 15 || value > 3600) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `intervalSec must be between 15 and 3600, got ${raw}`);
+    }
+    return Math.floor(value);
+}
+export function detectClockSourceFromEnv(explicit) {
+    if (explicit === "manual" ||
+        explicit === "launchd" ||
+        explicit === "systemd-user" ||
+        explicit === "schtasks" ||
+        explicit === "clock-run") {
+        return explicit;
+    }
+    // Heuristics for OS-invoked processes (best-effort).
+    if (process.env.LAUNCH_JOB_LABEL || process.env.XPC_SERVICE_NAME) {
+        return "launchd";
+    }
+    if (process.env.INVOCATION_ID || process.env.JOURNAL_STREAM) {
+        return "systemd-user";
+    }
+    return "manual";
+}
+export { darwinLaunchdAdapter, linuxSystemdUserAdapter, win32SchtasksAdapter };

package/dist/worker/scheduler/clock.js

@@ -0,0 +1,420 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { countActiveLeases, readExecutionLease } from "./lease.js";
+import { getClockInstallReceiptPath, getClockReceiptPath, getLeasesDir, } from "./paths.js";
+import { ensureSchedulerDirs } from "./store.js";
+import { readdir } from "node:fs/promises";
+export const CLOCK_RECEIPT_SCHEMA_VERSION = 1;
+export const CLOCK_INSTALL_SCHEMA_VERSION = 1;
+export const DEFAULT_CLOCK_INTERVAL_SEC = 60;
+export function computeStaleAfterSec(expectedIntervalSec) {
+    const interval = Number.isFinite(expectedIntervalSec) && expectedIntervalSec > 0
+        ? Math.floor(expectedIntervalSec)
+        : DEFAULT_CLOCK_INTERVAL_SEC;
+    return Math.max(180, 3 * interval);
+}
+export function createRunningClockReceipt(input) {
+    const now = input.now ?? new Date();
+    return {
+        schemaVersion: CLOCK_RECEIPT_SCHEMA_VERSION,
+        expectedIntervalSec: input.expectedIntervalSec ?? DEFAULT_CLOCK_INTERVAL_SEC,
+        lastAttemptAt: now.toISOString(),
+        lastCompletedAt: null,
+        lastOutcome: "running",
+        lastError: null,
+        lastSource: input.source ?? "manual",
+        lastDurationMs: null,
+    };
+}
+export function completeClockReceipt(running, input) {
+    const now = input.now ?? new Date();
+    const started = Date.parse(running.lastAttemptAt);
+    const durationMs = Number.isFinite(started)
+        ? Math.max(0, now.getTime() - started)
+        : null;
+    if (input.ok) {
+        return {
+            ...running,
+            lastCompletedAt: now.toISOString(),
+            lastOutcome: "ok",
+            lastError: null,
+            lastDurationMs: durationMs,
+        };
+    }
+    return {
+        ...running,
+        lastCompletedAt: now.toISOString(),
+        lastOutcome: "error",
+        lastError: input.error ?? {
+            code: "clock-tick-error",
+            message: "scheduler tick failed",
+        },
+        lastDurationMs: durationMs,
+    };
+}
+export async function readClockReceipt(controlRepoRoot) {
+    try {
+        const raw = await readFile(getClockReceiptPath(controlRepoRoot), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.schemaVersion !== CLOCK_RECEIPT_SCHEMA_VERSION)
+            return null;
+        return parsed;
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeClockReceipt(controlRepoRoot, receipt) {
+    await ensureSchedulerDirs(controlRepoRoot);
+    await writeJsonAtomic(getClockReceiptPath(controlRepoRoot), receipt, {
+        repoRoot: controlRepoRoot,
+    });
+}
+export async function readClockInstallReceipt(controlRepoRoot) {
+    try {
+        const raw = await readFile(getClockInstallReceiptPath(controlRepoRoot), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.schemaVersion !== CLOCK_INSTALL_SCHEMA_VERSION)
+            return null;
+        return parsed;
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeClockInstallReceipt(controlRepoRoot, receipt) {
+    await ensureSchedulerDirs(controlRepoRoot);
+    await writeJsonAtomic(getClockInstallReceiptPath(controlRepoRoot), receipt, {
+        repoRoot: controlRepoRoot,
+    });
+}
+export function hashManagedConfig(parts) {
+    const payload = [
+        parts.provider,
+        parts.unitName,
+        parts.controlRepoRoot,
+        String(parts.intervalSec),
+        parts.nodeBin,
+        parts.agentWorkerEntry,
+        parts.loopAgentBin,
+    ].join("\n");
+    const digest = createHash("sha256").update(payload).digest("hex");
+    return `sha256:${digest}`;
+}
+export function deriveClockUnitName(controlRepoRoot) {
+    const canonical = canonicalizeControlRoot(controlRepoRoot);
+    const digest = createHash("sha256")
+        .update(canonical)
+        .digest("hex")
+        .slice(0, 8);
+    return `com.tea-agent.loop-agent.night.${digest}`;
+}
+export function canonicalizeControlRoot(controlRepoRoot) {
+    // Keep stable across platforms; realpath is applied by install resolvers.
+    return controlRepoRoot.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
+}
+export function classifyClockHealth(input) {
+    const now = input.now ?? new Date();
+    const receipt = input.receipt ?? null;
+    const install = input.install ?? null;
+    const expectedIntervalSec = receipt?.expectedIntervalSec ??
+        install?.intervalSec ??
+        DEFAULT_CLOCK_INTERVAL_SEC;
+    const staleAfterSec = computeStaleAfterSec(expectedIntervalSec);
+    const activeLeaseCount = input.activeLeaseCount ?? 0;
+    const maxConcurrency = input.defaultMaxConcurrency ?? 1;
+    const providerSupported = input.providerSupported !== false;
+    const base = {
+        schemaVersion: 1,
+        expectedIntervalSec,
+        staleAfterSec,
+        provider: install?.provider ?? null,
+        unitName: install?.unitName ?? null,
+        unitLoaded: input.unitLoaded ?? null,
+        install,
+        receipt,
+        lastSuccessfulTickAt: receipt?.lastOutcome === "ok" ? receipt.lastCompletedAt : null,
+        activeLeaseCount,
+    };
+    if (!providerSupported && !install) {
+        return {
+            ...base,
+            status: "unsupported",
+            message: "No supported user-level OS timer provider on this host (need launchd, systemd --user, or schtasks).",
+            nextAction: "Use agent-worker scheduler tick --repo . manually, or move to a supported platform.",
+        };
+    }
+    if (!install && (input.unitPresent === false || input.unitPresent == null)) {
+        // No install receipt: still allow "observed" health from manual ticks.
+        if (receipt) {
+            const freshness = classifyReceiptFreshness(receipt, now, staleAfterSec);
+            if (freshness === "running") {
+                if (activeLeaseCount >= maxConcurrency) {
+                    return {
+                        ...base,
+                        status: "busy",
+                        message: "Clock tick is running and default concurrency capacity is in use.",
+                        nextAction: null,
+                    };
+                }
+                return {
+                    ...base,
+                    status: "healthy",
+                    message: "Clock tick is currently running (manual or unmanaged).",
+                    nextAction: "Optional: agent-worker scheduler clock install --repo . for automatic ticks.",
+                };
+            }
+            if (freshness === "fresh-ok") {
+                return {
+                    ...base,
+                    status: "healthy",
+                    message: "Recent successful tick observed, but no managed OS timer is installed.",
+                    nextAction: "Install automatic clock: agent-worker scheduler clock install --repo .",
+                };
+            }
+            if (freshness === "fresh-error") {
+                return {
+                    ...base,
+                    status: "degraded",
+                    message: `Recent tick failed: ${receipt.lastError?.message ?? "unknown error"}`,
+                    nextAction: "Inspect last tick error; re-run scheduler tick.",
+                };
+            }
+            return {
+                ...base,
+                status: "stale",
+                message: "Tick receipt is stale and no managed OS timer is installed.",
+                nextAction: "agent-worker scheduler clock install --repo .",
+            };
+        }
+        return {
+            ...base,
+            status: "missing",
+            message: "No managed clock timer installed and no tick receipt yet.",
+            nextAction: "agent-worker scheduler clock install --repo .",
+        };
+    }
+    if (input.configMatches === false ||
+        input.pathsMatch === false ||
+        (install && input.unitPresent === false)) {
+        return {
+            ...base,
+            status: "drifted",
+            message: input.unitPresent === false
+                ? "Install receipt exists but managed OS unit is missing."
+                : "Managed clock unit or package entry has drifted from install receipt.",
+            nextAction: "agent-worker scheduler clock install --repo .",
+        };
+    }
+    if (!receipt) {
+        return {
+            ...base,
+            status: "stale",
+            message: "Managed clock is installed but no tick receipt has been written yet.",
+            nextAction: "Wait for the next timer fire, or run scheduler tick once.",
+        };
+    }
+    const freshness = classifyReceiptFreshness(receipt, now, staleAfterSec);
+    if (freshness === "running") {
+        if (activeLeaseCount >= maxConcurrency) {
+            return {
+                ...base,
+                status: "busy",
+                message: "Clock tick is running and default concurrency capacity is in use.",
+                nextAction: null,
+            };
+        }
+        return {
+            ...base,
+            status: "healthy",
+            message: "Clock tick is currently running.",
+            nextAction: null,
+        };
+    }
+    if (freshness === "fresh-error") {
+        return {
+            ...base,
+            status: "degraded",
+            message: `Last tick failed: ${receipt.lastError?.message ?? "unknown error"}`,
+            nextAction: "Inspect scheduler doctor / last tick error, then re-run tick.",
+        };
+    }
+    if (freshness === "fresh-ok") {
+        return {
+            ...base,
+            status: "healthy",
+            message: "Managed clock is installed and recent ticks succeeded.",
+            nextAction: null,
+        };
+    }
+    return {
+        ...base,
+        status: "stale",
+        message: `No fresh tick within ${staleAfterSec}s (expected every ${expectedIntervalSec}s).`,
+        nextAction: "agent-worker scheduler clock status --repo . → reinstall if needed",
+    };
+}
+function classifyReceiptFreshness(receipt, now, staleAfterSec) {
+    const attemptMs = Date.parse(receipt.lastAttemptAt);
+    const completedMs = receipt.lastCompletedAt
+        ? Date.parse(receipt.lastCompletedAt)
+        : Number.NaN;
+    const freshest = Number.isFinite(completedMs)
+        ? Math.max(attemptMs, completedMs)
+        : attemptMs;
+    const ageSec = Number.isFinite(freshest)
+        ? (now.getTime() - freshest) / 1000
+        : Number.POSITIVE_INFINITY;
+    if (receipt.lastOutcome === "running" && ageSec <= staleAfterSec) {
+        return "running";
+    }
+    if (ageSec > staleAfterSec)
+        return "stale";
+    if (receipt.lastOutcome === "error")
+        return "fresh-error";
+    if (receipt.lastOutcome === "ok")
+        return "fresh-ok";
+    return "stale";
+}
+export async function countActiveExecutionLeases(controlRepoRoot, now = new Date()) {
+    const leases = [];
+    try {
+        const names = await readdir(getLeasesDir(controlRepoRoot));
+        for (const name of names) {
+            if (!name.endsWith(".json"))
+                continue;
+            const scheduleId = name.slice(0, -5);
+            const lease = await readExecutionLease(controlRepoRoot, scheduleId);
+            if (lease)
+                leases.push(lease);
+        }
+    }
+    catch {
+        return 0;
+    }
+    return countActiveLeases(leases, now);
+}
+/**
+ * Wrap any schedulerTick implementation with Clock receipt bookkeeping.
+ * Business semantics stay in schedulerTick; this only records evidence.
+ */
+export async function runRecordedSchedulerTick(input) {
+    const now = input.now ?? new Date();
+    const running = createRunningClockReceipt({
+        now,
+        expectedIntervalSec: input.expectedIntervalSec,
+        source: input.source ?? "manual",
+    });
+    // Prefer install interval when present.
+    if (!input.expectedIntervalSec) {
+        const install = await readClockInstallReceipt(input.controlRepoRoot);
+        if (install?.intervalSec) {
+            running.expectedIntervalSec = install.intervalSec;
+        }
+    }
+    await writeClockReceipt(input.controlRepoRoot, running);
+    try {
+        const result = await input.tick();
+        const completed = completeClockReceipt(running, {
+            now: new Date(),
+            ok: true,
+        });
+        await writeClockReceipt(input.controlRepoRoot, completed);
+        return result;
+    }
+    catch (error) {
+        const code = error &&
+            typeof error === "object" &&
+            "code" in error &&
+            typeof error.code === "string"
+            ? error.code
+            : "clock-tick-error";
+        const message = error instanceof Error ? error.message : String(error);
+        const completed = completeClockReceipt(running, {
+            now: new Date(),
+            ok: false,
+            error: { code, message },
+        });
+        await writeClockReceipt(input.controlRepoRoot, completed);
+        throw error;
+    }
+}
+export function formatClockHealthHuman(health) {
+    const lines = [
+        `Clock: ${health.status}`,
+        health.provider
+            ? `Provider: ${health.provider}${health.unitLoaded === true ? " (loaded)" : health.unitLoaded === false ? " (not loaded)" : ""}`
+            : "Provider: (none)",
+        `Interval: ${health.expectedIntervalSec}s`,
+    ];
+    if (health.unitName)
+        lines.push(`Unit: ${health.unitName}`);
+    if (health.receipt) {
+        const r = health.receipt;
+        const when = r.lastCompletedAt ?? r.lastAttemptAt ?? "(never)";
+        lines.push(`Last tick: ${r.lastOutcome} at ${when}`);
+        if (r.lastError) {
+            lines.push(`Last error: ${r.lastError.code}: ${r.lastError.message}`);
+        }
+        if (r.lastDurationMs != null) {
+            lines.push(`Last duration: ${r.lastDurationMs}ms`);
+        }
+        lines.push(`Source: ${r.lastSource}`);
+    }
+    else {
+        lines.push("Last tick: (none)");
+    }
+    lines.push(health.message);
+    if (health.nextAction) {
+        lines.push(`Next: ${health.nextAction}`);
+    }
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}
+export function clockDoctorSeverity(input) {
+    const { health, hasFutureScheduled, hasDueUnclaimed } = input;
+    if (health.status === "healthy" || health.status === "busy") {
+        return health.status === "busy" ? "info" : null;
+    }
+    if (health.status === "drifted")
+        return "error";
+    if (hasDueUnclaimed) {
+        if (health.status === "missing" ||
+            health.status === "stale" ||
+            health.status === "degraded" ||
+            health.status === "unsupported") {
+            return "error";
+        }
+    }
+    if (hasFutureScheduled) {
+        if (health.status === "missing" ||
+            health.status === "stale" ||
+            health.status === "unsupported") {
+            return "warning";
+        }
+        if (health.status === "degraded")
+            return "warning";
+    }
+    // no activity
+    if (health.status === "missing" ||
+        health.status === "stale" ||
+        health.status === "unsupported") {
+        return "info";
+    }
+    if (health.status === "degraded")
+        return "warning";
+    return "info";
+}