@cydm/happy-elves 0.1.0-beta.84 → 0.1.0-beta.86

package/apps/cli/dist/commands/daemon.js

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, wantsJson, writeDaemonConfig } from "./lib/index.js";
+import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, ensureDaemonRunning, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForNewConfig, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, waitForMachineProjection, wantsJson, writeDaemonConfig } from "./lib/index.js";
 export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "pair") {
         const relayUrl = requireRelayUrl(flags);
@@ -25,11 +25,87 @@ export async function handleDaemon({ domain, action, flags }) {
             machineToken: claimed.machineToken,
             accountSecret,
         };
+        const localBefore = await localDaemonStatus();
         const daemonConfigPath = await writeDaemonConfig(daemonConfig);
-        ok("daemon.pair", {
+        let daemonStart = { skipped: true, reason: "not requested" };
+        let projection = { checked: false, reason: "not checked" };
+        let startError;
+        if (flags["no-start"] === true) {
+            daemonStart = { skipped: true, reason: "--no-start" };
+            projection = { checked: false, reason: "--no-start" };
+        }
+        else {
+            try {
+                const startResult = localBefore.running
+                    ? await restartDaemonForNewConfig(relayUrl)
+                    : await ensureDaemonRunning(relayUrl);
+                daemonStart = {
+                    skipped: false,
+                    restarted: localBefore.running,
+                    local: startResult.local,
+                    started: startResult.started,
+                    ...(startResult.startedPid ? { startedPid: startResult.startedPid } : {}),
+                    ...("stopped" in startResult ? { stop: startResult.stopped } : {}),
+                };
+                try {
+                    const controllerConfig = await readConfig({ relay: relayUrl });
+                    const machine = await waitForMachineProjection(new ControllerClient(controllerConfig), claimed.machineId, 10_000);
+                    projection = {
+                        checked: true,
+                        online: machine?.online === true,
+                        machineId: claimed.machineId,
+                        ...(machine?.lastSeen ? { lastSeen: machine.lastSeen } : {}),
+                    };
+                }
+                catch (error) {
+                    projection = {
+                        checked: false,
+                        reason: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            catch (error) {
+                const code = error instanceof CliError ? error.code : "DAEMON_START_FAILED";
+                startError = { code, message: error instanceof Error ? error.message : String(error) };
+                process.exitCode = 1;
+                daemonStart = { skipped: true, reason: "start failed" };
+                projection = { checked: false, reason: "daemon did not start" };
+            }
+        }
+        const data = {
             path: daemonConfigPath,
             config: redactedDaemonConfig(daemonConfig),
-        });
+            daemon: daemonStart,
+            projection,
+            ...(startError ? { error: startError } : {}),
+        };
+        const commandOk = !startError && !(projection.checked && !projection.online);
+        if (!commandOk)
+            process.exitCode = 1;
+        if (!wantsJson(flags)) {
+            console.log(`Paired ${machineName} with ${relayUrl}`);
+            console.log(`Config: ${daemonConfigPath}`);
+            if (startError) {
+                console.error(`Daemon start failed: ${startError.message}`);
+            }
+            else if (daemonStart.skipped) {
+                console.log(`Daemon start: skipped (${daemonStart.reason})`);
+            }
+            else {
+                console.log(`${daemonStart.restarted ? "Restarted" : "Started"} daemon${daemonStart.startedPid ? ` pid ${daemonStart.startedPid}` : ""}`);
+            }
+            if (projection.checked) {
+                console.log(`Relay projection: ${projection.online ? "online" : "offline"} (${projection.machineId})`);
+                if (!projection.online) {
+                    console.log("If this stays offline, run happy-elves daemon logs --tail 100 and happy-elves daemon status --local.");
+                }
+            }
+            else {
+                console.log(`Relay projection: not checked (${projection.reason})`);
+            }
+            return true;
+        }
+        ok("daemon.pair", data, { machineId: claimed.machineId }, commandOk);
         return true;
     }
     if (domain === "daemon" && action === "doctor") {
@@ -118,6 +194,14 @@ export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "start") {
         const status = await localDaemonStatus();
         if (status.running) {
+            const existingConfig = await readDaemonConfig();
+            if (typeof flags.relay === "string")
+                existingConfig.relayUrl = requireRelayUrl(flags);
+            const restarted = await ensureDaemonRunning(existingConfig.relayUrl);
+            if (restarted.started) {
+                ok("daemon.start", { ...restarted.local, started: true, startedPid: restarted.startedPid, restartedForChangedConfig: true });
+                return true;
+            }
             ok("daemon.start", { ...status, started: false });
             return true;
         }

package/apps/cli/dist/commands/lib/args.js

@@ -62,6 +62,7 @@ const valueFlags = new Set([
     "session",
     "secret",
     "since",
+    "source",
     "stop-on",
     "tail",
     "tags",
@@ -85,6 +86,7 @@ const booleanFlags = new Set([
     "all",
     "allow-any-sender",
     "app-secret-stdin",
+    "confirm-risk",
     "detach",
     "disable-reaction",
     "help",
@@ -95,6 +97,7 @@ const booleanFlags = new Set([
     "keep-source",
     "local",
     "no-open",
+    "no-start",
     "no-wait",
     "repair-head",
     "summary",

package/apps/cli/dist/commands/lib/bootstrap-daemon.js

@@ -1,11 +1,11 @@
 import { CliError } from "../../errors.js";
 import { startDaemonTimeoutMs } from "./paths.js";
 import { readDaemonConfig } from "./config.js";
-import { daemonBinaryUpdatedAfterStart, localDaemonStatus, spawnDaemonStart, stopLocalDaemon } from "./local-daemon.js";
+import { daemonBinaryUpdatedAfterStart, daemonConfigUpdatedAfterStart, localDaemonStatus, spawnDaemonStart, stopLocalDaemon } from "./local-daemon.js";
 export async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
     const current = await localDaemonStatus();
     if (current.running) {
-        if (await daemonBinaryUpdatedAfterStart(current)) {
+        if ((await daemonBinaryUpdatedAfterStart(current)) || (await daemonConfigUpdatedAfterStart(current))) {
             return await restartDaemonForNewConfig(relayUrl, cwd);
         }
         return { local: current, started: false };

package/apps/cli/dist/commands/lib/gateway-store.d.ts

@@ -36,7 +36,3 @@ export type GatewayStore = {
 };
 export declare function readGatewayStore(): Promise<GatewayStore>;
 export declare function updateGatewayStore(update: (store: GatewayStore) => GatewayStore | Promise<GatewayStore>): Promise<GatewayStore>;
-export declare function redactedGatewayChannel(channel: GatewayChannelConfig): Omit<GatewayChannelConfig, "localToken" | "localSecret"> & {
-    hasLocalToken: boolean;
-    hasLocalSecret: boolean;
-};

package/apps/cli/dist/commands/lib/gateway-store.js

@@ -30,12 +30,4 @@ export async function updateGatewayStore(update) {
     await writeGatewayStore(next);
     return next;
 }
-export function redactedGatewayChannel(channel) {
-    const { localToken, localSecret, ...rest } = channel;
-    return {
-        ...rest,
-        hasLocalToken: Boolean(localToken),
-        hasLocalSecret: Boolean(localSecret),
-    };
-}
 //# sourceMappingURL=gateway-store.js.map

package/apps/cli/dist/commands/lib/index.d.ts

@@ -17,7 +17,6 @@ export * from "./loop-store.js";
 export * from "./paths.js";
 export * from "./relay-db-audit.js";
 export * from "./relay-http.js";
-export * from "./schedule-store.js";
 export * from "./scope.js";
 export * from "./session-output.js";
 export * from "./session-view.js";

package/apps/cli/dist/commands/lib/index.js

@@ -17,7 +17,6 @@ export * from "./loop-store.js";
 export * from "./paths.js";
 export * from "./relay-db-audit.js";
 export * from "./relay-http.js";
-export * from "./schedule-store.js";
 export * from "./scope.js";
 export * from "./session-output.js";
 export * from "./session-view.js";

package/apps/cli/dist/commands/lib/local-daemon.d.ts

@@ -4,6 +4,7 @@ export declare function localDaemonStatus(): Promise<{
     running: boolean;
 }>;
 export declare function daemonBinaryUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;
+export declare function daemonConfigUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;
 export declare function spawnDaemonStart(args: string[], cwd?: string): number;
 export declare function stopLocalDaemon(timeoutMs?: number): Promise<{
     pidPath: string;

package/apps/cli/dist/commands/lib/local-daemon.js

@@ -102,6 +102,20 @@ export async function daemonBinaryUpdatedAfterStart(status) {
         return false;
     }
 }
+export async function daemonConfigUpdatedAfterStart(status) {
+    if (!status.running || !status.pid)
+        return false;
+    const startedAt = readProcessStartedAtMs(status.pid);
+    if (!startedAt)
+        return false;
+    try {
+        const config = await fs.stat(path.join(configDir, "daemon.json"));
+        return config.mtimeMs > startedAt + 1000;
+    }
+    catch {
+        return false;
+    }
+}
 export function spawnDaemonStart(args, cwd = process.cwd()) {
     const child = spawn(process.execPath, [daemonCliPath(), "start", ...args], {
         cwd,

package/apps/cli/dist/commands/lib/paths.d.ts

@@ -8,4 +8,3 @@ export declare const daemonPidPath: string;
 export declare const loopStorePath: string;
 export declare const loopStoreLockPath: string;
 export declare const gatewayStorePath: string;
-export declare const scheduleStorePath: string;

package/apps/cli/dist/commands/lib/paths.js

@@ -12,5 +12,4 @@ export const daemonPidPath = path.join(configDir, "daemon.pid");
 export const loopStorePath = path.join(configDir, "loops.json");
 export const loopStoreLockPath = path.join(configDir, "loops.json.lock");
 export const gatewayStorePath = path.join(configDir, "gateway.json");
-export const scheduleStorePath = path.join(configDir, "schedules.json");
 //# sourceMappingURL=paths.js.map

package/apps/cli/dist/commands/lib/session-output.d.ts

@@ -1,4 +1,5 @@
 import type { ControllerClient, DecodedSessionEvent } from "../../../../../packages/client/dist/index.js";
+import type { MemoryCitation, MemoryLayer } from "../../../../../packages/shared/dist/index.js";
 export declare function compactText(value: string, max?: number): string;
 export declare function lastAssistantOutput(events: DecodedSessionEvent[]): string;
 export declare function compareSessionEventLogicalOrder(left: DecodedSessionEvent, right: DecodedSessionEvent): number;
@@ -14,6 +15,14 @@ export type StoredTurnOutput = {
     startedAt?: number;
     completedAt: number;
     eventCount: number;
+    usedMemories?: UsedMemoryReference[];
+};
+type UsedMemoryReference = {
+    id: string;
+    layer: MemoryLayer;
+    path: string;
+    title?: string;
+    citation: MemoryCitation;
 };
 export type TurnSummary = {
     turnId: string;
@@ -30,6 +39,7 @@ export type TurnSummary = {
     firstEventId: number;
     lastEventId: number;
     eventCount: number;
+    usedMemories?: UsedMemoryReference[];
 };
 export type StructuredCommandOutput = {
     state: string;
@@ -43,6 +53,7 @@ export type StructuredCommandOutput = {
         latest?: string;
         metadata?: string;
     };
+    usedMemories?: UsedMemoryReference[];
 };
 export declare function writeTurnOutput(sessionId: string, turnId: string, events: DecodedSessionEvent[]): Promise<StoredTurnOutput>;
 export declare function readStoredTurnOutput(sessionId: string, turnId?: string): Promise<StoredTurnOutput | undefined>;
@@ -59,3 +70,4 @@ export declare function conciseEvents(events: DecodedSessionEvent[]): Array<{
 }>;
 export declare function printConciseEvents(events: DecodedSessionEvent[]): void;
 export declare function readPromptTextFile(filePath: string): Promise<string>;
+export {};

package/apps/cli/dist/commands/lib/session-output.js

@@ -48,6 +48,45 @@ function assistantOutputForTurn(events, turnId) {
         .join("")
         .trim();
 }
+function usedMemoriesForTurn(events, turnId) {
+    return dedupeUsedMemories(events
+        .filter((event) => event.turnId === turnId && event.decoded?.type === "memory_used")
+        .flatMap((event) => event.decoded?.type === "memory_used" ? event.decoded.memories : []));
+}
+function dedupeUsedMemories(memories) {
+    const seen = new Set();
+    const result = [];
+    for (const memory of memories) {
+        const key = [
+            memory.id,
+            memory.path,
+            memory.citation.path,
+            memory.citation.startLine,
+            memory.citation.endLine,
+        ].join(":");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(memory);
+    }
+    return result;
+}
+function isUsedMemoryArray(value) {
+    return Array.isArray(value) && value.every((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return false;
+        const record = item;
+        const citation = record.citation;
+        return typeof record.id === "string" &&
+            (record.layer === "user" || record.layer === "curated" || record.layer === "daily") &&
+            typeof record.path === "string" &&
+            (!record.title || typeof record.title === "string") &&
+            Boolean(citation) &&
+            typeof citation?.path === "string" &&
+            typeof citation?.startLine === "number" &&
+            typeof citation?.endLine === "number";
+    });
+}
 function sessionEventLogicalOrder(event) {
     const messageKey = event.messageId ?? "";
     if (event.occurredAt !== undefined) {
@@ -99,6 +138,7 @@ export async function writeTurnOutput(sessionId, turnId, events) {
     await fs.mkdir(paths.dir, { recursive: true });
     const output = assistantOutputForTurn(events, turnId) || terminalTextForDone(events, turnId);
     const turnEvents = events.filter((event) => event.turnId === turnId);
+    const usedMemories = usedMemoriesForTurn(events, turnId);
     const doneEvent = [...turnEvents].reverse().find((event) => event.decoded?.type === "done");
     const metadata = {
         sessionId,
@@ -107,6 +147,7 @@ export async function writeTurnOutput(sessionId, turnId, events) {
         startedAt: turnEvents[0]?.createdAt,
         completedAt: doneEvent?.createdAt ?? Date.now(),
         eventCount: turnEvents.length,
+        ...(usedMemories.length > 0 ? { usedMemories } : {}),
         outputPath: paths.turn,
         latestPath: paths.latest,
     };
@@ -158,6 +199,7 @@ export async function readStoredTurnOutput(sessionId, turnId) {
         startedAt: typeof metadata.startedAt === "number" ? metadata.startedAt : undefined,
         completedAt: typeof metadata.completedAt === "number" ? metadata.completedAt : 0,
         eventCount: typeof metadata.eventCount === "number" ? metadata.eventCount : 0,
+        ...(isUsedMemoryArray(metadata.usedMemories) ? { usedMemories: metadata.usedMemories } : {}),
     };
 }
 export function summarizeTurns(events) {
@@ -177,6 +219,7 @@ export function summarizeTurns(events) {
             firstEventId: event.id,
             lastEventId: event.id,
             eventCount: 0,
+            usedMemories: [],
             order,
         };
         current.startedAt ??= event.createdAt;
@@ -200,6 +243,9 @@ export function summarizeTurns(events) {
             current.checkpointId = payload.currentHead;
             current.runtimeTurnId = payload.lastTurnId;
         }
+        else if (payload?.type === "memory_used") {
+            current.usedMemories = dedupeUsedMemories([...current.usedMemories, ...payload.memories]);
+        }
         turns.set(event.turnId, current);
     }
     return [...turns.values()]
@@ -218,6 +264,7 @@ export function summarizeTurns(events) {
         firstEventId: turn.firstEventId,
         lastEventId: turn.lastEventId,
         eventCount: turn.eventCount,
+        ...(turn.usedMemories.length > 0 ? { usedMemories: turn.usedMemories } : {}),
         order: turn.order,
     }))
         .sort((left, right) => right.order.time - left.order.time ||
@@ -236,6 +283,7 @@ export function structuredOutputForTurn(sessionId, turn) {
         status: turn.status,
         finalOutput,
         ...(turn.status === "failed" && finalOutput ? { error: finalOutput } : {}),
+        ...(turn.usedMemories?.length ? { usedMemories: turn.usedMemories } : {}),
     };
 }
 export function structuredOutputForStoredTurn(output) {
@@ -246,6 +294,7 @@ export function structuredOutputForStoredTurn(output) {
         status: output.status,
         finalOutput: output.output || undefined,
         ...(output.status === "failed" && output.output ? { error: output.output } : {}),
+        ...(output.usedMemories?.length ? { usedMemories: output.usedMemories } : {}),
         artifactPaths: {
             output: output.outputPath,
             latest: output.latestPath,

package/apps/cli/dist/commands/lib/usage.js

@@ -74,7 +74,7 @@ Session management:
   happy-elves turn list <sessionId> [--limit 10] [--verbose] [--json]
   happy-elves turn status <sessionId> <turnId> [--verbose] [--json]
   happy-elves turn result <sessionId> [<turnId>] [--verbose] [--json]
-  happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--inactivity-timeout 1000s] [--permission-mode approve-reads|approve-all|deny-all] [--json]
+  happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--inactivity-timeout 1000s] [--permission-mode approve-reads|approve-all|deny-all] [--memory off|readonly|readwrite] [--memory-project <key>] [--memory-top-n 3] [--json]
   happy-elves turn wait <sessionId> <turnId> [--timeout 1000s] --json
   happy-elves turn cancel <sessionId> <turnId> [--reason <reason>] --json
   happy-elves turn rewind <sessionId> <turn-or-checkpoint-id> --json
@@ -124,6 +124,7 @@ gateway serve is kept for fake/local debugging only; lark-cli is not a product d
   happy-elves memory save [--machine <machineId>] [--project <projectKey>] [--layer user|curated|daily] (--text <text> | --text-file <path>) [--title <title>] [--date YYYY-MM-DD] --json
   happy-elves memory read <USER.md|MEMORY.md|memory/YYYY-MM-DD.md> [--project <projectKey>] --json
   happy-elves memory search --query <text> [--project <projectKey>] [--limit 5] --json
+  happy-elves memory promote --source <path:start-end[@contentHash]> --layer user|curated [--project <projectKey>] [--title <title>] --json
   happy-elves memory reindex [--project <projectKey>] --json
   happy-elves memory sync [--project <projectKey>] --json
 
@@ -156,7 +157,7 @@ missed and are never auto-caught-up.
   happy-elves loop delete <loopId> --json
 `,
     daemon: `Usage:
-  happy-elves daemon pair --relay <url> --code <code> --secret <account-secret> [--name <machine-name>] --json
+  happy-elves daemon pair --relay <url> --code <code> --secret <account-secret> [--name <machine-name>] [--no-start] --json
   happy-elves daemon start [--relay <url>] [--json]
   happy-elves daemon stop [--json]
   happy-elves daemon restart [--relay <url>] [--json]

package/apps/cli/dist/commands/memory.js

@@ -72,7 +72,9 @@ export async function handleMemory({ domain, action, positional, flags }) {
                 console.log("No matching memory.");
             else
                 for (const item of results) {
-                    console.log(`${item.path}:${item.citation.startLine}-${item.citation.endLine}  ${item.snippet}`);
+                    const hash = item.citation.contentHash ? ` hash=${item.citation.contentHash.slice(0, 10)}` : "";
+                    const stale = item.citation.stale ? " stale" : "";
+                    console.log(`${item.path}:${item.citation.startLine}-${item.citation.endLine}${hash}${stale}  ${item.snippet}`);
                     if (wantsVerbose(flags))
                         console.log(`  score=${item.score}`);
                 }
@@ -81,6 +83,27 @@ export async function handleMemory({ domain, action, positional, flags }) {
         ok("memory.search", result);
         return true;
     }
+    if (action === "promote") {
+        const machineId = await resolveMemoryMachineId(client, flags);
+        const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
+        const source = typeof flags.source === "string" ? parseMemoryCitation(flags.source) : undefined;
+        if (!source)
+            throw new CliError("Missing --source <path:start-end>", "MISSING_ARGUMENT");
+        const targetLayer = parsePromotionLayer(flags.layer) ?? "curated";
+        const result = await client.memory({
+            machineId,
+            action: "promote",
+            projectKey,
+            promote: {
+                projectKey,
+                source,
+                targetLayer,
+                ...(typeof flags.title === "string" ? { title: flags.title } : {}),
+            },
+        });
+        ok("memory.promote", result);
+        return true;
+    }
     if (action === "reindex" || action === "sync") {
         const machineId = await resolveMemoryMachineId(client, flags);
         const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
@@ -128,4 +151,28 @@ function parseMemoryMode(value) {
         return value;
     throw new CliError("Invalid --mode; expected off|readonly|readwrite", "INVALID_ARGUMENT");
 }
+function parsePromotionLayer(value) {
+    const layer = parseMemoryLayer(value);
+    if (!layer)
+        return undefined;
+    if (layer === "user" || layer === "curated")
+        return layer;
+    throw new CliError("Invalid --layer for promotion; expected user|curated", "INVALID_ARGUMENT");
+}
+function parseMemoryCitation(value) {
+    const match = value.match(/^(.+):(\d+)-(\d+)(?:@([A-Za-z0-9._-]+))?$/);
+    if (!match)
+        throw new CliError("Invalid --source; expected path:start-end or path:start-end@contentHash", "INVALID_ARGUMENT");
+    const startLine = Number(match[2]);
+    const endLine = Number(match[3]);
+    if (!Number.isInteger(startLine) || !Number.isInteger(endLine) || startLine < 1 || endLine < startLine) {
+        throw new CliError("Invalid --source line range", "INVALID_ARGUMENT");
+    }
+    return {
+        path: match[1],
+        startLine,
+        endLine,
+        ...(match[4] ? { contentHash: match[4] } : {}),
+    };
+}
 //# sourceMappingURL=memory.js.map

package/apps/cli/dist/commands/schedule.js

@@ -48,8 +48,10 @@ export async function handleSchedule({ domain, action, positional, flags }) {
             if (schedules.length === 0)
                 console.log("No schedules.");
             else
-                for (const schedule of schedules)
-                    console.log(`${schedule.id}  ${schedule.status}  ${cadenceLabel(schedule)}  next:${schedule.nextRunAt ?? "manual"}  source:${schedule.sourceSessionId ?? schedule.sessionId ?? "pending"}`);
+                for (const schedule of schedules) {
+                    const preview = schedule.previewRunAt?.length ? `  preview:${schedule.previewRunAt.join(",")}` : "";
+                    console.log(`${schedule.id}  ${schedule.status}  ${cadenceLabel(schedule)}  next:${schedule.nextRunAt ?? "manual"}  source:${schedule.sourceSessionId ?? schedule.sessionId ?? "pending"}${preview}`);
+                }
             return true;
         }
         ok("schedule.list", { machineId, schedules: schedules.map(compactSchedule) });
@@ -216,6 +218,7 @@ function compactSchedule(schedule) {
         stopOn: schedule.stopOn,
         dueAt: schedule.dueAt,
         nextRunAt: schedule.nextRunAt,
+        previewRunAt: schedule.previewRunAt,
         status: schedule.status,
         runCount: schedule.runCount ?? schedule.runs.length,
         lastRun: schedule.lastRun ?? schedule.runs[0],