cloving 1.4.0 → 1.5.0

package/dist/src/cli/watch-header-view.d.ts

@@ -19,4 +19,5 @@ export declare function Queue(props: {
 export declare function Brand(): Shown;
 export declare function HeaderStatus(props: HeaderProps): Shown;
 export declare function HeaderActions(props: HeaderProps): Shown;
+export declare function Version(props: HeaderProps): Shown;
 export declare function Header(props: HeaderProps): Shown;

package/dist/src/cli/watch-header-view.js

@@ -16,7 +16,8 @@ export function queueLanes(model) {
     const queue = model.queue;
     if (queue === undefined)
         return null;
-    return `Queue: ${String(queue["busy"])} of ${String(queue["lanes"])} lanes busy`;
+    const state = typeof queue["state"] === "string" ? `${queue["state"]}, ` : "";
+    return `Queue: ${state}${String(queue["busy"])} of ${String(queue["lanes"])} lanes busy`;
 }
 export function skippedText(value) {
     const ticket = record(value) ?? {};
@@ -93,12 +94,19 @@ export function HeaderActions(props) {
         }),
     });
 }
+export function Version(props) {
+    const version = props.model?.serviceVersion;
+    if (version === undefined)
+        return null;
+    return element("div", { class: "version", children: `cloving ${version}` });
+}
 export function Header(props) {
     return element("header", {
         children: [
             component(Brand, {}),
             component(HeaderStatus, props),
             component(HeaderActions, props),
+            component(Version, props),
         ],
     });
 }

package/dist/src/cli/watch-model.d.ts

@@ -29,6 +29,7 @@ export interface WatchInputs {
     readonly client: string;
     readonly updatedAt: string;
     readonly service: string;
+    readonly serviceVersion?: string;
     readonly runs: readonly unknown[];
     readonly completionCandidates?: readonly unknown[];
     readonly decisions: readonly unknown[];

package/dist/src/cli/watch-model.js

@@ -269,6 +269,9 @@ export function watchModel(inputs) {
         startWorkflowId: startWorkflowOf(workflows),
         updatedAt: inputs.updatedAt,
         service: inputs.service,
+        ...(inputs.serviceVersion === undefined
+            ? {}
+            : { serviceVersion: inputs.serviceVersion }),
         runs: runs.toSorted((first, second) => began(first) < began(second) ? 1 : -1),
     };
 }

package/dist/src/cli/watch-page.js

@@ -15,7 +15,7 @@ import { boardWorkflow, watchHash, watchLocation, watchTitle, } from "./watch-na
 import { clockTime, completedDetail, counted, elapsed, groupActivity, pageTitle, phaseTime, runName, runTone, selectedRun, toneOf, turnTime, waitingDetail, } from "./watch-render.js";
 import { Command, Decision, Events, Group, Item, Turn, Work, } from "./watch-turn.js";
 import { Banner, BannerDetail, BoardPage, Page, Phases, PullRequest, Review, RefusedWorkflows, Run, } from "./watch-view.js";
