arisa 4.2.8 → 4.3.2

package/src/core/tools/daemon-runtime.js

@@ -7,22 +7,106 @@ import {
   readJson,
   startManagedDaemon,
   stopManagedDaemon,
+  writeDaemonStatus,
   writeJson
 } from "./daemon-processes.js";
+import { loadDaemonPolicy } from "./daemon-policy.js";
 
-export function createDaemonRuntime({ toolName, entryPath, beforeStart = null }) {
-  const paths = daemonPaths(toolName);
+const CONTROL_FIELD = "__daemon";
 
-  async function ensure() {
-    await mkdir(paths.commandsDir, { recursive: true });
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function withTimeout(work, timeoutMs, message) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(work),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          const error = new Error(message);
+          error.code = "DAEMON_OPERATION_TIMEOUT";
+          reject(error);
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
   }
+}
 
-  function jobPaths(id) {
-    return {
-      request: path.join(paths.commandsDir, `${id}.request.json`),
-      processing: path.join(paths.commandsDir, `${id}.processing.json`),
-      result: path.join(paths.commandsDir, `${id}.result.json`)
-    };
+function jobPaths(paths, id) {
+  return {
+    request: path.join(paths.commandsDir, `${id}.request.json`),
+    processing: path.join(paths.commandsDir, `${id}.processing.json`),
+    result: path.join(paths.commandsDir, `${id}.result.json`)
+  };
+}
+
+async function waitForResult(paths, id, { timeoutMs, intervalMs }) {
+  const files = jobPaths(paths, id);
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const result = await readJson(files.result, null);
+    if (result) {
+      await unlink(files.result).catch(() => {});
+      if (!result.ok) {
+        const error = new Error(result.error || `${paths.toolName} daemon job failed`);
+        if (result.code) error.code = result.code;
+        throw error;
+      }
+      return result.output || {};
+    }
+    await sleep(intervalMs);
+  }
+  const error = new Error(`${paths.toolName} daemon job timed out after ${timeoutMs}ms`);
+  error.code = "DAEMON_JOB_TIMEOUT";
+  throw error;
+}
+
+async function enqueue(paths, payload, { control = false, timeoutMs, intervalMs }) {
+  await mkdir(paths.commandsDir, { recursive: true });
+  const id = `${control ? "control" : "job"}-${crypto.randomUUID()}`;
+  await writeJson(jobPaths(paths, id).request, { id, ...payload });
+  return waitForResult(paths, id, { timeoutMs, intervalMs });
+}
+
+export async function submitDaemonControl(record, operation, { timeoutMs } = {}) {
+  const paths = daemonPaths({ toolName: record.toolName, scope: record.scope });
+  const policy = await loadDaemonPolicy();
+  return enqueue(paths, {
+    [CONTROL_FIELD]: { operation }
+  }, {
+    control: true,
+    timeoutMs: timeoutMs ?? policy.healthTimeoutMs,
+    intervalMs: policy.queuePollIntervalMs
+  });
+}
+
+export function isDaemonReady(status, pid, policy, now = Date.now()) {
+  if (status.state !== "ready" || !isProcessAlive(pid)) return false;
+  const heartbeatAt = new Date(status.heartbeatAt || 0).getTime();
+  const healthAt = new Date(status.lastHealthSuccessAt || 0).getTime();
+  if (!heartbeatAt || now - heartbeatAt > policy.heartbeatStaleMs) return false;
+  if (!healthAt || now - healthAt > policy.healthIntervalMs + policy.healthTimeoutMs) return false;
+  return true;
+}
+
+export function createDaemonRuntime({
+  toolName,
+  entryPath,
+  scope = { type: "global" },
+  startupContext = {},
+  beforeStart = null,
+  autoStart = true
+}) {
+  const paths = daemonPaths({ toolName, scope });
+  const registration = { toolName, entryPath, scope: paths.scope, startupContext, autoStart };
+  let statusWrite = Promise.resolve();
+
+  async function ensure() {
+    await mkdir(paths.commandsDir, { recursive: true });
   }
 
   async function getPid() {
@@ -30,60 +114,72 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
   }
 
   async function writeStatus(patch) {
-    const current = await readJson(paths.statusFile, {});
-    await writeJson(paths.statusFile, { ...current, ...patch, updatedAt: new Date().toISOString() });
+    statusWrite = statusWrite.catch(() => {}).then(() => writeDaemonStatus(paths, patch));
+    return statusWrite;
   }
 
   async function start() {
     return startManagedDaemon({
-      toolName,
-      entryPath,
+      ...registration,
       beforeStart
     });
   }
 
   async function stop() {
-    await stopManagedDaemon(toolName);
+    await stopManagedDaemon({ toolName, scope: paths.scope });
   }
 
-  async function waitReady({ timeoutMs = 120000, readyStates = ["ready"] } = {}) {
+  async function waitReady({ timeoutMs } = {}) {
+    const policy = await loadDaemonPolicy();
+    const effectiveTimeoutMs = timeoutMs ?? policy.startupTimeoutMs;
     const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
+    while (Date.now() - startTime < effectiveTimeoutMs) {
       const status = await readJson(paths.statusFile, {});
       const pid = await getPid();
-      if (readyStates.includes(status.state) && isProcessAlive(pid)) return status;
-      if (status.state === "error") throw new Error(status.message || `${toolName} daemon failed`);
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (isDaemonReady(status, pid, policy)) return status;
+      if (status.state === "failed") throw new Error(status.message || `${toolName} daemon failed`);
+      await sleep(policy.queuePollIntervalMs);
     }
-    throw new Error(`${toolName} daemon was not ready after ${timeoutMs}ms`);
+    throw new Error(`${toolName} daemon was not ready after ${effectiveTimeoutMs}ms`);
   }
 
-  async function submit(payload, { timeoutMs = 180000, readyTimeoutMs = 120000 } = {}) {
-    await start();
-    await waitReady({ timeoutMs: readyTimeoutMs });
-    const id = crypto.randomUUID();
-    const files = jobPaths(id);
-    await writeJson(files.request, { id, ...payload });
+  async function ensureReady({ timeoutMs } = {}) {
+    const policy = await loadDaemonPolicy();
+    const status = await readJson(paths.statusFile, {});
+    const pid = await getPid();
+    if (isDaemonReady(status, pid, policy)) return status;
+    await submitDaemonControl(registration, "health", {
+      timeoutMs: timeoutMs ?? policy.healthTimeoutMs
+    });
+    return waitReady({ timeoutMs: timeoutMs ?? policy.startupTimeoutMs });
+  }
 
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const result = await readJson(files.result, null);
-      if (result) {
-        await unlink(files.result).catch(() => {});
-        if (!result.ok) throw new Error(result.error || `${toolName} job failed`);
-        return result.output || {};
-      }
-      await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-    throw new Error(`${toolName} job timed out after ${timeoutMs}ms`);
+  async function submit(payload, {
+    timeoutMs,
+    readyTimeoutMs,
+    requireReady = true
+  } = {}) {
+    const policy = await loadDaemonPolicy();
+    await start();
+    if (requireReady) await ensureReady({ timeoutMs: readyTimeoutMs });
+    return enqueue(paths, payload, {
+      timeoutMs: timeoutMs ?? policy.startupTimeoutMs,
+      intervalMs: policy.queuePollIntervalMs
+    });
   }
 
   async function claimNext() {
     await ensure();
-    const files = (await readdir(paths.commandsDir)).filter((file) => file.endsWith(".request.json"));
+    const files = (await readdir(paths.commandsDir))
+      .filter((file) => file.endsWith(".request.json"))
+      .sort((a, b) => {
+        const aControl = a.startsWith("control-") ? 0 : 1;
+        const bControl = b.startsWith("control-") ? 0 : 1;
+        return aControl - bControl || a.localeCompare(b);
+      });
     for (const file of files) {
       const id = file.replace(/\.request\.json$/, "");
-      const item = jobPaths(id);
+      const item = jobPaths(paths, id);
       try {
         await rename(item.request, item.processing);
         return { id, ...item, payload: await readJson(item.processing, null) };
@@ -98,33 +194,152 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
   }
 
   async function fail(job, error) {
-    await writeJson(job.result, { ok: false, error: error?.message || String(error) });
+    await writeJson(job.result, {
+      ok: false,
+      error: error?.message || String(error),
+      code: error?.code || null
+    });
     await unlink(job.processing).catch(() => {});
   }
 
-  async function workLoop({ processJob, idleTimeoutMs = 0, intervalMs = 250 }) {
+  async function workLoop({
+    processJob,
+    healthCheck,
+    recover = null,
+    beforeExit = null,
+    idleTimeoutMs = 0
+  }) {
+    if (typeof healthCheck !== "function") {
+      throw new Error(`${toolName} daemon must declare healthCheck`);
+    }
+    const policy = await loadDaemonPolicy();
+    const intervalMs = policy.queuePollIntervalMs;
     let lastActivity = Date.now();
-    setInterval(async () => {
+    let processing = false;
+    let exiting = false;
+    let acceptingWork = true;
+
+    await ensure();
+    await writeStatus({
+      state: "starting",
+      pid: process.pid,
+      heartbeatAt: new Date().toISOString(),
+      supportsRecovery: typeof recover === "function",
+      message: "Daemon work loop started; waiting for health check"
+    });
+
+    const heartbeatTimer = setInterval(() => {
+      writeStatus({ heartbeatAt: new Date().toISOString() }).catch(() => {});
+    }, policy.heartbeatIntervalMs);
+
+    const workTimer = setInterval(async () => {
+      if (processing || exiting || !acceptingWork) return;
+      processing = true;
       try {
         const job = await claimNext();
         if (job) {
-          lastActivity = Date.now();
+          const operation = job.payload?.[CONTROL_FIELD]?.operation;
           try {
-            await complete(job, await processJob(job.payload));
+            if (operation === "health") {
+              const checkedAt = new Date().toISOString();
+              await writeStatus({ lastHealthCheckAt: checkedAt });
+              const output = await withTimeout(
+                healthCheck,
+                policy.healthTimeoutMs,
+                `${toolName} health check timed out after ${policy.healthTimeoutMs}ms`
+              );
+              await writeStatus({
+                state: "ready",
+                lastHealthSuccessAt: new Date().toISOString(),
+                consecutiveHealthFailures: 0,
+                restartAttempts: 0,
+                restartRequested: false,
+                nextRestartAt: null,
+                message: output?.message || "Daemon health check passed"
+              });
+              await complete(job, output || { ok: true });
+            } else if (operation === "recover") {
+              const recovered = typeof recover === "function"
+                ? await withTimeout(
+                    recover,
+                    policy.healthTimeoutMs,
+                    `${toolName} recovery timed out after ${policy.healthTimeoutMs}ms`
+                  )
+                : false;
+              await complete(job, { recovered: recovered !== false });
+            } else {
+              lastActivity = Date.now();
+              const output = await processJob(job.payload);
+              await writeStatus({ lastSuccessfulJobAt: new Date().toISOString() });
+              await complete(job, output);
+              lastActivity = Date.now();
+            }
           } catch (error) {
+            if (error?.code === "DAEMON_OPERATION_TIMEOUT") {
+              acceptingWork = false;
+            }
+            const current = await readJson(paths.statusFile, {});
+            await writeStatus({
+              ...(operation === "health"
+                ? {
+                    state: error?.code === "DAEMON_OPERATION_TIMEOUT" ? "unhealthy" : "degraded",
+                    consecutiveHealthFailures: Number(current.consecutiveHealthFailures || 0) + 1
+                  }
+                : {}),
+              lastError: {
+                at: new Date().toISOString(),
+                phase: operation || "job",
+                message: error?.message || String(error)
+              },
+              message: error?.message || String(error)
+            });
             await fail(job, error);
           }
-          lastActivity = Date.now();
         }
         if (idleTimeoutMs > 0 && Date.now() - lastActivity > idleTimeoutMs) {
-          await writeStatus({ state: "stopped", message: "Idle timeout reached" });
+          exiting = true;
+          clearInterval(heartbeatTimer);
+          clearInterval(workTimer);
+          if (beforeExit) await beforeExit();
+          await writeStatus({
+            state: "stopped",
+            restartRequested: false,
+            nextRestartAt: null,
+            message: "Idle timeout reached"
+          });
           process.exit(0);
         }
       } catch (error) {
-        await writeStatus({ state: "error", message: error?.message || String(error) });
+        await writeStatus({
+          state: "degraded",
+          lastError: {
+            at: new Date().toISOString(),
+            phase: "work-loop",
+            message: error?.message || String(error)
+          },
+          message: error?.message || String(error)
+        });
+      } finally {
+        processing = false;
       }
     }, intervalMs);
+
+    submitDaemonControl(registration, "health", {
+      timeoutMs: policy.healthTimeoutMs
+    }).catch(() => {});
   }
 
-  return { paths, ensure, getPid, writeStatus, start, stop, waitReady, submit, workLoop };
+  return {
+    paths,
+    registration,
+    ensure,
+    getPid,
+    writeStatus,
+    start,
+    stop,
+    waitReady,
+    ensureReady,
+    submit,
+    workLoop
+  };
 }

package/src/runtime/bootstrap.js

@@ -5,8 +5,10 @@ import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
 import { Bot } from "grammy";
 import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
-import { createPiRuntime, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
+import { createPiRuntime, formatPiModelOption, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
+import { applyConfigDefaults, telegramConfigDefaults } from "../core/config/config-defaults.js";
 import { buildDeviceCodeTelegramMessage } from "../transport/telegram/device-code-message.js";
+import { buildPagedInlineKeyboard } from "../transport/telegram/paged-inline-keyboard.js";
 import { configFile, ensureArisaHome } from "./paths.js";
 
 const ARISA_BANNER = [
@@ -28,7 +30,7 @@ async function exists(file) {
 }
 
 function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [], chatMeta = {}, provider, model, piApiKey }) {
-  return {
+  return applyConfigDefaults({
     telegram: {
       token: telegramApiKey,
       maxChatIds: telegramMaxChatIds,
@@ -41,7 +43,7 @@ function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [
       apiKey: piApiKey
     },
     createdAt: new Date().toISOString()
-  };
+  });
 }
 
 function sortBootstrapProviders(providers) {
@@ -99,30 +101,6 @@ function parseYesNo(value, fallback = true) {
   return null;
 }
 
-function buildPagedInlineKeyboard(action, items, { page = 0, pageSize = 8 } = {}) {
-  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
-  const currentPage = Math.max(0, Math.min(pageCount - 1, page));
-  const startIndex = currentPage * pageSize;
-  const rows = items.slice(startIndex, startIndex + pageSize).map((item, index) => ([{
-    text: item.text,
-    callback_data: `${action}:${startIndex + index}`
-  }]));
-
-  if (pageCount > 1) {
-    const navigation = [];
-    if (currentPage > 0) {
-      navigation.push({ text: "Previous", callback_data: `${action}-page:${currentPage - 1}` });
-    }
-    navigation.push({ text: `${currentPage + 1}/${pageCount}`, callback_data: "noop:page" });
-    if (currentPage < pageCount - 1) {
-      navigation.push({ text: "Next", callback_data: `${action}-page:${currentPage + 1}` });
-    }
-    rows.push(navigation);
-  }
-
-  return { inline_keyboard: rows };
-}
-
 function getIncomingChatMeta(ctx) {
   return {
     languageCode: ctx.from?.language_code || "",
@@ -137,11 +115,6 @@ function formatProviderOption(item) {
   return `${item.provider} (${item.modelCount} models, ${authLabel})`;
 }
 
-function formatModelOption(model) {
-  const capabilities = [model.reasoning ? "reasoning" : null, model.input?.includes("image") ? "image" : null].filter(Boolean).join(", ");
-  return capabilities ? `${model.id} [${capabilities}]` : model.id;
-}
-
 function selectPiLoginOption(options = []) {
   return options.find((option) => /device/i.test(`${option.id} ${option.label}`))
     || options.find((option) => /browser|oauth|web/i.test(`${option.id} ${option.label}`))
@@ -214,7 +187,7 @@ async function collectCliBootstrapChoices({ telegramApiKey, rl, ask }) {
   const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, runtime));
   console.log(`\nAvailable models for ${selectedProvider.provider}:`);
   models.forEach((model, index) => {
-    console.log(`${index + 1}. ${formatModelOption(model)}`);
+    console.log(`${index + 1}. ${formatPiModelOption(model)}`);
   });
 
   const selectedModel = selectByIndex(models, await ask("Select Pi model by number", "1"));
@@ -325,14 +298,20 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
   const askProvider = async (ctx = null, page = 0) => {
     state = "provider";
     await showSetupPrompt(ctx, "Select the Pi provider Arisa should use:", {
-      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), { page })
+      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), {
+        page,
+        pageSize: telegramConfigDefaults.modelPickerPageSize
+      })
     });
   };
 
   const askModel = async (ctx = null, page = 0) => {
     state = "model";
     const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, createPiRuntime()));
-    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatModelOption(model) })), { page });
+    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatPiModelOption(model) })), {
+      page,
+      pageSize: telegramConfigDefaults.modelPickerPageSize
+    });
     keyboard.inline_keyboard.push([{ text: "Back to providers", callback_data: "back:provider" }]);
     await showSetupPrompt(ctx, `Select the model for ${selectedProvider.provider}:`, {
       reply_markup: keyboard

package/src/runtime/create-app.js

@@ -98,7 +98,7 @@ export async function createApp({ logger, runtimeOverrides } = {}) {
   }
 
   const artifactStore = new ArtifactStore();
-  const toolProcessSupervisor = createToolProcessSupervisor({ logger });
+  const toolProcessSupervisor = createToolProcessSupervisor({ logger, policy: config.daemons });
   const toolRegistry = new ToolRegistry({ logger });
   const taskStore = new TaskStore();
   await toolRegistry.load();

package/src/runtime/paths.js

@@ -43,8 +43,43 @@ export function getChatToolStateDir(chatId, toolName) {
   return path.join(getChatDir(chatId), "state", "tools", toolName);
 }
 
-export function getChatPiSessionsDir(chatId) {
-  return path.join(getChatDir(chatId), "state", "pi-sessions");
+export function normalizeDaemonScope(scope = { type: "global" }) {
+  if (!scope || scope === "global" || scope.type === "global") {
+    return { type: "global" };
+  }
+  if (scope === "chat") {
+    throw new Error("chat daemon scope requires chatId");
+  }
+  if (scope.type !== "chat") {
+    throw new Error(`Unsupported daemon scope: ${scope.type || scope}`);
+  }
+  const chatId = String(scope.chatId ?? "").trim();
+  if (!/^-?\d+$/.test(chatId)) {
+    throw new Error(`Invalid chat daemon scope: ${chatId || "missing chatId"}`);
+  }
+  return { type: "chat", chatId };
+}
+
+export function getDaemonInstanceId(scope = { type: "global" }) {
+  const normalized = normalizeDaemonScope(scope);
+  return normalized.type === "global" ? "global" : `chat:${normalized.chatId}`;
+}
+
+export function getDaemonInstanceDir(toolName, scope = { type: "global" }) {
+  const normalized = normalizeDaemonScope(scope);
+  return normalized.type === "global"
+    ? getToolStateDir(toolName)
+    : path.join(getChatToolStateDir(normalized.chatId, toolName), "daemon");
+}
+
+export function getChatPiSessionsDir(chatId, sessionRevision = 0) {
+  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
+    throw new Error(`Invalid Pi session revision: ${sessionRevision}`);
+  }
+  const sessionsDir = path.join(getChatDir(chatId), "state", "pi-sessions");
+  return sessionRevision === 0
+    ? sessionsDir
+    : path.join(sessionsDir, String(sessionRevision));
 }
 
 export function getToolDir(toolName) {

package/src/runtime/tool-process-supervisor.js

@@ -1,11 +1,7 @@
-import { access, rm } from "node:fs/promises";
-import {
-  daemonPaths,
-  isProcessAlive,
-  listRegisteredDaemons,
-  readJson,
-  startManagedDaemon
-} from "../core/tools/daemon-processes.js";
+import { access } from "node:fs/promises";
+import { superviseDaemon } from "../core/tools/daemon-health.js";
+import { listRegisteredDaemons } from "../core/tools/daemon-processes.js";
+import { loadDaemonPolicy } from "../core/tools/daemon-policy.js";
 import { ensureArisaHome } from "./paths.js";
 
 async function fileExists(file) {
@@ -17,47 +13,63 @@ async function fileExists(file) {
   }
 }
 
-export function createToolProcessSupervisor({ logger } = {}) {
+export function createToolProcessSupervisor({ logger, policy } = {}) {
   let running = false;
+  let timer = null;
+  let reconciliation = null;
+  let daemonPolicy = policy;
+
+  function reportLoopError(error) {
+    logger?.error?.("tools", `daemon supervisor loop failed: ${error?.message || error}`);
+  }
 
   async function reconcileDaemons() {
     await ensureArisaHome();
     for (const record of await listRegisteredDaemons()) {
-      if (!record.autoStart) continue;
       if (!(await fileExists(record.entryPath))) {
         logger?.log("tools", `skipping daemon ${record.toolName}: missing entry ${record.entryPath}`);
         continue;
       }
-
-      const paths = daemonPaths(record.toolName);
-      const { pid } = await readJson(paths.pidFile, {});
-      if (isProcessAlive(pid)) {
-        logger?.log("tools", `adopted managed daemon ${record.toolName} (pid ${pid})`);
-        continue;
-      }
-      if (pid) {
-        await rm(paths.pidFile, { force: true });
-        logger?.log("tools", `removed stale daemon pid for ${record.toolName} (${pid})`);
+      try {
+        const outcome = await superviseDaemon(record, daemonPolicy);
+        if (outcome !== "healthy") {
+          logger?.log("tools", `${record.toolName} (${record.instanceId || "global"}): ${outcome}`);
+        }
+      } catch (error) {
+        logger?.error?.("tools", `daemon supervision failed for ${record.toolName}: ${error?.message || error}`);
       }
+    }
+  }
 
-      logger?.log("tools", `starting managed daemon ${record.toolName}`);
-      await startManagedDaemon({
-        toolName: record.toolName,
-        entryPath: record.entryPath
-      });
+  async function runLoop() {
+    if (!running || reconciliation) return;
+    reconciliation = reconcileDaemons();
+    try {
+      await reconciliation;
+    } finally {
+      reconciliation = null;
+      if (running) {
+        timer = setTimeout(() => {
+          runLoop().catch(reportLoopError);
+        }, daemonPolicy.supervisorIntervalMs);
+      }
     }
   }
 
   return {
     async start() {
       if (running) return;
+      daemonPolicy ||= await loadDaemonPolicy();
       running = true;
-      await reconcileDaemons();
+      runLoop().catch(reportLoopError);
     },
 
     async stop() {
       if (!running) return;
       running = false;
+      clearTimeout(timer);
+      timer = null;
+      await reconciliation?.catch(() => {});
     }
   };
 }