@ganglion/xacpx 0.10.0 → 0.10.1

package/README.md

@@ -258,6 +258,7 @@ xacpx doctor
 xacpx doctor --verbose
 xacpx doctor --smoke
 xacpx doctor --smoke --agent codex --workspace backend
+xacpx doctor --fix
 ```
 
 Notes:
@@ -266,6 +267,7 @@ Notes:
 - `--smoke` additionally runs a minimal real transport-level prompt check
 - `--agent` / `--workspace` only affect `--smoke`
 - Without `--smoke`, the related checks show as `SKIP`
+- `--fix` applies safe local repairs (runtime dir permissions, stale locks, invalid state records) and re-checks; state-mutating repairs are withheld while the daemon runs — see [docs/doctor-command.md](docs/doctor-command.md)
 
 ### How to use `update`
 

package/dist/cli.js

@@ -5301,7 +5301,7 @@ class DaemonController {
     this.deps = deps;
     this.statusStore = new DaemonStatusStore(paths.statusFile);
     this.startupPollIntervalMs = deps.startupPollIntervalMs ?? 50;
-    this.startupTimeoutMs = deps.startupTimeoutMs ?? 5000;
+    this.startupTimeoutMs = deps.startupTimeoutMs ?? 1e4;
     this.onboardingStartupTimeoutMs = deps.onboardingStartupTimeoutMs ?? 300000;
     this.shutdownPollIntervalMs = deps.shutdownPollIntervalMs ?? 50;
     this.shutdownTimeoutMs = deps.shutdownTimeoutMs ?? 5000;
@@ -5696,6 +5696,14 @@ function resolveRuntimeDirFromConfigPath(configPath) {
 function resolveDaemonOrchestrationSocketPath(runtimeDir, platform = process.platform) {
   return resolveOrchestrationEndpoint(runtimeDir, platform).path;
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
 var init_daemon_files = __esm(() => {
   init_core_home();
   init_orchestration_ipc();
@@ -19815,6 +19823,122 @@ var init_plugin_loader = __esm(() => {
   init_plugin_home();
 });
 
+// src/plugins/plugin-doctor.ts
+import { readFile as readFile10 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+function suggestedPluginPackageForChannel(type) {
+  return findKnownPluginByChannel(type)?.packageName ?? `<npm-package-that-provides-${type}>`;
+}
+async function readDependencyEntries(pluginHome) {
+  try {
+    const raw = await readFile10(join12(pluginHome, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const out = {};
+    for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
+      if (typeof value === "string")
+        out[name] = value;
+    }
+    return out;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`failed to read plugin home package.json: ${message}`);
+  }
+}
+async function inspectPlugins(input) {
+  const issues = [];
+  let dependencies;
+  try {
+    dependencies = await readDependencyEntries(input.pluginHome);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return [{ level: "error", message }];
+  }
+  const importPlugin = input.importPlugin ?? importPluginFromHome;
+  const allConfigured = input.config.plugins;
+  const filterByName = input.pluginName ? normalizePluginPackageName(input.pluginName) : null;
+  if (filterByName && !allConfigured.some((plugin) => normalizePluginPackageName(plugin.name) === filterByName)) {
+    return [{ level: "error", plugin: filterByName, message: `plugin is not configured; run xacpx plugin add ${filterByName}` }];
+  }
+  const pushIfRelevant = (issue2) => {
+    if (!filterByName || issue2.plugin === filterByName)
+      issues.push(issue2);
+  };
+  const channelProviders = new Map;
+  for (const configPlugin of allConfigured) {
+    if (!(configPlugin.name in dependencies)) {
+      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `package not installed in plugin home; run xacpx plugin add ${configPlugin.name}`, suggestion: `xacpx plugin add ${configPlugin.name} && xacpx restart` });
+      continue;
+    }
+    let moduleValue;
+    try {
+      moduleValue = await importPlugin(configPlugin.name, input.pluginHome);
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `failed to import plugin: ${message}`, suggestion: `xacpx plugin add ${configPlugin.name} && xacpx restart` });
+      continue;
+    }
+    try {
+      const plugin = validateWeacpxPlugin(moduleValue, configPlugin.name, {
+        ...input.currentXacpxVersion !== undefined ? { currentXacpxVersion: input.currentXacpxVersion } : {}
+      });
+      const channels = plugin.channels ?? [];
+      const channelTypes = channels.map((channel) => channel.type);
+      for (const type of channelTypes) {
+        const existing = channelProviders.get(type);
+        if (existing) {
+          pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `channel type ${type} is already provided by ${existing.plugin}` });
+        } else {
+          channelProviders.set(type, { plugin: configPlugin.name, enabled: configPlugin.enabled });
+        }
+      }
+      pushIfRelevant({
+        level: configPlugin.enabled ? "ok" : "warn",
+        plugin: configPlugin.name,
+        message: configPlugin.enabled ? `plugin is installed and valid; channels: ${channelTypes.length > 0 ? channelTypes.join(", ") : "none"}` : `plugin is installed and valid but disabled; run xacpx plugin enable ${configPlugin.name}`,
+        ...configPlugin.enabled ? {} : { suggestion: `xacpx plugin enable ${configPlugin.name}` }
+      });
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      pushIfRelevant({ level: "error", plugin: configPlugin.name, message });
+    }
+  }
+  const builtInChannelTypes = new Set(listKnownChannelIds());
+  for (const channel of input.config.channels) {
+    if (channel.enabled === false)
+      continue;
+    if (builtInChannelTypes.has(channel.type))
+      continue;
+    const provider = channelProviders.get(channel.type);
+    if (!provider) {
+      if (!filterByName) {
+        const suggestedPackage = suggestedPluginPackageForChannel(channel.type);
+        issues.push({
+          level: "error",
+          message: `channel ${channel.type} is configured but no enabled plugin provides it; run xacpx plugin add ${suggestedPackage} or another plugin that provides type "${channel.type}"`,
+          suggestion: `xacpx plugin add ${suggestedPackage}`
+        });
+      }
+      continue;
+    }
+    if (!provider.enabled) {
+      pushIfRelevant({
+        level: "error",
+        plugin: provider.plugin,
+        message: `channel ${channel.type} is configured but provider plugin is disabled; run xacpx plugin enable ${provider.plugin}`,
+        suggestion: `xacpx plugin enable ${provider.plugin}`
+      });
+    }
+  }
+  return issues;
+}
+var init_plugin_doctor = __esm(() => {
+  init_channel_scope();
+  init_plugin_loader();
+  init_validate_plugin();
+  init_known_plugins();
+  init_plugin_renames();
+});
+
 // src/channels/bootstrap.ts
 function bootstrapBuiltinChannels() {
   bootstrapBuiltinChannelFactories();
@@ -29815,8 +29939,9 @@ async function runConsole(paths, deps) {
         throw error2;
       }
     }
-    await runtime.reapStaleQueueOwners();
+    const reapPromise = Promise.resolve(runtime.reapStaleQueueOwners()).catch(() => {});
     if (deps.beforeReady) {
+      await reapPromise;
       await deps.beforeReady(runtime);
     }
     if (deps.daemonRuntime) {
@@ -29830,6 +29955,7 @@ async function runConsole(paths, deps) {
         deps.daemonRuntime?.heartbeat().catch(() => {});
       }, deps.heartbeatIntervalMs ?? 30000);
     }
+    await reapPromise;
     const channelStartPromise = deps.channels.startAll({
       agent: runtime.agent,
       abortSignal: shutdownController.signal,
@@ -33161,8 +33287,10 @@ var init_config_check = __esm(async () => {
 });
 
 // src/doctor/checks/daemon-check.ts
+import { readdir as readdir3, readFile as readFile14, rm as rm10 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { homedir as homedir10 } from "node:os";
+import { join as join19 } from "node:path";
 async function checkDaemon(options = {}) {
   const home = options.home ?? process.env.HOME ?? homedir10();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
@@ -33170,15 +33298,25 @@ async function checkDaemon(options = {}) {
     home,
     ...runtimeDir ? { runtimeDir } : {}
   });
+  const isProcessRunning = options.isProcessRunning ?? isProcessAlive;
+  const listConsumerLocks = options.listConsumerLocks ?? defaultListConsumerLocks;
+  const readConsumerLock = options.readConsumerLock ?? defaultReadConsumerLock;
+  const removeConsumerLock = options.removeConsumerLock ?? defaultRemoveConsumerLock;
   const controller = createDaemonController(paths, {
     processExecPath: options.processExecPath ?? process.execPath,
     cliEntryPath: options.cliEntryPath ?? resolveCliEntryPath(),
     cwd: options.cwd ?? process.cwd(),
     env: options.env ?? process.env,
-    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning5
+    isProcessRunning
   });
   try {
     const status = await controller.getStatus();
+    const staleLockFix = status.state === "stopped" ? await detectStaleConsumerLockFix(paths.runtimeDir, {
+      isProcessRunning,
+      listConsumerLocks,
+      readConsumerLock,
+      removeConsumerLock
+    }) : undefined;
     switch (status.state) {
       case "running":
         return {
@@ -33200,6 +33338,7 @@ async function checkDaemon(options = {}) {
           summary: status.stale ? "daemon was stopped and stale runtime files were cleared" : "daemon is not running",
           details: status.stale ? ["stale runtime files were cleared"] : undefined,
           suggestions: ["run: xacpx start"],
+          ...staleLockFix ? { fixes: [staleLockFix] } : {},
           metadata: {
             paths,
             status
@@ -33246,25 +33385,210 @@ async function checkDaemon(options = {}) {
     };
   }
 }
-function defaultIsProcessRunning5(pid) {
+async function detectStaleConsumerLockFix(runtimeDir, deps) {
+  const lockFiles = await deps.listConsumerLocks(runtimeDir);
+  const stalePaths = [];
+  for (const fileName of lockFiles) {
+    if (!fileName.endsWith(CONSUMER_LOCK_SUFFIX)) {
+      continue;
+    }
+    const lockPath = join19(runtimeDir, fileName);
+    const lock2 = await deps.readConsumerLock(lockPath);
+    if (lock2 && !deps.isProcessRunning(lock2.pid)) {
+      stalePaths.push(lockPath);
+    }
+  }
+  if (stalePaths.length === 0) {
+    return;
+  }
+  return {
+    id: "daemon.clear-stale-lock",
+    title: "remove stale consumer lock(s)",
+    run: async () => {
+      const removed = [];
+      let skipped = 0;
+      for (const lockPath of stalePaths) {
+        const lock2 = await deps.readConsumerLock(lockPath);
+        if (!lock2 || deps.isProcessRunning(lock2.pid)) {
+          skipped += 1;
+          continue;
+        }
+        await deps.removeConsumerLock(lockPath);
+        removed.push(lockPath);
+      }
+      const skippedNote = skipped > 0 ? `; left ${skipped} no-longer-stale lock(s) alone` : "";
+      return {
+        ok: true,
+        message: removed.length > 0 ? `removed ${removed.length} stale consumer lock(s): ${removed.join(", ")}${skippedNote}` : `no locks removed${skippedNote}`
+      };
+    }
+  };
+}
+async function defaultListConsumerLocks(runtimeDir) {
+  try {
+    return await readdir3(runtimeDir);
+  } catch {
+    return [];
+  }
+}
+async function defaultReadConsumerLock(path15) {
   try {
-    process.kill(pid, 0);
-    return true;
+    const raw = await readFile14(path15, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.pid === "number" ? { pid: parsed.pid } : null;
   } catch {
-    return false;
+    return null;
   }
 }
+async function defaultRemoveConsumerLock(path15) {
+  await rm10(path15, { force: true });
+}
 function resolveCliEntryPath() {
   return process.argv[1] ?? fileURLToPath6(import.meta.url);
 }
 function formatError5(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
+var CONSUMER_LOCK_SUFFIX = "-consumer.lock.json";
 var init_daemon_check = __esm(() => {
   init_create_daemon_controller();
   init_daemon_files();
 });
 
+// src/doctor/checks/logs-check.ts
+import { stat as stat3, readdir as readdir4 } from "node:fs/promises";
+import { basename as basename3, join as join20 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+async function checkLogs(options = {}) {
+  const home = options.home ?? process.env.HOME ?? homedir11();
+  const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
+  const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
+    home,
+    ...runtimeDir ? { runtimeDir } : {}
+  });
+  const probe = options.probe ?? createLogsFsProbe();
+  const singleFileWarnBytes = options.singleFileWarnBytes ?? DEFAULT_SINGLE_FILE_WARN_BYTES;
+  const totalWarnBytes = options.totalWarnBytes ?? DEFAULT_TOTAL_WARN_BYTES;
+  let entries;
+  try {
+    const dirStat = await probe.stat(paths.runtimeDir);
+    if (!dirStat.isDirectory()) {
+      return skip("runtime log directory could not be read", [
+        `runtimeDir: ${paths.runtimeDir} (exists but is not a directory)`
+      ]);
+    }
+    entries = await probe.readdir(paths.runtimeDir);
+  } catch (error2) {
+    if (isMissingPathError(error2)) {
+      return skip("no runtime logs yet", [`runtimeDir: ${paths.runtimeDir} (missing)`]);
+    }
+    return skip("runtime log directory could not be read", [
+      `runtimeDir: ${paths.runtimeDir}`,
+      `error: ${formatError6(error2)}`
+    ]);
+  }
+  const baseNames = [basename3(paths.appLog), basename3(paths.stdoutLog), basename3(paths.stderrLog)];
+  const tracked = new Set(baseNames);
+  const matched = entries.filter((entry) => isTrackedLogName(entry, tracked));
+  const files = [];
+  for (const name of matched) {
+    const path15 = join20(paths.runtimeDir, name);
+    try {
+      const fileStat = await probe.stat(path15);
+      if (fileStat.isDirectory()) {
+        continue;
+      }
+      files.push({ name, path: path15, size: fileStat.size });
+    } catch {
+      continue;
+    }
+  }
+  const total = files.reduce((sum, file) => sum + file.size, 0);
+  const largestSingle = files.reduce((max, file) => Math.max(max, file.size), 0);
+  const overSingle = files.some((file) => file.size > singleFileWarnBytes);
+  const overTotal = total > totalWarnBytes;
+  const sorted = [...files].sort((a, b) => b.size - a.size);
+  const details = [
+    ...sorted.map((file) => `${file.name}: ${formatBytes(file.size)}`),
+    `total: ${formatBytes(total)}`
+  ];
+  if (overSingle || overTotal) {
+    const reason = overSingle ? `largest single log is ${formatBytes(largestSingle)}` : `total is ${formatBytes(total)}`;
+    return {
+      id: "logs",
+      label: "Logs",
+      severity: "warn",
+      summary: `log growth high: ${reason} (total ${formatBytes(total)})`,
+      details,
+      suggestions: [
+        "logs are large; check disk space and that log rotation is configured (logging.maxSizeBytes / maxFiles)"
+      ]
+    };
+  }
+  return {
+    id: "logs",
+    label: "Logs",
+    severity: "pass",
+    summary: `logs total ${formatBytes(total)}`,
+    details
+  };
+}
+function skip(summary, details) {
+  return {
+    id: "logs",
+    label: "Logs",
+    severity: "skip",
+    summary,
+    details
+  };
+}
+function isTrackedLogName(name, baseNames) {
+  if (baseNames.has(name)) {
+    return true;
+  }
+  for (const base of baseNames) {
+    const prefix = `${base}.`;
+    if (name.startsWith(prefix)) {
+      const suffix = name.slice(prefix.length);
+      if (/^\d+$/.test(suffix) && Number(suffix) > 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  return `${value.toFixed(1)} ${units[unitIndex]}`;
+}
+function createLogsFsProbe() {
+  return {
+    stat: async (path15) => await stat3(path15),
+    readdir: async (path15) => await readdir4(path15)
+  };
+}
+function formatError6(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function isMissingPathError(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && (error2.code === "ENOENT" || error2.code === "ENOTDIR");
+}
+var DEFAULT_SINGLE_FILE_WARN_BYTES, DEFAULT_TOTAL_WARN_BYTES;
+var init_logs_check = __esm(() => {
+  init_daemon_files();
+  DEFAULT_SINGLE_FILE_WARN_BYTES = 50 * 1024 * 1024;
+  DEFAULT_TOTAL_WARN_BYTES = 200 * 1024 * 1024;
+});
+
 // src/doctor/checks/orchestration-health.ts
 async function checkOrchestrationHealth(options) {
   const state = await options.loadState();
@@ -33317,13 +33641,187 @@ var init_orchestration_health = __esm(() => {
   init_i18n();
 });
 
+// src/doctor/checks/orchestration-socket-check.ts
+import { homedir as homedir12 } from "node:os";
+async function checkOrchestrationSocket(options = {}) {
+  const home = options.home ?? process.env.HOME ?? homedir12();
+  const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
+  const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
+    home,
+    ...runtimeDir ? { runtimeDir } : {}
+  });
+  const getDaemonStatus = options.getDaemonStatus ?? ((p) => defaultGetDaemonStatus(p, options));
+  const probe = options.canConnectToEndpoint ?? canConnectToEndpoint;
+  const resolveEndpoint = options.resolveOrchestrationEndpoint ?? ((dir) => resolveOrchestrationEndpoint(dir));
+  let status;
+  try {
+    status = await getDaemonStatus(paths);
+  } catch (error2) {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "skip",
+      summary: "daemon status could not be read",
+      details: [`runtime dir: ${paths.runtimeDir}`, `error: ${formatError7(error2)}`]
+    };
+  }
+  if (status.state === "stopped") {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "skip",
+      summary: "daemon stopped"
+    };
+  }
+  let endpoint;
+  let reachable;
+  try {
+    endpoint = resolveEndpoint(paths.runtimeDir);
+    reachable = await probe(endpoint.path);
+  } catch (error2) {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "skip",
+      summary: "orchestration IPC liveness could not be probed",
+      details: [`runtime dir: ${paths.runtimeDir}`, `error: ${formatError7(error2)}`]
+    };
+  }
+  if (reachable) {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "pass",
+      summary: "orchestration IPC is accepting connections",
+      details: [`endpoint: ${endpoint.path}`]
+    };
+  }
+  return {
+    id: "orchestration-socket",
+    label: "Orchestration IPC",
+    severity: "fail",
+    summary: "daemon is running but orchestration IPC is not accepting connections",
+    details: [`endpoint: ${endpoint.path}`],
+    suggestions: ["run: xacpx restart"]
+  };
+}
+async function defaultGetDaemonStatus(paths, options) {
+  const controller = createDaemonController(paths, {
+    processExecPath: options.processExecPath ?? process.execPath,
+    cliEntryPath: options.cliEntryPath ?? process.argv[1] ?? "",
+    cwd: options.cwd ?? process.cwd(),
+    env: options.env ?? process.env,
+    isProcessRunning: options.isProcessRunning ?? isProcessAlive
+  });
+  return await controller.getStatus();
+}
+function formatError7(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+var init_orchestration_socket_check = __esm(() => {
+  init_create_daemon_controller();
+  init_daemon_files();
+  init_endpoint_probe();
+  init_orchestration_ipc();
+});
+
+// src/doctor/checks/plugin-check.ts
+async function checkPlugins(options = {}) {
+  const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
+  let config4;
+  try {
+    config4 = await (options.loadConfig ?? loadConfig)(runtimePaths.configPath);
+  } catch (error2) {
+    return {
+      id: "plugins",
+      label: "Plugins",
+      severity: "skip",
+      summary: "plugin check skipped because configuration could not be loaded",
+      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError8(error2)}`],
+      suggestions: ["fix the Config check first, then run: xacpx doctor"]
+    };
+  }
+  if (!hasPluginSurface(config4)) {
+    return {
+      id: "plugins",
+      label: "Plugins",
+      severity: "skip",
+      summary: "no plugins configured"
+    };
+  }
+  const pluginHome = (options.resolvePluginHome ?? resolvePluginHome)({ home: options.home });
+  const inspect = options.inspectPlugins ?? inspectPlugins;
+  let issues;
+  try {
+    issues = await inspect({
+      config: config4,
+      pluginHome,
+      currentXacpxVersion: options.currentXacpxVersion ?? XACPX_CORE_VERSION
+    });
+  } catch (error2) {
+    return {
+      id: "plugins",
+      label: "Plugins",
+      severity: "fail",
+      summary: "plugin health check failed",
+      details: [`plugin home: ${pluginHome}`, `error: ${formatError8(error2)}`]
+    };
+  }
+  const errorCount = issues.filter((issue2) => issue2.level === "error").length;
+  const warnCount = issues.filter((issue2) => issue2.level === "warn").length;
+  const severity = errorCount > 0 ? "fail" : warnCount > 0 ? "warn" : "pass";
+  const problemCount = errorCount + warnCount;
+  return {
+    id: "plugins",
+    label: "Plugins",
+    severity,
+    summary: problemCount > 0 ? `${problemCount} plugin issue(s)` : "all plugins healthy",
+    details: issues.filter((issue2) => issue2.level !== "ok").map(formatIssueDetail),
+    suggestions: collectSuggestions(issues),
+    metadata: { pluginHome, errorCount, warnCount }
+  };
+}
+function hasPluginSurface(config4) {
+  if ((config4.plugins ?? []).length > 0) {
+    return true;
+  }
+  const builtInChannelTypes = new Set(listKnownChannelIds());
+  return (config4.channels ?? []).some((channel) => channel.enabled !== false && !builtInChannelTypes.has(channel.type));
+}
+function formatIssueDetail(issue2) {
+  return issue2.plugin ? `${issue2.plugin}: ${issue2.message}` : issue2.message;
+}
+function collectSuggestions(issues) {
+  const suggestions = [];
+  const seen = new Set;
+  for (const issue2 of issues) {
+    const suggestion = issue2.suggestion;
+    if (suggestion && !seen.has(suggestion)) {
+      seen.add(suggestion);
+      suggestions.push(`run: ${suggestion}`);
+    }
+  }
+  return suggestions;
+}
+function formatError8(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+var init_plugin_check = __esm(async () => {
+  init_load_config();
+  init_channel_scope();
+  init_plugin_doctor();
+  init_plugin_home();
+  init_version();
+  await init_main();
+});
+
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
-import { access as access4, stat as stat3 } from "node:fs/promises";
+import { access as access4, stat as stat4 } from "node:fs/promises";
 import { dirname as dirname13 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 async function checkRuntime(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir11();
+  const home = options.home ?? process.env.HOME ?? homedir13();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -33349,6 +33847,20 @@ async function checkRuntime(options = {}) {
       details: checks3.map((check) => check.detail)
     };
   }
+  const privacy = await inspectRuntimeDirPrivacy(paths.runtimeDir, probe, platform);
+  if (privacy.needsRepair) {
+    return {
+      id: "runtime",
+      label: "Runtime",
+      severity: "warn",
+      summary: "daemon runtime dir should be private (mode 0700)",
+      details: [...checks3.map((check) => check.detail), privacy.detail],
+      fixes: [createEnsurePrivateDirFix(paths.runtimeDir, options.ensurePrivateRuntimeDir)],
+      metadata: {
+        paths
+      }
+    };
+  }
   return {
     id: "runtime",
     label: "Runtime",
@@ -33360,9 +33872,50 @@ async function checkRuntime(options = {}) {
     }
   };
 }
+async function inspectRuntimeDirPrivacy(runtimeDir, probe, platform) {
+  if (platform === "win32") {
+    return { needsRepair: false, detail: "" };
+  }
+  try {
+    const stats = await probe.stat(runtimeDir);
+    if (typeof stats.mode !== "number") {
+      return { needsRepair: false, detail: "" };
+    }
+    const mode = stats.mode & 511;
+    if (mode === PRIVATE_DIR_MODE) {
+      return { needsRepair: false, detail: "" };
+    }
+    return {
+      needsRepair: true,
+      detail: `runtimeDir: ${runtimeDir} (mode ${formatMode(mode)} is not 0700; group/other access should be removed)`
+    };
+  } catch (error2) {
+    if (isMissingPathError2(error2)) {
+      return {
+        needsRepair: true,
+        detail: `runtimeDir: ${runtimeDir} (missing; will be created with mode 0700)`
+      };
+    }
+    return { needsRepair: false, detail: "" };
+  }
+}
+function createEnsurePrivateDirFix(runtimeDir, ensureImpl) {
+  const ensure = ensureImpl ?? ((dir) => ensurePrivateRuntimeDir(dir));
+  return {
+    id: "runtime.ensure-private-dir",
+    title: "create/repair runtime dir with mode 0700",
+    run: async () => {
+      await ensure(runtimeDir);
+      return { ok: true, message: `runtime dir ${runtimeDir} created/repaired with mode 0700` };
+    }
+  };
+}
+function formatMode(mode) {
+  return `0${(mode & 511).toString(8)}`;
+}
 function createRuntimeFsProbe() {
   return {
-    stat: async (path15) => await stat3(path15),
+    stat: async (path15) => await stat4(path15),
     access: async (path15, mode) => await access4(path15, mode)
   };
 }
@@ -33381,10 +33934,10 @@ async function checkDirectoryCreatable(label, path15, probe, platform) {
       detail: `${label}: ${path15} (writable)`
     };
   } catch (error2) {
-    if (!isMissingPathError(error2)) {
+    if (!isMissingPathError2(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path15} (unusable: ${formatError9(error2)})`
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(path15, probe, platform);
@@ -33415,10 +33968,10 @@ async function checkFileCreatable(label, path15, probe, platform) {
       detail: `${label}: ${path15} (writable)`
     };
   } catch (error2) {
-    if (!isMissingPathError(error2)) {
+    if (!isMissingPathError2(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path15} (unusable: ${formatError9(error2)})`
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(dirname13(path15), probe, platform);
@@ -33450,7 +34003,7 @@ async function checkCreatableAncestorDirectory(path15, probe, platform) {
       creatableFrom: path15
     };
   } catch (error2) {
-    if (!isMissingPathError(error2)) {
+    if (!isMissingPathError2(error2)) {
       return {
         ok: false,
         creatableFrom: path15,
@@ -33478,21 +34031,22 @@ async function checkCreatableAncestorDirectory(path15, probe, platform) {
 function directoryAccessMode(platform) {
   return platform === "win32" ? constants.W_OK : DIRECTORY_USABLE;
 }
-function isMissingPathError(error2) {
+function isMissingPathError2(error2) {
   return isErrnoError(error2) && (error2.code === "ENOENT" || error2.code === "ENOTDIR");
 }
 function isErrnoError(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2;
 }
-function formatError6(error2) {
+function formatError9(error2) {
   if (error2 instanceof Error) {
     return error2.message;
   }
   return String(error2);
 }
-var DIRECTORY_USABLE;
+var DIRECTORY_USABLE, PRIVATE_DIR_MODE = 448;
 var init_runtime_check = __esm(() => {
   init_daemon_files();
+  init_private_runtime_dir();
   DIRECTORY_USABLE = constants.W_OK | constants.X_OK;
 });
 
@@ -33604,7 +34158,7 @@ async function checkSmoke(options = {}, deps = {}) {
       label: "Smoke",
       severity: "fail",
       summary: "smoke transport probe failed",
-      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError7(error2)}`]
+      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError10(error2)}`]
     };
   }
 }
@@ -33731,7 +34285,7 @@ function buildDetails3(options) {
   }
   return details;
 }
-function formatError7(error2) {
+function formatError10(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 var SMOKE_PROMPT = "Reply with exactly: ok";
@@ -33756,7 +34310,7 @@ async function checkWechat(options = {}) {
     } catch (error2) {
       return {
         accountId,
-        error: formatError8(error2)
+        error: formatError11(error2)
       };
     }
   });
@@ -33797,7 +34351,7 @@ function buildVerboseDetails(loggedIn, verbose, accounts) {
   }
   return details;
 }
-function formatError8(error2) {
+function formatError11(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 var init_wechat_check = __esm(() => {
@@ -33806,43 +34360,60 @@ var init_wechat_check = __esm(() => {
 
 // src/doctor/render-doctor.ts
 function renderDoctor(report, options = {}) {
-  return options.verbose ? renderVerboseDoctor(report) : renderDefaultDoctor(report);
+  const fixMode = options.fix === true;
+  return options.verbose ? renderVerboseDoctor(report, fixMode) : renderDefaultDoctor(report, fixMode);
 }
-function renderDefaultDoctor(report) {
+function renderDefaultDoctor(report, fixMode) {
   const lines = [];
   for (const check of report.checks) {
-    lines.push(renderCheckLine(check));
+    lines.push(renderCheckLine(check, fixMode));
   }
+  appendRepairs(lines, report, fixMode);
   lines.push(renderSummaryLine(report.checks));
-  const suggestions = collectSuggestions(report.checks);
-  if (suggestions.length > 0) {
-    lines.push("Next steps:");
-    for (const suggestion of suggestions) {
-      lines.push(`- ${suggestion}`);
-    }
-  }
+  appendNextSteps(lines, report.checks);
   return lines;
 }
-function renderVerboseDoctor(report) {
+function renderVerboseDoctor(report, fixMode) {
   const lines = [];
   for (const check of report.checks) {
-    lines.push(renderCheckLine(check));
+    lines.push(renderCheckLine(check, fixMode));
     for (const detail of check.details ?? []) {
       lines.push(`  detail: ${detail}`);
     }
   }
+  appendRepairs(lines, report, fixMode);
   lines.push(renderSummaryLine(report.checks));
-  const suggestions = collectSuggestions(report.checks);
+  appendNextSteps(lines, report.checks);
+  return lines;
+}
+function appendNextSteps(lines, checks3) {
+  const suggestions = collectSuggestions2(checks3);
   if (suggestions.length > 0) {
     lines.push("Next steps:");
     for (const suggestion of suggestions) {
       lines.push(`- ${suggestion}`);
     }
   }
-  return lines;
 }
-function renderCheckLine(check) {
-  return `${SEVERITY_LABELS[check.severity]} ${check.label}: ${check.summary}`;
+function appendRepairs(lines, report, fixMode) {
+  if (!fixMode) {
+    return;
+  }
+  const repairs = report.repairs ?? [];
+  if (repairs.length === 0) {
+    return;
+  }
+  lines.push("Repairs:");
+  for (const repair of repairs) {
+    lines.push(`- ${repair.title}: ${repair.status} (${repair.message})`);
+  }
+}
+function renderCheckLine(check, fixMode) {
+  const base = `${SEVERITY_LABELS[check.severity]} ${check.label}: ${check.summary}`;
+  if (!fixMode && (check.fixes?.length ?? 0) > 0) {
+    return `${base} (fixable — run: xacpx doctor --fix)`;
+  }
+  return base;
 }
 function renderSummaryLine(checks3) {
   const counts = summarizeChecks(checks3);
@@ -33854,7 +34425,7 @@ function summarizeChecks(checks3) {
     return counts;
   }, { pass: 0, warn: 0, fail: 0, skip: 0 });
 }
-function collectSuggestions(checks3) {
+function collectSuggestions2(checks3) {
   const seen = new Set;
   const suggestions = [];
   for (const check of checks3) {
@@ -33879,47 +34450,112 @@ var init_render_doctor = __esm(() => {
 });
 
 // src/doctor/doctor.ts
-import { homedir as homedir12 } from "node:os";
-import { join as join19 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join21 } from "node:path";
 async function runDoctor(options = {}, deps = {}) {
-  const home = deps.home ?? process.env.HOME ?? homedir12();
+  const home = deps.home ?? process.env.HOME ?? homedir14();
   const runtimePaths = resolveDoctorRuntimePaths(home, deps.resolveRuntimePaths);
   const sharedLoadConfig = createSharedLoadConfig(runtimePaths, deps.loadConfig ?? loadConfig);
+  const runners = [
+    {
+      id: "config",
+      run: () => (deps.checkConfig ?? checkConfig)({
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "runtime",
+      run: () => (deps.checkRuntime ?? checkRuntime)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "logs",
+      run: () => (deps.checkLogs ?? checkLogs)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "daemon",
+      run: () => (deps.checkDaemon ?? checkDaemon)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "wechat",
+      run: () => (deps.checkWechat ?? checkWechat)({
+        verbose: options.verbose
+      })
+    },
+    {
+      id: "acpx",
+      run: () => (deps.checkAcpx ?? checkAcpx)({
+        verbose: options.verbose,
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "bridge",
+      run: () => (deps.checkBridge ?? checkBridge)({
+        verbose: options.verbose,
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "plugins",
+      run: () => (deps.checkPlugins ?? checkPlugins)({
+        home,
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "orchestration",
+      run: () => (deps.checkOrchestrationHealth ?? (() => defaultCheckOrchestrationHealth({
+        runtimePaths,
+        loadConfig: sharedLoadConfig,
+        isDaemonRunning: deps.isDaemonRunning ?? (() => defaultIsDaemonRunning(home, runtimePaths, deps.getDaemonStatus))
+      })))()
+    },
+    {
+      id: "orchestration-socket",
+      run: () => (deps.checkOrchestrationSocket ?? checkOrchestrationSocket)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "smoke",
+      run: () => options.smoke === true ? (deps.checkSmoke ?? ((runOptions) => defaultCheckSmoke(runOptions, {
+        resolveRuntimePaths: () => runtimePaths,
+        loadConfig: sharedLoadConfig
+      })))(options) : Promise.resolve(createSmokeSkipResult("smoke probe not requested"))
+    }
+  ];
+  const runnersById = new Map(runners.map((runner) => [runner.id, runner.run]));
   const checks3 = [];
-  checks3.push(await (deps.checkConfig ?? checkConfig)({
-    loadConfig: sharedLoadConfig,
-    resolveRuntimePaths: () => runtimePaths
-  }));
-  checks3.push(await (deps.checkRuntime ?? checkRuntime)({
-    home,
-    configPath: runtimePaths.configPath
-  }));
-  checks3.push(await (deps.checkDaemon ?? checkDaemon)({
-    home,
-    configPath: runtimePaths.configPath
-  }));
-  checks3.push(await (deps.checkWechat ?? checkWechat)({
-    verbose: options.verbose
-  }));
-  checks3.push(await (deps.checkAcpx ?? checkAcpx)({
-    verbose: options.verbose,
-    loadConfig: sharedLoadConfig,
-    resolveRuntimePaths: () => runtimePaths
-  }));
-  checks3.push(await (deps.checkBridge ?? checkBridge)({
-    verbose: options.verbose,
-    loadConfig: sharedLoadConfig,
-    resolveRuntimePaths: () => runtimePaths
-  }));
-  checks3.push(await (deps.checkOrchestrationHealth ?? (() => defaultCheckOrchestrationHealth({
-    runtimePaths,
-    loadConfig: sharedLoadConfig
-  })))());
-  checks3.push(options.smoke === true ? await (deps.checkSmoke ?? ((runOptions) => defaultCheckSmoke(runOptions, {
-    resolveRuntimePaths: () => runtimePaths,
-    loadConfig: sharedLoadConfig
-  })))(options) : createSmokeSkipResult("smoke probe not requested"));
+  for (const runner of runners) {
+    checks3.push(await runner.run());
+  }
   const report = { checks: checks3 };
+  if (options.fix === true) {
+    const { repairs, repairedCheckIds } = await applyRepairs(checks3);
+    report.repairs = repairs;
+    for (const checkId of repairedCheckIds) {
+      const index = checks3.findIndex((check) => check.id === checkId);
+      const rerun = runnersById.get(checkId);
+      if (index === -1 || !rerun) {
+        continue;
+      }
+      checks3[index] = await rerun();
+    }
+  }
   const output = (deps.renderDoctor ?? renderDoctor)(report, options);
   return {
     report,
@@ -33927,6 +34563,41 @@ async function runDoctor(options = {}, deps = {}) {
     exitCode: checks3.some((check) => check.severity === "fail") ? 1 : 0
   };
 }
+async function applyRepairs(checks3) {
+  const repairs = [];
+  const repairedCheckIds = [];
+  for (const check of checks3) {
+    for (const fix of check.fixes ?? []) {
+      if (fix.withheld !== undefined) {
+        repairs.push({
+          checkId: check.id,
+          fixId: fix.id,
+          title: fix.title,
+          status: "skipped",
+          message: fix.withheld
+        });
+        continue;
+      }
+      let outcome;
+      try {
+        outcome = await fix.run();
+      } catch (error2) {
+        outcome = { ok: false, message: formatError12(error2) };
+      }
+      repairs.push({
+        checkId: check.id,
+        fixId: fix.id,
+        title: fix.title,
+        status: outcome.ok ? "applied" : "failed",
+        message: outcome.message
+      });
+      if (outcome.ok && !repairedCheckIds.includes(check.id)) {
+        repairedCheckIds.push(check.id);
+      }
+    }
+  }
+  return { repairs, repairedCheckIds };
+}
 function resolveDoctorRuntimePaths(home, resolver) {
   if (resolver) {
     return resolver();
@@ -33935,8 +34606,8 @@ function resolveDoctorRuntimePaths(home, resolver) {
     return resolveRuntimePaths();
   }
   return {
-    configPath: join19(coreHomeDir(home), "config.json"),
-    statePath: join19(coreHomeDir(home), "state.json")
+    configPath: join21(coreHomeDir(home), "config.json"),
+    statePath: join21(coreHomeDir(home), "state.json")
   };
 }
 function depsUseExplicitRuntimeOverrides() {
@@ -33976,7 +34647,7 @@ async function defaultCheckOrchestrationHealth(deps) {
       label: "Orchestration",
       severity: "skip",
       summary: "orchestration check skipped because configuration could not be loaded",
-      details: [`config path: ${deps.runtimePaths.configPath}`, `error: ${formatError9(error2)}`],
+      details: [`config path: ${deps.runtimePaths.configPath}`, `error: ${formatError12(error2)}`],
       suggestions: ["fix the Config check first, then run: xacpx doctor"]
     };
   }
@@ -33988,18 +34659,19 @@ async function defaultCheckOrchestrationHealth(deps) {
       now: () => new Date,
       heartbeatThresholdSeconds: config4.orchestration.progressHeartbeatSeconds
     });
-    return applyStateInspectionReport(result, inspection.report, deps.runtimePaths.statePath);
+    const daemonRunning = inspection.report ? await deps.isDaemonRunning() : false;
+    return applyStateInspectionReport(result, inspection.report, deps.runtimePaths.statePath, daemonRunning, deps.isDaemonRunning);
   } catch (error2) {
     return {
       id: "orchestration",
       label: "Orchestration",
       severity: "fail",
       summary: "orchestration health check failed",
-      details: [`state path: ${deps.runtimePaths.statePath}`, `error: ${formatError9(error2)}`]
+      details: [`state path: ${deps.runtimePaths.statePath}`, `error: ${formatError12(error2)}`]
     };
   }
 }
-function applyStateInspectionReport(result, report, statePath) {
+function applyStateInspectionReport(result, report, statePath, daemonRunning, isDaemonRunning) {
   if (!report) {
     return result;
   }
@@ -34017,18 +34689,74 @@ function applyStateInspectionReport(result, report, statePath) {
     suggestions: [
       ...result.suggestions ?? [],
       fileCorrupt ? "back up the state file before the next daemon start if you want to attempt manual recovery" : "the daemon backs the original file up as state.json.quarantine-* before dropping these records"
-    ]
+    ],
+    fixes: [createStateQuarantineFix(statePath, daemonRunning, isDaemonRunning)]
   };
 }
-function formatError9(error2) {
+function createStateQuarantineFix(statePath, daemonRunning, isDaemonRunning) {
+  return {
+    id: "state.quarantine",
+    title: "quarantine invalid state.json records",
+    ...daemonRunning ? { withheld: "stop the daemon first: xacpx stop" } : {},
+    run: async () => {
+      if (await isDaemonRunning()) {
+        return {
+          ok: false,
+          message: "a daemon started since detection; stop it first: xacpx stop"
+        };
+      }
+      const store = new StateStore(statePath);
+      await store.load();
+      const report = store.lastLoadReport;
+      if (!report) {
+        return { ok: true, message: "state.json was already valid; nothing to quarantine" };
+      }
+      if (report.corruptPath) {
+        return { ok: true, message: `state.json was unreadable; renamed to ${report.corruptPath} and reset` };
+      }
+      const backup = report.quarantinePath ? ` (original backed up to ${report.quarantinePath})` : "";
+      return {
+        ok: true,
+        message: `quarantined ${report.dropped.length} invalid state.json record(s)${backup}`
+      };
+    }
+  };
+}
+async function defaultIsDaemonRunning(home, runtimePaths, getDaemonStatus = () => defaultGetDaemonStatus2(home, runtimePaths)) {
+  try {
+    const status = await getDaemonStatus();
+    return status.state === "running" || status.state === "indeterminate";
+  } catch {
+    return true;
+  }
+}
+async function defaultGetDaemonStatus2(home, runtimePaths) {
+  const paths = resolveDaemonPaths({
+    home,
+    runtimeDir: resolveRuntimeDirFromConfigPath(runtimePaths.configPath)
+  });
+  const controller = createDaemonController(paths, {
+    processExecPath: process.execPath,
+    cliEntryPath: process.argv[1] ?? "",
+    cwd: process.cwd(),
+    env: process.env,
+    isProcessRunning: isProcessAlive
+  });
+  return await controller.getStatus();
+}
+function formatError12(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 var init_doctor = __esm(async () => {
   init_core_home();
   init_load_config();
+  init_create_daemon_controller();
+  init_daemon_files();
   init_state_store();
   init_daemon_check();
+  init_logs_check();
   init_orchestration_health();
+  init_orchestration_socket_check();
   init_runtime_check();
   init_wechat_check();
   init_render_doctor();
@@ -34037,6 +34765,7 @@ var init_doctor = __esm(async () => {
     init_acpx_check(),
     init_bridge_check(),
     init_config_check(),
+    init_plugin_check(),
     init_smoke_check()
   ]);
 });
@@ -34061,8 +34790,8 @@ var init_doctor2 = __esm(async () => {
 // src/cli.ts
 init_core_home();
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname14, join as join20, sep } from "node:path";
+import { homedir as homedir15 } from "node:os";
+import { dirname as dirname14, join as join22, sep } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/runtime/migrate-core-home.ts
@@ -49109,118 +49838,7 @@ import { readFile as readFile11 } from "node:fs/promises";
 import { isAbsolute, join as join13, resolve } from "node:path";
 init_plugin_loader();
 init_validate_plugin();
-
-// src/plugins/plugin-doctor.ts
-init_channel_scope();
-init_plugin_loader();
-init_validate_plugin();
-init_known_plugins();
-init_plugin_renames();
-import { readFile as readFile10 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-function suggestedPluginPackageForChannel(type) {
-  return findKnownPluginByChannel(type)?.packageName ?? `<npm-package-that-provides-${type}>`;
-}
-async function readDependencyEntries(pluginHome) {
-  try {
-    const raw = await readFile10(join12(pluginHome, "package.json"), "utf8");
-    const parsed = JSON.parse(raw);
-    const out = {};
-    for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
-      if (typeof value === "string")
-        out[name] = value;
-    }
-    return out;
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    throw new Error(`failed to read plugin home package.json: ${message}`);
-  }
-}
-async function inspectPlugins(input) {
-  const issues = [];
-  let dependencies;
-  try {
-    dependencies = await readDependencyEntries(input.pluginHome);
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return [{ level: "error", message }];
-  }
-  const importPlugin = input.importPlugin ?? importPluginFromHome;
-  const allConfigured = input.config.plugins;
-  const filterByName = input.pluginName ? normalizePluginPackageName(input.pluginName) : null;
-  if (filterByName && !allConfigured.some((plugin) => normalizePluginPackageName(plugin.name) === filterByName)) {
-    return [{ level: "error", plugin: filterByName, message: `plugin is not configured; run xacpx plugin add ${filterByName}` }];
-  }
-  const pushIfRelevant = (issue2) => {
-    if (!filterByName || issue2.plugin === filterByName)
-      issues.push(issue2);
-  };
-  const channelProviders = new Map;
-  for (const configPlugin of allConfigured) {
-    if (!(configPlugin.name in dependencies)) {
-      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `package not installed in plugin home; run xacpx plugin add ${configPlugin.name}` });
-      continue;
-    }
-    let moduleValue;
-    try {
-      moduleValue = await importPlugin(configPlugin.name, input.pluginHome);
-    } catch (error2) {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `failed to import plugin: ${message}` });
-      continue;
-    }
-    try {
-      const plugin = validateWeacpxPlugin(moduleValue, configPlugin.name, {
-        ...input.currentXacpxVersion !== undefined ? { currentXacpxVersion: input.currentXacpxVersion } : {}
-      });
-      const channels = plugin.channels ?? [];
-      const channelTypes = channels.map((channel) => channel.type);
-      for (const type of channelTypes) {
-        const existing = channelProviders.get(type);
-        if (existing) {
-          pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `channel type ${type} is already provided by ${existing.plugin}` });
-        } else {
-          channelProviders.set(type, { plugin: configPlugin.name, enabled: configPlugin.enabled });
-        }
-      }
-      pushIfRelevant({
-        level: configPlugin.enabled ? "ok" : "warn",
-        plugin: configPlugin.name,
-        message: configPlugin.enabled ? `plugin is installed and valid; channels: ${channelTypes.length > 0 ? channelTypes.join(", ") : "none"}` : `plugin is installed and valid but disabled; run xacpx plugin enable ${configPlugin.name}`
-      });
-    } catch (error2) {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      pushIfRelevant({ level: "error", plugin: configPlugin.name, message });
-    }
-  }
-  const builtInChannelTypes = new Set(listKnownChannelIds());
-  for (const channel of input.config.channels) {
-    if (channel.enabled === false)
-      continue;
-    if (builtInChannelTypes.has(channel.type))
-      continue;
-    const provider = channelProviders.get(channel.type);
-    if (!provider) {
-      if (!filterByName) {
-        issues.push({
-          level: "error",
-          message: `channel ${channel.type} is configured but no enabled plugin provides it; run xacpx plugin add ${suggestedPluginPackageForChannel(channel.type)} or another plugin that provides type "${channel.type}"`
-        });
-      }
-      continue;
-    }
-    if (!provider.enabled) {
-      pushIfRelevant({
-        level: "error",
-        plugin: provider.plugin,
-        message: `channel ${channel.type} is configured but provider plugin is disabled; run xacpx plugin enable ${provider.plugin}`
-      });
-    }
-  }
-  return issues;
-}
-
-// src/plugins/plugin-cli.ts
+init_plugin_doctor();
 init_known_plugins();
 init_plugin_renames();
 init_i18n();
@@ -50416,7 +51034,7 @@ async function createCliScheduledTaskService() {
   return new ScheduledTaskService(state, stateStore);
 }
 function resolveConfigPathForCurrentEnv() {
-  return coreEnv("CONFIG") ?? join20(coreHomeDir(requireHome2()), "config.json");
+  return coreEnv("CONFIG") ?? join22(coreHomeDir(requireHome2()), "config.json");
 }
 function resolveDaemonPathsForCurrentConfig() {
   const configPath = resolveConfigPathForCurrentEnv();
@@ -50763,7 +51381,7 @@ function decodeFirstRunOnboarding(raw) {
   return null;
 }
 function requireHome2() {
-  const home = process.env.HOME ?? homedir13();
+  const home = process.env.HOME ?? homedir15();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
@@ -50787,7 +51405,7 @@ function safeDaemonLogPaths() {
     const configPath = resolveConfigPathForCurrentEnv();
     const paths = resolveDaemonPathsForCurrentConfig();
     return {
-      appLog: join20(dirname14(configPath), "runtime", "app.log"),
+      appLog: join22(dirname14(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {
@@ -50811,6 +51429,9 @@ function parseDoctorArgs(args) {
       case "--smoke":
         options.smoke = true;
         break;
+      case "--fix":
+        options.fix = true;
+        break;
       case "--agent": {
         const value = args[index + 1];
         if (!value || value.startsWith("--")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",