-import { Brand, clove, Header, HeaderActions, HeaderStatus, Queue, queueLanes, skippedText, } from "./watch-header-view.js";
+import { Brand, clove, Header, HeaderActions, HeaderStatus, Queue, queueLanes, skippedText, Version, } from "./watch-header-view.js";
 const functions = [
     scheduleStatusLine,
     scheduledText,
@@ -32,6 +32,7 @@ const functions = [
     Brand,
     HeaderStatus,
     HeaderActions,
+    Version,
     cardReply,
     cardSubmitKey,
     cardKey,
@@ -284,6 +285,7 @@ button:hover { background: var(--code-head); }
 .events { margin-top: 18px; padding-bottom: 10px; }
 .events > summary { color: var(--code-fg); }
 .down { font-weight: 600; }
+.version { position: fixed; left: 12px; bottom: 8px; font: 12px/1.4 var(--code-font); color: var(--muted); pointer-events: none; }
 @media (max-width: 700px) { body { padding-inline: 12px; } }
 `;
 export function pageDocument(actionToken = null) {

package/dist/src/cli/watch-reads.d.ts

@@ -20,6 +20,7 @@ export interface WatchRead {
     readonly schedules?: ShownSchedules;
     readonly queue?: Fields;
     readonly service: string;
+    readonly serviceVersion?: string;
     readonly workflows: readonly string[];
     readonly workflowRefusals: readonly WorkflowRefusal[];
     readonly workflowStages?: WorkflowStages;

package/dist/src/cli/watch-reads.js

@@ -1,6 +1,6 @@
 import { establishedIssue } from "./watch-pr-identity.js";
 import { shownSchedules } from "./schedule-render.js";
-import { isWorkflowStages, } from "../workflow-declaration.js";
+import { workflowStagesOf, } from "../workflow-declaration.js";
 import { record } from "../protocol.js";
 import { send } from "./client.js";
 import { activeRun, recentRun } from "./watch-board.js";
@@ -192,8 +192,8 @@ function stoppedIssues(runs, context) {
             : [];
     }));
 }
-function stageMetadata(value) {
-    return Object.fromEntries(Object.entries(record(value) ?? {}).flatMap(([workflowId, stages]) => isWorkflowStages(stages) ? [[workflowId, stages]] : []));
+function versionOf(value) {
+    return typeof value === "string" ? { serviceVersion: value } : {};
 }
 async function service(reader, now) {
     const status = await asked(reader, {
@@ -226,7 +226,8 @@ async function service(reader, now) {
             ? {}
             : { queue: record(status["queue"]) ?? {} }),
         workflows: list(status["workflows"]).filter((value) => typeof value === "string"),
-        workflowStages: stageMetadata(status["workflowStages"]),
+        workflowStages: workflowStagesOf(status["workflowStages"]),
+        ...versionOf(status["serviceVersion"]),
         workflowRefusals: workflowRefusals(status["workflowRefusals"]),
         summaries,
         runs,
@@ -252,7 +253,7 @@ async function singleRun(reader, runId) {
     return {
         ...unavailable,
         service: "up",
-        workflowStages: stageMetadata(metadata["workflowStages"]),
+        workflowStages: workflowStagesOf(metadata["workflowStages"]),
         runs: [value],
         decisions: await decisionsOf(reader),
     };

package/dist/src/cli/watch-render.d.ts

@@ -153,6 +153,7 @@ export interface WatchRun {
     readonly mergeCommit: string | null;
 }
 export interface WatchModel {
+    readonly serviceVersion?: string;
     readonly schedules?: ShownSchedules;
     readonly queue?: Fields;
     readonly workflowRefusals?: readonly WorkflowRefusal[];

package/dist/src/cli/watch-server.js

@@ -1,4 +1,5 @@
 import { watchAction, watchActions, watchHost, } from "./watch-actions.js";
+import { watchApiChange, watchApiReply } from "./watch-api.js";
 import { observedBoard } from "./watch-pr-board.js";
 import { isPhoneAction, phoneAction, phoneRead } from "./watch-phone.js";
 import { watchPrObserver } from "./watch-pr-settings.js";
@@ -30,6 +31,7 @@ const fontFiles = new Map([
     new URL(`assets/watch-fonts/${name}`, import.meta.resolve("#package")),
 ]));
 const libraryFile = fileURLToPath(import.meta.resolve("preact"));
+const pageChange = () => "data: change\n\n";
 function parsed(text) {
     try {
         const value = JSON.parse(text);
@@ -139,6 +141,14 @@ async function answered(watch, request) {
     if (font !== null)
         return font;
     const url = new URL(String(request.url), "http://localhost");
+    const api = await watchApiReply({
+        method: request.method ?? "",
+        url,
+        model: () => snapshot(watch, null),
+        run: (runId) => snapshot(watch, runId),
+    });
+    if (api !== null)
+        return api;
     if (request.method === "GET")
         return readReply(watch, url);
     if (request.method !== "POST" || watch.actions === null)
@@ -187,13 +197,14 @@ function replied(response, reply) {
     response.writeHead(reply.status, {
         "content-type": reply.type,
         "cache-control": reply.cache ?? "no-store",
+        ...(reply.allow === undefined ? {} : { allow: reply.allow }),
     });
     response.end(reply.body);
 }
 function subscribed(stream, exchange) {
-    const { request, response } = exchange;
+    const { request, response, message } = exchange;
     const changed = () => {
-        response.write("data: change\n\n");
+        response.write(message());
     };
     response.writeHead(200, {
         "content-type": "text/event-stream",
@@ -223,11 +234,14 @@ export async function watchServer(settings) {
         if (watchHost(request) &&
             request.method === "GET" &&
             request.url === "/events") {
-            subscribed(stream, { request, response });
+            subscribed(stream, { request, response, message: pageChange });
             return;
         }
         answered(watch, request).then((reply) => {
-            replied(response, reply);
+            if (reply === "stream")
+                subscribed(stream, { request, response, message: watchApiChange });
+            else
+                replied(response, reply);
         }, () => {
             replied(response, { ...notFound, status: 500, body: "failed" });
         });

package/dist/src/cli.js

@@ -4,7 +4,7 @@ import { terminateHarness } from "./cli/harness-processes.js";
 import { settingsEnvironment } from "./cli/project-settings.js";
 import { constants as systemConstants } from "node:os";
 import { addAbortListener } from "node:events";
-import { execFile, execFileSync, spawn } from "node:child_process";
+import { execFile, execFileSync, spawn, } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { delimiter, dirname, extname, join, resolve } from "node:path";
@@ -60,43 +60,50 @@ const watchCommand = async (request) => {
         listener[Symbol.dispose]();
     }
 };
+function spawnedHarness(request) {
+    try {
+        return spawn(request.executable, request.arguments, {
+            cwd: request.directory,
+            env: request.environment,
+            stdio: "inherit",
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
 function startHarness(request) {
     return new Promise((settle) => {
-        try {
-            const child = spawn(request.executable, request.arguments, {
-                cwd: request.directory,
-                env: request.environment,
-                stdio: "inherit",
-            });
-            const interrupt = () => undefined;
-            const terminate = () => {
-                terminateHarness(child.pid, {
-                    snapshot: () => execFileSync("/bin/ps", ["-axo", "pid=,ppid="], {
-                        encoding: "utf8",
-                        timeout: 1000,
-                    }),
-                    kill: (identifier, signal) => process.kill(identifier, signal),
-                });
-            };
-            const cleanup = () => {
-                process.off("SIGINT", interrupt);
-                process.off("SIGTERM", terminate);
-            };
-            process.on("SIGINT", interrupt);
-            process.on("SIGTERM", terminate);
-            child.once("error", () => {
-                cleanup();
-                settle(null);
+        const interrupt = () => undefined;
+        const terminate = () => {
+            terminateHarness(child?.pid, {
+                snapshot: () => execFileSync("/bin/ps", ["-axo", "pid=,ppid="], {
+                    encoding: "utf8",
+                    timeout: 1000,
+                }),
+                kill: (identifier, signal) => process.kill(identifier, signal),
             });
-            child.once("close", (status, signal) => {
-                cleanup();
-                settle(status ??
-                    (signal === null ? 1 : 128 + systemConstants.signals[signal]));
-            });
-        }
-        catch {
+        };
+        const cleanup = () => {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", terminate);
+        };
+        process.on("SIGINT", interrupt);
+        process.on("SIGTERM", terminate);
+        const child = spawnedHarness(request);
+        if (child === undefined) {
+            cleanup();
             settle(null);
+            return;
         }
+        child.once("error", () => {
+            cleanup();
+            settle(null);
+        });
+        child.once("close", (status, signal) => {
+            cleanup();
+            settle(status ?? (signal === null ? 1 : 128 + systemConstants.signals[signal]));
+        });
     });
 }
 function startArguments(input) {
@@ -122,16 +129,6 @@ function startArguments(input) {
 }
 function toolProcess(input) {
     const program = join(import.meta.dirname, "..", "tools", `${input.tool}${extname(import.meta.filename)}`);
-    const child = spawn(process.execPath, [program, ...input.argumentsList], {
-        detached: input.tool === "red-green-command",
-        stdio: input.tool === "red-green-command"
-            ? ["inherit", "inherit", "inherit", "ipc"]
-            : "inherit",
-        env: {
-            ...process.env,
-            PATH: [dirname(process.execPath), process.env["PATH"]].join(delimiter),
-        },
-    });
     let stopping = false;
     const interrupt = () => {
         stopping = true;
@@ -143,6 +140,16 @@ function toolProcess(input) {
     };
     process.on("SIGINT", interrupt);
     process.on("SIGTERM", terminate);
+    const child = spawn(process.execPath, [program, ...input.argumentsList], {
+        detached: input.tool === "red-green-command",
+        stdio: input.tool === "red-green-command"
+            ? ["inherit", "inherit", "inherit", "ipc"]
+            : "inherit",
+        env: {
+            ...process.env,
+            PATH: [dirname(process.execPath), process.env["PATH"]].join(delimiter),
+        },
+    });
     return new Promise((settle) => {
         child.once("close", (status) => {
             setImmediate(() => {

package/dist/src/configuration-display.js

@@ -13,6 +13,8 @@ const defaults = {
     "watch.port": 3663,
     "watch.actions": "on",
     "github.command": ["gh"],
+    "retention.days": 30,
+    "retention.action": "archive",
 };
 function effectiveValue(setting) {
     const { field, value } = setting;

package/dist/src/configuration-schema.d.ts

@@ -51,6 +51,11 @@ export interface Configuration {
     readonly workflows?: {
         readonly folder?: string;
     };
+    readonly retention?: {
+        readonly days?: number | null;
+        readonly action?: "archive" | "delete";
+        readonly archiveFolder?: string | null;
+    };
 }
 export declare function configuration(value: unknown, scope: "project" | "private"): Configuration;
 export declare function settingScope(field: string): "project" | "private";

package/dist/src/daemon/claude-recovery.js

@@ -78,9 +78,19 @@ export function recordedTree(started) {
 }
 export async function resumePlan(settings, request) {
     const { folder, started, intent, signal } = request;
-    const resume = await readResume(folder, started);
     const tree = recordedTree(started);
-    if (resume === undefined || tree === undefined)
+    if (tree === undefined)
+        return "claude-turn-interrupted";
+    const locked = await resumeWorktree({
+        ...settings,
+        directory: tree.path,
+        folder,
+        signal,
+    });
+    if (locked !== null)
+        return locked.reason;
+    const resume = await readResume(folder, started);
+    if (resume === undefined)
         return "claude-turn-interrupted";
     const profile = await selectedProfile(settings, intent);
     if (typeof profile === "string")
@@ -93,13 +103,7 @@ export async function resumePlan(settings, request) {
             sessionId: resume.sessionId,
         }) === undefined)
         return "claude-turn-interrupted";
-    const locked = await resumeWorktree({
-        ...settings,
-        directory: tree.path,
-        folder,
-        signal,
-    });
-    return locked === null ? { resume, tree, profile, harness } : locked.reason;
+    return { resume, tree, profile, harness };
 }
 function priorEnd(record) {
     const field = (name) => recordedField(record, name);

package/dist/src/daemon/claude-worker.d.ts

@@ -1,10 +1,10 @@
 import { type HarnessSettings } from "../harness-defaults.ts";
-import { type TurnProfiles } from "../turn-profile.ts";
 import type { Delivery, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
 import { type RetrySettings } from "./retrying-turn.ts";
 import { type WorkerReport } from "./operation-journal.ts";
-export interface ClaudeWorkerSettings extends RetrySettings, HarnessSettings {
-    readonly profiles?: TurnProfiles;
+import type { TurnSettings } from "../project-settings.ts";
+export interface ClaudeWorkerSettings extends Pick<RetrySettings, "retryDelay">, HarnessSettings {
+    readonly turnSettings: () => TurnSettings;
     readonly workflowId?: (runId: string) => Promise<string | undefined>;
     readonly repository: string;
     readonly worktrees: string;

package/dist/src/daemon/claude-worker.js

@@ -1,13 +1,13 @@
 import { turnHarness } from "../harness-defaults.js";
 import { attachmentEnvironment } from "./attachments.js";
-import { profileCommand, } from "../turn-profile.js";
+import { profileCommand } from "../turn-profile.js";
 import {} from "./claude-turn.js";
 import { turnOutcome } from "./turn-report.js";
 import { startRetriedTurn } from "./retrying-turn.js";
 import { located, readRecord as read, replied, reportOf, writeRecord as written, } from "./operation-journal.js";
 import { firstTurn, treeFailure, workTree, } from "./work-tree.js";
 import { recordedHarness, interruptedReply, processAlive, uncertainProcess, resumePlan, recordedField, resumableHarness, recoverTurn, turnIntent, } from "./claude-recovery.js";
-import { selectedProfile } from "./worker-profile.js";
+import { checkedProfiles, selectedProfile } from "./worker-profile.js";
 export const claudeLimits = {
     summaryCharacters: 16_000,
     resultBytes: 48_000,
@@ -51,12 +51,8 @@ async function resumed(parts, request) {
         return interruptedReply(request, "claude-turn-interrupted");
     if (aborted())
         return failure("claude-start-aborted");
-    const plan = await resumePlan(parts.settings, {
-        folder,
-        started,
-        intent,
-        signal,
-    });
+    const current = parts.settings.turnSettings();
+    const plan = await resumePlan({ ...parts.settings, ...current }, { folder, started, intent, signal });
     if (aborted())
         return failure("claude-start-aborted");
     if (typeof plan === "string")
@@ -73,6 +69,7 @@ async function resumed(parts, request) {
         ...plan,
         signal,
         prompt,
+        turnSettings: current,
     });
     return { kind: "accepted", receipt: key, worker };
 }
@@ -105,6 +102,7 @@ async function begun(parts, start) {
         prompt,
     }, {
         ...parts.settings,
+        ...start.turnSettings,
         ...(start.resume === undefined ? {} : { resume: start.resume }),
         stopping: stopping.controller,
         metadata: {
@@ -143,7 +141,8 @@ async function delivered(parts, call) {
     const known = await reconciled(parts, call);
     if (known.kind !== "absent")
         return known;
-    const profile = await selectedProfile(settings, intent);
+    const current = settings.turnSettings();
+    const profile = await selectedProfile({ ...settings, ...current }, intent);
     if (typeof profile === "string")
         return failure(profile);
     const prompt = await settings.document(intent.payload);
@@ -171,6 +170,7 @@ async function delivered(parts, call) {
         profile,
         harness: turnHarness(settings, profile),
         signal,
+        turnSettings: current,
     });
     return { receipt: place.key, worker };
 }
@@ -225,8 +225,7 @@ export function claudeWorker(settings) {
     if (settings.command.length === 0)
         throw new Error("invalid-claude-command");
     turnHarness(settings);
-    for (const profile of Object.values(settings.profiles ?? {}))
-        turnHarness(settings, profile);
+    checkedProfiles(settings, settings.turnSettings().profiles);
     const parts = {
         settings,
         active: new Map(),

package/dist/src/daemon/daemon-adapters.d.ts

@@ -12,12 +12,15 @@ import type { LocalCommands } from "../command-settings.ts";
 import type { DeclaredWorkflow } from "../workflow-declaration.ts";
 import type { WorkflowRefusal } from "../workflow-refusals.ts";
 import type { HarnessSettings } from "../harness-defaults.ts";
+import type { RetentionSettings } from "../record-retention.ts";
+import { type SettingDigests, type TurnSettingsSource } from "./settings-reload.ts";
 export interface DaemonSettings extends HarnessSettings {
     readonly commands?: LocalCommands;
     readonly commandSeconds?: number;
     readonly fallbackModels?: readonly string[];
     readonly tokenPrices?: TokenPrices;
     readonly profiles?: TurnProfiles;
+    readonly settingDigests?: SettingDigests;
     readonly directory: string;
     readonly runtimeDirectory: string;
     readonly repository: string;
@@ -28,6 +31,7 @@ export interface DaemonSettings extends HarnessSettings {
     readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
     readonly handler: WorkflowHandler;
     readonly loadBundle?: WorkflowBundleLoader;
+    readonly reloadCommand?: readonly string[];
     readonly command: readonly string[];
     readonly ticketCommand?: readonly string[];
     readonly nextCommand?: readonly string[];
@@ -35,6 +39,8 @@ export interface DaemonSettings extends HarnessSettings {
     readonly notifyMilliseconds?: number;
     readonly queueMilliseconds?: number;
     readonly scheduleClock?: () => number;
+    readonly retention?: RetentionSettings;
+    readonly retentionClock?: () => number;
     readonly schedules?: unknown;
     readonly queueLanes?: number;
     readonly queueDailySpendLimitUsd?: number;
@@ -47,6 +53,7 @@ export interface DaemonSettings extends HarnessSettings {
 }
 export interface Adapters {
     readonly worker: ClaudeWorker;
+    readonly turnSettings: TurnSettingsSource;
     readonly github: GithubWorker;
     readonly runs: StartDelivery;
     readonly handoff: EffectDelivery;

package/dist/src/daemon/daemon-adapters.js

@@ -7,6 +7,7 @@ import { githubWorker } from "./github-worker.js";
 import { commandWorker } from "./command-worker.js";
 import { handoffWorker } from "./handoff-worker.js";
 import { resumableHarness } from "./claude-recovery.js";
+import { turnSettingsSource, } from "./settings-reload.js";
 function githubOf(settings, given) {
     const { directory, repository, checkCommand } = settings;
     return githubWorker({
@@ -42,11 +43,14 @@ export function adapters(settings, options) {
     const { given, generations } = options;
     const document = async (digest) => (await given).document(digest);
     const report = async (effect) => (await given).reportEffect(effect);
-    const worker = claudeWorker({
+    const turnSettings = turnSettingsSource({
+        profiles: settings.profiles ?? {},
         fallbackModels: settings.fallbackModels ?? [],
         tokenPrices: settings.tokenPrices ?? {},
+    });
+    const worker = claudeWorker({
         ...workerHarness(settings),
-        profiles: settings.profiles ?? {},
+        turnSettings: turnSettings.current,
         workflowId: async (runId) => (await given).workflow.id(runId),
         repository,
         document,
@@ -72,7 +76,7 @@ export function adapters(settings, options) {
         document,
         report,
     });
-    return { worker, github, runs, handoff, commands };
+    return { worker, github, runs, handoff, commands, turnSettings };
 }
 function handoffOf(settings, given) {
     return handoffWorker({

package/dist/src/daemon/daemon-loops.d.ts

@@ -1,7 +1,9 @@
 import type { scheduleConnection } from "./schedule-control.ts";
+import type { queueConnection } from "./queue-control.ts";
 import { workflowSchedules } from "./workflow-schedules.ts";
 interface LoopSettings extends ParametersOfSchedules {
     readonly scheduleConnection?: ReturnType<typeof scheduleConnection>;
+    readonly queueConnection?: ReturnType<typeof queueConnection>;
     readonly notifyCommand?: readonly string[];
     readonly notifyMilliseconds?: number;
     readonly queueMilliseconds?: number;

package/dist/src/daemon/daemon-loops.js

@@ -1,6 +1,22 @@
 import { workflowSchedules } from "./workflow-schedules.js";
 import { issueQueue } from "./issue-queue.js";
 import { notifyRuns } from "./notify.js";
+async function startedQueue(settings) {
+    if (settings.queueMilliseconds === undefined ||
+        settings.queueWorkflowId === undefined)
+        return undefined;
+    const queue = issueQueue({
+        directory: settings.directory,
+        runtimeDirectory: settings.runtimeDirectory,
+        intervalMilliseconds: settings.queueMilliseconds,
+        lanes: settings.queueLanes ?? 1,
+        resetQueue: settings.resetQueue ?? false,
+        workflowId: settings.queueWorkflowId,
+    });
+    settings.queueConnection?.connect(queue.port);
+    await queue.ready;
+    return queue;
+}
 export async function daemonLoops(settings) {
     const schedules = await workflowSchedules(settings);
     settings.scheduleConnection?.connect(schedules.request);
@@ -15,17 +31,7 @@ export async function daemonLoops(settings) {
                     ? {}
                     : { intervalMilliseconds: settings.notifyMilliseconds }),
             });
-        const queue = settings.queueMilliseconds === undefined ||
-            settings.queueWorkflowId === undefined
-            ? undefined
-            : issueQueue({
-                directory: settings.directory,
-                runtimeDirectory: settings.runtimeDirectory,
-                intervalMilliseconds: settings.queueMilliseconds,
-                lanes: settings.queueLanes ?? 1,
-                resetQueue: settings.resetQueue ?? false,
-                workflowId: settings.queueWorkflowId,
-            });
+        const queue = await startedQueue(settings);
         return {
             stop: async () => {
                 await schedules.stop();