arisa 4.3.4 → 5.0.2

package/src/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
-import { createApp } from "./runtime/create-app.js";
+import { applyRuntimeOverrides, createApp } from "./runtime/create-app.js";
+import { loadConfig } from "./core/config/config-store.js";
 import { createLogger } from "./runtime/logger.js";
-import { getServiceStatus, registerServiceProcess, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
+import { getServiceStatus, handoffServiceRestart, registerServiceProcess, restartService, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
+import { readPackageVersion, showServiceLogs } from "./runtime/log-viewer.js";
 import { arisaPackageDir } from "./runtime/paths.js";
 
 process.env.ARISA_PACKAGE_DIR = arisaPackageDir;
@@ -69,17 +71,18 @@ function toNestedOverrides(nestedFlags) {
 
 function toServiceRunnerArgs(nestedFlags) {
   const args = [];
-  const serviceSafePiFlags = [
+  const serviceSafeAgentFlags = [
     "pi.provider",
     "pi.model",
     "pi.workspaceDir",
     "pi.tools",
     "pi.excludeTools",
     "pi.shellPath",
-    "pi.shellTimeoutMs"
+    "pi.shellTimeoutMs",
+    "pi.speed"
   ];
 
-  for (const flag of serviceSafePiFlags) {
+  for (const flag of serviceSafeAgentFlags) {
     if (nestedFlags[flag]) {
       args.push(`--${flag}`, nestedFlags[flag]);
     }
@@ -111,12 +114,21 @@ process.once("SIGINT", () => {
 });
 
 async function startRuntimeApp() {
-  const app = await createApp({ logger, runtimeOverrides });
+  const app = await createApp({
+    logger,
+    runtimeOverrides,
+    requestRestart: () => handoffServiceRestart({
+      verbose,
+      cliArgs: toServiceRunnerArgs(cli.nestedFlags)
+    })
+  });
   activeApp = app;
   await app.start();
 }
 
 async function startBackgroundService() {
+  const persistedConfig = await loadConfig();
+  applyRuntimeOverrides(persistedConfig, runtimeOverrides);
   const result = await startService({ verbose, cliArgs: toServiceRunnerArgs(cli.nestedFlags) });
   if (!result.ok) {
     console.log(`Arisa is already running in background (pid ${result.pid}).`);
@@ -127,6 +139,31 @@ async function startBackgroundService() {
   return result;
 }
 
+async function restartBackgroundService() {
+  const persistedConfig = await loadConfig();
+  applyRuntimeOverrides(persistedConfig, runtimeOverrides);
+  const result = await restartService({
+    verbose,
+    cliArgs: toServiceRunnerArgs(cli.nestedFlags),
+    shutdownTimeoutMs: persistedConfig.service.shutdownTimeoutMs,
+    shutdownPollIntervalMs: persistedConfig.service.shutdownPollIntervalMs
+  });
+  if (!result.ok) {
+    if (result.reason === "already-running") {
+      console.log(`Arisa could not be restarted because another instance is running (pid ${result.pid}).`);
+      return result;
+    }
+    throw new Error(`Arisa could not be restarted: ${result.reason || "unknown service error"}`);
+  }
+  if (result.wasRunning) {
+    console.log(`Arisa restarted in background (pid ${result.pid}; previous pid ${result.previousPid}).`);
+  } else {
+    console.log(`Arisa started in background (pid ${result.pid}); it was not running.`);
+  }
+  console.log(`Log file: ${result.logFile}`);
+  return result;
+}
+
 async function runForeground() {
   const hasRuntimePiOverrides = Boolean(
     runtimeOverrides?.pi?.model
@@ -197,6 +234,16 @@ async function main() {
     return;
   }
 
+  if (command === "restart") {
+    const bootstrapResult = await bootstrapIfNeeded({ force: forceBootstrap });
+    if (bootstrapResult.configCreated && bootstrapResult.viaTelegram && !bootstrapResult.startInBackground) {
+      console.log("Config saved. Arisa was not started in background.");
+      return;
+    }
+    await restartBackgroundService();
+    return;
+  }
+
   if (command === "status") {
     const status = await getServiceStatus();
     if (!status.running) {
@@ -207,6 +254,14 @@ async function main() {
     return;
   }
 
+  if (command === "log") {
+    await showServiceLogs({
+      version: await readPackageVersion(),
+      follow: !cli.flags["no-follow"]
+    });
+    return;
+  }
+
   if (command === "flush") {
     const status = await getServiceStatus();
     if (status.running) {

package/src/runtime/arisa-capabilities.js

@@ -41,10 +41,35 @@ function normalizeLimit(limit) {
   return Math.min(value, 100);
 }
 
-export function createArisaCapabilities({ artifactStore, taskStore, agentManager } = {}) {
+export function createArisaCapabilities({ artifactStore, taskStore, toolRegistry, agentManager } = {}) {
   async function dispatch({ method, toolName, chatId = null, params = {} } = {}) {
     const scopedToolName = requireToolName(toolName);
 
+    if (method === "tools.list") {
+      await toolRegistry.load();
+      return toolRegistry.listWithRuntime(chatId);
+    }
+
+    if (method === "tools.help") {
+      await toolRegistry.load();
+      return toolRegistry.help(requireString(params.name, "name"));
+    }
+
+    if (method === "tools.skills") {
+      await toolRegistry.load();
+      return toolRegistry.resolveSkills(requireString(params.name, "name"));
+    }
+
+    if (method === "tools.setConfig") {
+      await toolRegistry.load();
+      return toolRegistry.setConfig(
+        requireString(params.name, "name"),
+        requireString(params.field, "field"),
+        requireString(params.value, "value"),
+        requireChatId(chatId, method)
+      );
+    }
+
     if (method === "tools.run") {
       if (!agentManager?.runTool) {
         throw new Error("tools.run requires agentManager");
@@ -90,6 +115,20 @@ export function createArisaCapabilities({ artifactStore, taskStore, agentManager
       return artifactStore.forChat(scopedChatId).get(requireString(params.artifactId, "artifactId"));
     }
 
+    if (method === "artifacts.deliver") {
+      const scopedChatId = requireChatId(chatId, method);
+      const artifactId = requireString(params.artifactId, "artifactId");
+      const artifact = await artifactStore.forChat(scopedChatId).get(artifactId);
+      if (!artifact?.path) throw new Error(`Artifact not found or has no file: ${artifactId}`);
+      if (!agentManager?.deliverArtifact) throw new Error("artifact delivery is unavailable");
+      return agentManager.deliverArtifact({
+        chatId: scopedChatId,
+        artifact,
+        caption: params.caption,
+        method: params.method
+      });
+    }
+
     if (method === "tasks.add") {
       const scopedChatId = requireChatId(chatId, method);
       return taskStore.add(params.task || {}, {
@@ -118,6 +157,11 @@ export function createArisaCapabilities({ artifactStore, taskStore, agentManager
       return taskStore.cancel(taskId);
     }
 
+    if (method === "tasks.cancelAll") {
+      const scopedChatId = requireChatId(chatId, method);
+      return taskStore.cancelAll({ chatId: scopedChatId });
+    }
+
     if (method === "agent.enqueueEvent") {
       const scopedChatId = requireChatId(chatId, method);
       return taskStore.add({

package/src/runtime/bootstrap.js

@@ -7,6 +7,7 @@ import { Bot } from "grammy";
 import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
 import { createPiRuntime, formatPiModelOption, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
 import { applyConfigDefaults, telegramConfigDefaults } from "../core/config/config-defaults.js";
+import { prepareConfigForSave } from "../core/config/config-store.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";
@@ -29,7 +30,7 @@ async function exists(file) {
   }
 }
 
-function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [], chatMeta = {}, provider, model, piApiKey }) {
+export function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [], chatMeta = {}, provider, model, piApiKey }) {
   return applyConfigDefaults({
     telegram: {
       token: telegramApiKey,
@@ -602,7 +603,7 @@ export async function bootstrapIfNeeded({ force = false } = {}) {
       result = await collectCliBootstrapChoices({ telegramApiKey, rl, ask });
     }
 
-    await writeFile(configFile, `${JSON.stringify(result.config, null, 2)}\n`, "utf8");
+    await writeFile(configFile, `${JSON.stringify(prepareConfigForSave(result.config), null, 2)}\n`, "utf8");
     console.log(`\nConfig saved to ${configFile}\n`);
     return {
       configCreated: true,

package/src/runtime/create-app.js

@@ -8,6 +8,9 @@ import { createTelegramBot } from "../transport/telegram/bot.js";
 import { createToolProcessSupervisor } from "./tool-process-supervisor.js";
 import { createArisaCapabilities } from "./arisa-capabilities.js";
 import { createIpcServer } from "./ipc/ipc-server.js";
+import { getAgentConfig } from "../core/agent/model-selection.js";
+import { normalizeModelSpeed } from "../core/agent/model-speed.js";
+import { runDoctor } from "./doctor.js";
 
 function normalizeString(value) {
   const text = String(value ?? "").trim();
@@ -51,10 +54,14 @@ function splitModelOverride(modelOverride) {
 }
 
 export function applyRuntimeOverrides(config, runtimeOverrides) {
+  const unsupportedNamespaces = Object.keys(runtimeOverrides || {}).filter((name) => name !== "pi");
+  if (unsupportedNamespaces.length) {
+    throw new Error(`Unsupported runtime override namespace: ${unsupportedNamespaces.join(", ")}`);
+  }
   const piRuntimeOverrides = runtimeOverrides?.pi || {};
   const pi = {};
-  const providerOverride = normalizeString(runtimeOverrides?.pi?.provider);
-  const modelOverride = normalizeString(runtimeOverrides?.pi?.model);
+  const providerOverride = normalizeString(piRuntimeOverrides.provider);
+  const modelOverride = normalizeString(piRuntimeOverrides.model);
 
   if (providerOverride || modelOverride) {
     const splitOverride = modelOverride ? splitModelOverride(modelOverride) : null;
@@ -77,6 +84,7 @@ export function applyRuntimeOverrides(config, runtimeOverrides) {
 
   const shellTimeoutMs = normalizePositiveInteger(piRuntimeOverrides.shellTimeoutMs);
   if (shellTimeoutMs) pi.shellTimeoutMs = shellTimeoutMs;
+  if (piRuntimeOverrides.speed !== undefined) pi.speed = normalizeModelSpeed(piRuntimeOverrides.speed);
 
   if (!Object.keys(pi).length) return config;
 
@@ -89,32 +97,55 @@ export function applyRuntimeOverrides(config, runtimeOverrides) {
   };
 }
 
-export async function createApp({ logger, runtimeOverrides } = {}) {
+export async function createApp({ logger, runtimeOverrides, requestRestart } = {}) {
+  if (typeof requestRestart !== "function") {
+    throw new Error("createApp requires a service restart handoff");
+  }
   logger?.log("app", "loading config");
   const persistedConfig = await loadConfig();
-  const config = applyRuntimeOverrides(persistedConfig, runtimeOverrides);
-  if (config.pi.provider !== persistedConfig.pi.provider || config.pi.model !== persistedConfig.pi.model) {
-    logger?.log("app", `applying runtime model override: ${persistedConfig.pi.provider}/${persistedConfig.pi.model} -> ${config.pi.provider}/${config.pi.model}`);
+  const overriddenConfig = applyRuntimeOverrides(persistedConfig, runtimeOverrides);
+  const config = overriddenConfig;
+  const activeConfig = getAgentConfig(config);
+  const persistedActiveConfig = getAgentConfig(persistedConfig);
+  if (activeConfig.provider !== persistedActiveConfig.provider || activeConfig.model !== persistedActiveConfig.model) {
+    logger?.log("app", `applying runtime model override: ${persistedActiveConfig.provider}/${persistedActiveConfig.model} -> ${activeConfig.provider}/${activeConfig.model}`);
   }
 
   const artifactStore = new ArtifactStore();
-  const toolProcessSupervisor = createToolProcessSupervisor({ logger, policy: config.daemons });
   const toolRegistry = new ToolRegistry({ logger });
+  const toolProcessSupervisor = createToolProcessSupervisor({ logger, policy: config.daemons, toolRegistry });
   const taskStore = new TaskStore();
   await toolRegistry.load();
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
 
   const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
-  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore, agentManager });
+  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore, toolRegistry, agentManager });
   const ipcServer = createIpcServer({ capabilities: arisaCapabilities, logger });
-  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger });
+  const bot = await createTelegramBot({
+    config,
+    artifactStore,
+    toolRegistry,
+    taskStore,
+    agentManager,
+    saveConfig,
+    updateConfig,
+    doctor: () => runDoctor({
+      agentManager,
+      toolProcessSupervisor,
+      daemonPolicy: config.daemons,
+      doctorPolicy: config.doctor,
+      logger
+    }),
+    requestRestart,
+    logger
+  });
 
   return {
     async start() {
-      logger?.log("app", `validating Pi model ${config.pi.provider}/${config.pi.model}`);
+      logger?.log("app", `validating Pi model ${activeConfig.provider}/${activeConfig.model}`);
       let skipAgentStartupPrompts = false;
       try {
-        await agentManager.validatePiAgent();
+        await agentManager.validateAgent();
       } catch (error) {
         const issue = getPiAuthIssue(error);
         if (!issue) {
@@ -129,6 +160,10 @@ export async function createApp({ logger, runtimeOverrides } = {}) {
       try {
         await ipcServer.start();
         ipcStarted = true;
+        const recoveredTasks = await taskStore.recoverInterrupted();
+        if (recoveredTasks.length) {
+          logger?.log("tasks", `recovered ${recoveredTasks.length} interrupted task(s)`);
+        }
         await toolProcessSupervisor.start();
         supervisorStarted = true;
         logger?.log("app", "starting Telegram bot");
@@ -142,6 +177,7 @@ export async function createApp({ logger, runtimeOverrides } = {}) {
 
     async stop() {
       await bot.stop?.();
+      await agentManager.close();
       await toolProcessSupervisor.stop();
       await ipcServer.stop();
     }

package/src/runtime/doctor.js

@@ -0,0 +1,307 @@
+import { execFile } from "node:child_process";
+import process from "node:process";
+import { promisify } from "node:util";
+import { stopManagedDaemon, unregisterManagedDaemon } from "../core/tools/daemon-processes.js";
+import { getServiceStatus, serviceEntryFile } from "./service-manager.js";
+
+const execFileAsync = promisify(execFile);
+
+function parsePosixProcesses(output) {
+  return String(output || "")
+    .split("\n")
+    .map((line) => /^\s*(\d+)\s+(.+)$/.exec(line))
+    .filter(Boolean)
+    .map((match) => ({ pid: Number(match[1]), command: match[2] }));
+}
+
+function parseWindowsProcesses(output) {
+  const parsed = JSON.parse(output || "[]");
+  const records = Array.isArray(parsed) ? parsed : [parsed];
+  return records
+    .filter((record) => record?.ProcessId && record?.CommandLine)
+    .map((record) => ({ pid: Number(record.ProcessId), command: String(record.CommandLine) }));
+}
+
+export async function listSystemProcesses({ timeoutMs, platform = process.platform } = {}) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Doctor process inspection requires a positive timeoutMs");
+  }
+  if (platform === "win32") {
+    const { stdout } = await execFileAsync("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
+    ], { timeout: timeoutMs, windowsHide: true });
+    return parseWindowsProcesses(stdout);
+  }
+  const { stdout } = await execFileAsync("ps", ["-ww", "-axo", "pid=,command="], { timeout: timeoutMs });
+  return parsePosixProcesses(stdout);
+}
+
+function isArisaServiceProcess(record) {
+  return record.command.includes(serviceEntryFile)
+    && /(?:^|\s)--service-runner(?:\s|$)/.test(record.command);
+}
+
+function isDaemonProcess(record, daemon) {
+  return record.command.includes(daemon.entryPath)
+    && /(?:^|\s)daemon(?:\s|$)/.test(record.command);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function terminateProcess(pid, { forceAfterMs } = {}) {
+  if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) {
+    throw new Error(`Refusing to terminate invalid doctor target: ${pid}`);
+  }
+  if (!Number.isFinite(forceAfterMs) || forceAfterMs <= 0) {
+    throw new Error("Doctor process cleanup requires a positive forceAfterMs");
+  }
+  if (!isAlive(pid)) return false;
+  process.kill(pid, "SIGTERM");
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < forceAfterMs) {
+    if (!isAlive(pid)) return true;
+    await sleep(Math.min(100, forceAfterMs));
+  }
+  if (isAlive(pid)) process.kill(pid, "SIGKILL");
+  return true;
+}
+
+function daemonLabel(record) {
+  return `${record.toolName} (${record.instanceId || "global"})`;
+}
+
+function daemonResultSummary(results) {
+  const states = new Map();
+  for (const result of results) {
+    const state = result.diagnostic?.state || result.outcome;
+    states.set(state, (states.get(state) || 0) + 1);
+  }
+  return [...states.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([state, count]) => `${count} ${state}`)
+    .join(", ");
+}
+
+function formatTokenCount(tokens) {
+  return new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 }).format(tokens);
+}
+
+function assertDoctorPolicy(policy) {
+  const positiveValues = [
+    "contextInspectionTimeoutMs",
+    "contextWarningPercent",
+    "contextCriticalPercent",
+    "contextInefficientMinTokens",
+    "contextToolResultWarningPercent",
+    "contextSingleMessageWarningPercent"
+  ];
+  for (const name of positiveValues) {
+    if (!Number.isFinite(policy?.[name]) || policy[name] <= 0) {
+      throw new Error(`Doctor configuration requires a positive ${name}`);
+    }
+  }
+  if (policy.contextCriticalPercent <= policy.contextWarningPercent) {
+    throw new Error("Doctor contextCriticalPercent must be greater than contextWarningPercent");
+  }
+}
+
+function evaluateContext(context, policy) {
+  if (context.error) return { ...context, level: "unknown", inefficiencies: [] };
+  const percent = context.percent;
+  const level = !Number.isFinite(percent)
+    ? "unknown"
+    : percent >= policy.contextCriticalPercent
+      ? "critical"
+      : percent >= policy.contextWarningPercent ? "warning" : "healthy";
+  const inefficiencies = [];
+  if (context.estimatedTokens >= policy.contextInefficientMinTokens) {
+    if (context.toolResultPercent >= policy.contextToolResultWarningPercent) {
+      inefficiencies.push(`tool results occupy ${context.toolResultPercent.toFixed(1)}% of retained content`);
+    }
+    if (context.largestMessagePercent >= policy.contextSingleMessageWarningPercent) {
+      inefficiencies.push(`one message occupies ${context.largestMessagePercent.toFixed(1)}% of retained content`);
+    }
+  }
+  return { ...context, level, inefficiencies };
+}
+
+function contextSummary(contexts) {
+  if (!contexts.length) return "Contexts: no active contexts.";
+  const measured = contexts.filter((context) => Number.isFinite(context.percent));
+  const oversized = contexts.filter((context) => context.level === "warning" || context.level === "critical").length;
+  const inefficient = contexts.filter((context) => context.inefficiencies.length).length;
+  const unavailable = contexts.length - measured.length;
+  const details = [
+    `${contexts.length} active`,
+    `${measured.length} measured`,
+    `${oversized} large`,
+    `${inefficient} inefficient`
+  ];
+  if (unavailable) details.push(`${unavailable} unavailable`);
+  if (measured.length) {
+    details.push(`max ${Math.max(...measured.map((context) => context.percent)).toFixed(1)}%`);
+  }
+  return `Contexts: ${details.join(", ")}.`;
+}
+
+function addContextAttention(report) {
+  for (const context of report.contexts) {
+    const label = `Chat ${context.chatId}`;
+    if (context.error) {
+      report.attention.push(`${label} context inspection failed: ${context.error}`);
+      continue;
+    }
+    if (context.level === "warning" || context.level === "critical") {
+      const size = context.tokens == null || context.contextWindow == null
+        ? `${context.percent.toFixed(1)}% of its context window`
+        : `${formatTokenCount(context.tokens)}/${formatTokenCount(context.contextWindow)} tokens (${context.percent.toFixed(1)}%)`;
+      const severity = context.level === "critical" ? "critically large" : "large";
+      report.attention.push(`${label} context is ${severity}: ${size}. Use /new to carry durable context into a fresh session.`);
+    }
+    if (context.inefficiencies.length) {
+      report.attention.push(`${label} context may be inefficient: ${formatTokenCount(context.estimatedTokens)} estimated retained tokens; ${context.inefficiencies.join("; ")}.`);
+    }
+  }
+}
+
+export function formatDoctorReport(report) {
+  const status = report.attention.length
+    ? "attention needed"
+    : report.repairs.length ? "repaired" : "healthy";
+  const lines = [
+    `Arisa Doctor: ${status}`,
+    `Core: Pi, ${report.runtime.sessions} active session(s), ${report.runtime.closingSessions} closing.`,
+    contextSummary(report.contexts),
+    `Daemons: ${report.daemons.length} checked${report.daemons.length ? ` (${daemonResultSummary(report.daemons)})` : ""}.`
+  ];
+  if (!report.repairs.length) lines.push("Processes: no unnecessary managed processes found.");
+  if (report.repairs.length) {
+    lines.push("", "Repairs:", ...report.repairs.map((item) => `- ${item}`));
+  }
+  if (report.attention.length) {
+    lines.push("", "Attention:", ...report.attention.map((item) => `- ${item}`));
+  }
+  return lines.join("\n");
+}
+
+export async function runDoctor({
+  agentManager,
+  toolProcessSupervisor,
+  daemonPolicy,
+  doctorPolicy,
+  logger,
+  listProcesses = listSystemProcesses,
+  stopProcess = terminateProcess,
+  serviceStatus = getServiceStatus,
+  stopDaemon = stopManagedDaemon,
+  unregisterDaemon = unregisterManagedDaemon
+}) {
+  assertDoctorPolicy(doctorPolicy);
+  const runtime = await agentManager.getRuntimeDiagnostic({
+    contextInspectionTimeoutMs: doctorPolicy.contextInspectionTimeoutMs
+  });
+  const report = {
+    runtime,
+    contexts: runtime.contexts.map((context) => evaluateContext(context, doctorPolicy)),
+    daemons: [],
+    repairs: [],
+    attention: []
+  };
+  addContextAttention(report);
+  let processes = [];
+  try {
+    processes = await listProcesses({ timeoutMs: daemonPolicy.healthTimeoutMs });
+  } catch (error) {
+    report.attention.push(`Process inspection failed: ${error?.message || error}`);
+  }
+
+  const processByPid = new Map(processes.map((record) => [record.pid, record]));
+  const currentService = await serviceStatus();
+  if (currentService.running && currentService.pid !== process.pid) {
+    const registered = processByPid.get(currentService.pid);
+    if (registered && isArisaServiceProcess(registered)) {
+      try {
+        await stopProcess(currentService.pid, { forceAfterMs: daemonPolicy.stopTimeoutMs });
+        report.repairs.push(`Stopped duplicate Arisa service process ${currentService.pid}.`);
+      } catch (error) {
+        report.attention.push(`Duplicate Arisa service process ${currentService.pid} could not be stopped: ${error?.message || error}`);
+      }
+    } else {
+      report.attention.push(`Registered service process ${currentService.pid} could not be verified and was left running.`);
+    }
+  }
+
+  try {
+    report.daemons = await toolProcessSupervisor.repair();
+  } catch (error) {
+    report.attention.push(`Daemon reconciliation failed: ${error?.message || error}`);
+  }
+  for (const result of report.daemons) {
+    const label = daemonLabel(result.record);
+    if (result.outcome === "stale-registration") {
+      const pid = result.diagnostic?.pid;
+      const registered = pid ? processByPid.get(pid) : null;
+      if (pid && (!registered || !isDaemonProcess(registered, result.record))) {
+        report.attention.push(`${label} has a stale registration, but its live process identity could not be verified.`);
+        continue;
+      }
+      try {
+        if (pid) {
+          await stopProcess(pid, { forceAfterMs: daemonPolicy.stopTimeoutMs });
+          await stopDaemon(
+            { toolName: result.record.toolName, scope: result.record.scope },
+            { state: null }
+          );
+        }
+        await unregisterDaemon({ toolName: result.record.toolName, scope: result.record.scope });
+        report.repairs.push(`Removed stale daemon registration ${label}: ${result.reason}.`);
+      } catch (error) {
+        report.attention.push(`${label} stale registration could not be removed: ${error?.message || error}`);
+      }
+      continue;
+    }
+    if (result.outcome === "missing-entry") {
+      const pid = result.diagnostic?.pid;
+      const registered = pid ? processByPid.get(pid) : null;
+      if (registered && isDaemonProcess(registered, result.record)) {
+        try {
+          await stopProcess(pid, { forceAfterMs: daemonPolicy.stopTimeoutMs });
+          await stopDaemon(
+            { toolName: result.record.toolName, scope: result.record.scope },
+            { state: "failed", message: "Orphaned daemon stopped because its tool entry is missing" }
+          );
+          report.repairs.push(`Stopped orphaned daemon ${label}.`);
+        } catch (error) {
+          report.attention.push(`${label} could not be stopped: ${error?.message || error}`);
+        }
+      } else {
+        report.attention.push(`${label} has a missing entry${pid ? "; its process identity could not be verified" : ""}.`);
+      }
+      continue;
+    }
+    if (["started", "recovered", "restart-scheduled"].includes(result.outcome)) {
+      report.repairs.push(`${label}: ${result.outcome}.`);
+    }
+    if (result.outcome === "error") {
+      report.attention.push(`${label}: daemon reconciliation failed.`);
+    } else if (result.diagnostic?.disposition === "requires-attention") {
+      report.attention.push(`${label}: ${result.diagnostic.message || result.diagnostic.state}.`);
+    }
+  }
+
+  logger?.log("doctor", `completed with ${report.repairs.length} repair(s) and ${report.attention.length} attention item(s)`);
+  return report;
+}