mixdog 0.9.20 → 0.9.22

package/src/tui/dist/index.mjs

@@ -158,7 +158,7 @@ import React21 from "react";
 import { render } from "../../../vendor/ink/build/index.js";
 import { closeSync as closeSync2, constants as fsConstants, createWriteStream, mkdirSync as mkdirSync7, openSync as openSync2, readSync } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname7, join as join9 } from "node:path";
+import { dirname as dirname9, join as join11 } from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 
 // src/tui/App.jsx
@@ -7509,7 +7509,10 @@ namespace Mixdog {
   }
 }
 '@`,
-    "Add-Type -TypeDefinition $code -ReferencedAssemblies System.Windows.Forms | Out-Null",
+    // System.Drawing is required too: GetDialogOwnerCenter uses
+    // Screen.PrimaryScreen.WorkingArea (System.Drawing.Rectangle) — without it
+    // the Add-Type compile fails and the dialog silently falls back to typing.
+    "Add-Type -TypeDefinition $code -ReferencedAssemblies System.Windows.Forms,System.Drawing | Out-Null",
     // Invisible TopMost owner anchored to the TUI console (or foreground window)
     // so IFileOpenDialog is modal, centered, and not detached on another monitor.
     "$owner = New-Object System.Windows.Forms.Form",
@@ -7682,6 +7685,7 @@ var SLASH_COMMANDS = [
   { name: "settings", usage: "/setting", aliases: ["setting", "config"], aliasUsage: ["settings", "config"], showAliasUsage: false, description: "Open runtime settings" },
   { name: "profile", usage: "/profile", description: "Set your title and response language" },
   { name: "update", usage: "/update", description: "Check version and update mixdog" },
+  { name: "doctor", usage: "/doctor", description: "Diagnose installation health" },
   { name: "quit", usage: "/quit", aliases: ["exit", "q"], aliasUsage: ["exit", "q"], description: "Quit the TUI" }
 ];
 function slashQuery(value) {
@@ -13733,6 +13737,7 @@ var RETRY_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY", "EEXIST"]
 var LOCK_WAIT_CODES = /* @__PURE__ */ new Set(["EEXIST", "EPERM", "EACCES", "EBUSY"]);
 var DEFAULT_BACKOFFS_MS = Object.freeze([25, 50, 100, 200, 400, 800, 1200, 1600]);
 var DEFAULT_LOCK_TIMEOUT_MS = 8e3;
+var _OWNER_TOKEN = randomBytes2(12).toString("hex");
 function sleepSync(ms) {
   try {
     const buf = new SharedArrayBuffer(4);
@@ -13780,34 +13785,7 @@ function withFileLockSync(lockPath, fn, opts = {}) {
         throw contErr;
       }
       try {
-        const st = statSync2(lockPath);
-        const ownerPidEarly = _readLockOwnerPid(lockPath);
-        const ownerDead = ownerPidEarly !== null && _pidIsDead(ownerPidEarly);
-        if (ownerDead || Date.now() - st.mtimeMs > staleMs) {
-          const deadPid = ownerPidEarly;
-          if (ownerDead) {
-            const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
-            if (reclaim !== null) {
-              let reclaimed = false;
-              try {
-                const currentSt = statSync2(lockPath);
-                if (ownerDead || Date.now() - currentSt.mtimeMs > staleMs) {
-                  const currentPid = _readLockOwnerPid(lockPath);
-                  if (currentPid === deadPid && _pidIsDead(currentPid)) {
-                    try {
-                      unlinkSync2(lockPath);
-                      reclaimed = true;
-                    } catch {
-                    }
-                  }
-                }
-              } finally {
-                _releaseReclaimGuard(reclaim);
-              }
-              if (reclaimed) continue;
-            }
-          }
-        }
+        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
       } catch {
       }
       if (Date.now() >= deadline) break;
@@ -13818,7 +13796,7 @@ function withFileLockSync(lockPath, fn, opts = {}) {
       continue;
     }
     try {
-      writeFileSync2(fd, `${process.pid} ${Date.now()}
+      writeFileSync2(fd, `${process.pid} ${Date.now()} ${_OWNER_TOKEN}
 `, "utf8");
     } catch {
     }
@@ -13831,7 +13809,7 @@ function withFileLockSync(lockPath, fn, opts = {}) {
       } catch {
       }
       try {
-        if (_lockOwnedByPid(lockPath, process.pid)) unlinkSync2(lockPath);
+        if (_lockOwnedBySelf(lockPath)) unlinkSync2(lockPath);
       } catch {
       }
     }
@@ -13861,8 +13839,77 @@ function _pidIsDead(pid) {
     return err?.code === "ESRCH";
   }
 }
-function _lockOwnedByPid(lockPath, pid) {
-  return _readLockOwnerPid(lockPath) === pid;
+function _readLockOwner(lockPath) {
+  try {
+    const raw = readFileSync2(lockPath, "utf8");
+    const parts = String(raw).trim().split(/\s+/);
+    const pid = Number.parseInt(parts[0], 10);
+    return {
+      pid: Number.isFinite(pid) && pid > 0 ? pid : null,
+      token: parts.length >= 3 ? parts[2] : null
+    };
+  } catch {
+    return { pid: null, token: null };
+  }
+}
+function _ownerIsLive(owner) {
+  if (owner.pid === null) return false;
+  if (owner.pid === process.pid) return true;
+  try {
+    process.kill(owner.pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code !== "ESRCH";
+  }
+}
+function _ownerIsSelfForeign(owner) {
+  return owner.pid === process.pid && owner.token !== null && owner.token !== _OWNER_TOKEN;
+}
+function _lockOwnedBySelf(lockPath) {
+  const owner = _readLockOwner(lockPath);
+  if (owner.pid !== process.pid) return false;
+  return owner.token === null ? true : owner.token === _OWNER_TOKEN;
+}
+function _tryReclaimStaleLock(lockPath, staleMs) {
+  let st;
+  try {
+    st = statSync2(lockPath);
+  } catch {
+    return false;
+  }
+  const owner = _readLockOwner(lockPath);
+  const stale = Date.now() - st.mtimeMs > staleMs;
+  const dead = owner.pid !== null && !_ownerIsLive(owner);
+  const pidless = owner.pid === null;
+  const selfForeign = _ownerIsSelfForeign(owner);
+  if (!dead && !((pidless || selfForeign) && stale)) return false;
+  const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
+  if (reclaim === null) return false;
+  try {
+    let cur;
+    try {
+      cur = statSync2(lockPath);
+    } catch {
+      return false;
+    }
+    const curOwner = _readLockOwner(lockPath);
+    if (curOwner.pid !== owner.pid || curOwner.token !== owner.token) return false;
+    const curStale = Date.now() - cur.mtimeMs > staleMs;
+    const curDead = curOwner.pid !== null && !_ownerIsLive(curOwner);
+    const curPidless = curOwner.pid === null;
+    const curSelfForeign = _ownerIsSelfForeign(curOwner);
+    if (curDead || (curPidless || curSelfForeign) && curStale) {
+      try {
+        unlinkSync2(lockPath);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  } finally {
+    _releaseReclaimGuard(reclaim);
+  }
 }
 function _reclaimGuardIsUnreadableAndStale(guardPath, staleMs) {
   if (_readLockOwnerPid(guardPath) !== null) return false;
@@ -13880,8 +13927,21 @@ function _reclaimGuardMatchesToken(guardPath, token) {
     return false;
   }
 }
-function _unlinkReclaimGuardIfPidMatches(guardPath, pid) {
-  if (_readLockOwnerPid(guardPath) !== pid) return false;
+function _readGuardContent(guardPath) {
+  try {
+    return readFileSync2(guardPath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function _parseStampPid(raw) {
+  if (raw === null) return null;
+  const tok = String(raw).trim().split(/\s+/)[0];
+  const pid = Number.parseInt(tok, 10);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+function _unlinkReclaimGuardIfContentMatches(guardPath, content) {
+  if (_readGuardContent(guardPath) !== content) return false;
   try {
     unlinkSync2(guardPath);
     return true;
@@ -13899,9 +13959,17 @@ function _unlinkUnreadableStaleReclaimGuard(guardPath, staleMs) {
   }
 }
 function _tryClearStaleReclaimGuard(guardPath, staleMs) {
-  const guardPid = _readLockOwnerPid(guardPath);
+  const guardContent = _readGuardContent(guardPath);
+  const guardPid = _parseStampPid(guardContent);
   if (guardPid !== null) {
-    if (_pidIsDead(guardPid)) _unlinkReclaimGuardIfPidMatches(guardPath, guardPid);
+    let guardStale = false;
+    try {
+      guardStale = Date.now() - statSync2(guardPath).mtimeMs > staleMs;
+    } catch {
+    }
+    if (_pidIsDead(guardPid) || guardStale) {
+      _unlinkReclaimGuardIfContentMatches(guardPath, guardContent);
+    }
     return;
   }
   _unlinkUnreadableStaleReclaimGuard(guardPath, staleMs);
@@ -13963,32 +14031,7 @@ async function withFileLock(lockPath, fn, opts = {}) {
         throw contErr;
       }
       try {
-        const st = statSync2(lockPath);
-        if (Date.now() - st.mtimeMs > staleMs) {
-          const deadPid = _readLockOwnerPid(lockPath);
-          if (deadPid !== null && _pidIsDead(deadPid)) {
-            const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
-            if (reclaim !== null) {
-              let reclaimed = false;
-              try {
-                const currentSt = statSync2(lockPath);
-                if (Date.now() - currentSt.mtimeMs > staleMs) {
-                  const currentPid = _readLockOwnerPid(lockPath);
-                  if (currentPid === deadPid && _pidIsDead(currentPid)) {
-                    try {
-                      unlinkSync2(lockPath);
-                      reclaimed = true;
-                    } catch {
-                    }
-                  }
-                }
-              } finally {
-                _releaseReclaimGuard(reclaim);
-              }
-              if (reclaimed) continue;
-            }
-          }
-        }
+        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
       } catch {
       }
       if (Date.now() >= deadline) break;
@@ -13999,7 +14042,7 @@ async function withFileLock(lockPath, fn, opts = {}) {
       continue;
     }
     try {
-      writeFileSync2(fd, `${process.pid} ${Date.now()}
+      writeFileSync2(fd, `${process.pid} ${Date.now()} ${_OWNER_TOKEN}
 `, "utf8");
     } catch {
     }
@@ -14012,7 +14055,7 @@ async function withFileLock(lockPath, fn, opts = {}) {
       } catch {
       }
       try {
-        if (_lockOwnedByPid(lockPath, process.pid)) unlinkSync2(lockPath);
+        if (_lockOwnedBySelf(lockPath)) unlinkSync2(lockPath);
       } catch {
       }
     }
@@ -16808,6 +16851,7 @@ function createSlashDispatch({
   openContextPicker,
   openProfilePicker,
   openUpdatePicker,
+  runDoctor,
   requestExit
 }) {
   const runSlashCommand = (cmd, arg = "") => {
@@ -17123,6 +17167,13 @@ function createSlashDispatch({
       case "update":
         openUpdatePicker();
         return true;
+      case "doctor":
+        if (state.commandBusy) {
+          store.pushNotice("wait for the current command to finish before /doctor", "warn");
+          return false;
+        }
+        void Promise.resolve(runDoctor?.()).catch((e) => store.pushNotice(`doctor failed: ${e?.message || e}`, "error"));
+        return true;
       case "quit":
         requestExit();
         return true;
@@ -18980,6 +19031,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
     openContextPicker: (...a) => openContextPicker(...a),
     openProfilePicker: (...a) => openProfilePicker(...a),
     openUpdatePicker: (...a) => openUpdatePicker(...a),
+    runDoctor: (...a) => store.runDoctor?.(...a),
     requestExit: (...a) => requestExit(...a)
   });
   const promptHintTimerRef = useRef9(null);
@@ -24441,6 +24493,178 @@ function createEngineApiB(bag) {
   };
 }
 
+// src/runtime/shared/update-checker.mjs
+import { dirname as dirname7, join as join8 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var PACKAGE_NAME = "mixdog";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var _MODULE_DIR = dirname7(fileURLToPath2(import.meta.url));
+var _PACKAGE_JSON_PATH = join8(_MODULE_DIR, "..", "..", "..", "package.json");
+function parseSemver(value) {
+  const text = String(value || "").trim().replace(/^v/i, "");
+  const [core, ...preParts] = text.split("-");
+  const parts = core.split(".").map((n) => {
+    const num2 = Number.parseInt(n, 10);
+    return Number.isFinite(num2) ? num2 : 0;
+  });
+  while (parts.length < 3) parts.push(0);
+  return { parts, prerelease: preParts.join("-") };
+}
+function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa.parts[i] || 0) - (pb.parts[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  if (pa.prerelease && !pb.prerelease) return -1;
+  if (!pa.prerelease && pb.prerelease) return 1;
+  if (pa.prerelease !== pb.prerelease) return pa.prerelease < pb.prerelease ? -1 : 1;
+  return 0;
+}
+
+// src/tui/app/doctor.mjs
+import { readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname8, join as join9 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var GLYPH = { ok: "\u2713", warn: "\u26A0", fail: "\u2717" };
+function readPackageJson() {
+  try {
+    const dir = dirname8(fileURLToPath3(import.meta.url));
+    const raw = JSON.parse(readFileSync6(join9(dir, "..", "..", "..", "package.json"), "utf8"));
+    return raw && typeof raw === "object" ? raw : null;
+  } catch {
+    return null;
+  }
+}
+async function buildDoctorReport(runtime = {}, getState = () => ({})) {
+  const rows = [];
+  const check = async (label, fn) => {
+    const row = (level, detail) => {
+      rows.push(`${GLYPH[level] || GLYPH.warn} ${label}: ${detail}`);
+    };
+    try {
+      await fn(row);
+    } catch (e) {
+      row("fail", `check failed: ${e?.message || e}`);
+    }
+  };
+  const pkg = readPackageJson();
+  await check("mixdog", async (row) => {
+    const upd = await runtime.checkForUpdate?.({}) || {};
+    const current = upd.currentVersion || pkg?.version || "unknown";
+    const latest = upd.latestVersion;
+    if (latest == null) {
+      row("warn", `v${current} \xB7 update check skipped (registry unreachable)`);
+      return;
+    }
+    if (upd.updateAvailable) row("warn", `v${current} \xB7 update available \u2192 v${latest}`);
+    else row("ok", `v${current} \xB7 up to date`);
+  });
+  await check("node", async (row) => {
+    const nodeVer = process.versions?.node || "0.0.0";
+    const engines = pkg?.engines?.node;
+    if (!engines) {
+      row("ok", `v${nodeVer}`);
+      return;
+    }
+    const m = String(engines).match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!m) {
+      row("warn", `v${nodeVer} \xB7 engines "${engines}" unparsed`);
+      return;
+    }
+    const required = `${m[1]}.${m[2] || 0}.${m[3] || 0}`;
+    const ok = compareSemver(nodeVer, required) >= 0;
+    row(ok ? "ok" : "fail", `v${nodeVer} \xB7 requires node ${engines}`);
+  });
+  await check("providers", async (row) => {
+    const setup = await runtime.getProviderSetup?.() || {};
+    const lists = [...setup.api || [], ...setup.oauth || [], ...setup.local || []];
+    const isAuthed = (p) => Boolean(p && (p.authenticated || p.enabled || p.detected));
+    const authed = lists.filter(isAuthed);
+    const active = getState()?.provider || "";
+    const activeEntry = active ? lists.find((p) => p.id === active) : null;
+    if (activeEntry && !isAuthed(activeEntry)) {
+      row("fail", `route ${active} has no auth \xB7 ${authed.length} configured`);
+      return;
+    }
+    if (active && !activeEntry) {
+      row("warn", `${authed.length} authed \xB7 route ${active} (not listed)`);
+      return;
+    }
+    row("ok", `${authed.length} authed \xB7 route ${active || "unknown"}`);
+  });
+  await check("mcp", async (row) => {
+    const m = runtime.mcpStatus?.() || {};
+    const servers = Array.isArray(m.servers) ? m.servers : [];
+    const conn = Number(m.connectedCount || 0);
+    const conf = Number(m.configuredCount || 0);
+    if (conf === 0) {
+      row("ok", "no servers configured");
+      return;
+    }
+    const failed = servers.filter((s) => s && (s.error || s.status === "failed")).map((s) => s.name || s.id).filter(Boolean);
+    const detail = `${conn}/${conf} connected${failed.length ? ` \xB7 failed: ${failed.join(", ")}` : ""}`;
+    row(failed.length || conn < conf ? "warn" : "ok", detail);
+  });
+  await check("memory", async (row) => {
+    const mem = runtime.getMemorySettings?.() || {};
+    const enabled = mem.enabled !== false;
+    let detail = enabled ? "enabled" : "disabled";
+    if (mem.backend) detail += ` \xB7 backend ${mem.backend}`;
+    const health = mem.backendHealth || mem.health;
+    if (health != null) {
+      detail += ` \xB7 ${typeof health === "string" ? health : health.ok ? "healthy" : "unhealthy"}`;
+    }
+    row(enabled ? "ok" : "warn", detail);
+  });
+  await check("channels", async (row) => {
+    const settings = runtime.getChannelSettings?.({ includeStatus: true }) || {};
+    const enabled = settings.enabled !== false;
+    if (!enabled) {
+      row("ok", "disabled");
+      return;
+    }
+    const worker = settings.status || runtime.getChannelWorkerStatus?.() || {};
+    const setup = runtime.getChannelSetup?.() || {};
+    const tokens = [];
+    if (setup.discord?.authenticated) tokens.push("discord");
+    if (setup.telegram?.authenticated) tokens.push("telegram");
+    if (setup.webhook?.authenticated) tokens.push("webhook");
+    const running = worker.running === true;
+    const detail = `enabled \xB7 worker ${running ? "running" : "stopped"} \xB7 tokens: ${tokens.length ? tokens.join(", ") : "none"}`;
+    row(running ? "ok" : "warn", detail);
+  });
+  await check("skills", async (row) => {
+    const s = runtime.skillsStatus?.() || {};
+    const skills = Array.isArray(s.skills) ? s.skills : [];
+    const broken = skills.filter((x) => x && (x.broken || x.error || x.invalid));
+    const disabled = skills.filter((x) => x && x.disabled);
+    let detail = `${s.count ?? skills.length} available`;
+    if (disabled.length) detail += ` \xB7 ${disabled.length} disabled`;
+    if (broken.length) detail += ` \xB7 broken: ${broken.map((x) => x.name || x.id).filter(Boolean).join(", ")}`;
+    row(broken.length ? "warn" : "ok", detail);
+  });
+  await check("plugins", async (row) => {
+    const p = runtime.pluginsStatus?.() || {};
+    const plugins = Array.isArray(p.plugins) ? p.plugins : [];
+    const broken = plugins.filter((x) => x && (x.broken || x.error));
+    const disabled = plugins.filter((x) => x && x.disabled);
+    let detail = `${p.count ?? plugins.length} detected`;
+    if (disabled.length) detail += ` \xB7 ${disabled.length} disabled`;
+    if (broken.length) detail += ` \xB7 broken: ${broken.map((x) => x.title || x.name || x.id).filter(Boolean).join(", ")}`;
+    row(broken.length ? "warn" : "ok", detail);
+  });
+  await check("hooks", async (row) => {
+    const h = runtime.hooksStatus?.() || {};
+    const events = Array.isArray(h.events) ? h.events : [];
+    const enabled = h.enabled === true;
+    row("ok", `${enabled ? "enabled" : "disabled"} \xB7 ${events.length} event${events.length === 1 ? "" : "s"}`);
+  });
+  return ["mixdog doctor \u2014 installation health", ...rows].join("\n");
+}
+
 // src/tui/engine/session-api.mjs
 function createEngineApi(bag) {
   return { ...createEngineApiA(bag), ...createEngineApiB(bag) };
@@ -24883,6 +25107,22 @@ function createEngineApiA(bag) {
         set({ commandBusy: false, commandStatus: null });
       }
     },
+    runDoctor: async () => {
+      if (getState().commandBusy) return null;
+      const startedAt = Date.now();
+      set({ commandBusy: true, commandStatus: { active: true, verb: "Running diagnostics", startedAt, mode: "doctor" } });
+      try {
+        await new Promise((resolve6) => setTimeout(resolve6, 0));
+        const report = await buildDoctorReport(runtime, getState);
+        pushNotice(report, "info");
+        return report;
+      } catch (e) {
+        pushNotice(`doctor failed: ${e?.message || e}`, "error");
+        return null;
+      } finally {
+        set({ commandBusy: false, commandStatus: null });
+      }
+    },
     compact: async () => {
       if (getState().commandBusy) return null;
       if (getState().busy) {
@@ -25512,18 +25752,18 @@ function installProcessSignalCleanup({
 
 // src/runtime/channels/lib/runtime-paths.mjs
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename4, join as join8, resolve as resolve5 } from "path";
+import { basename as basename4, join as join10, resolve as resolve5 } from "path";
 
 // src/runtime/channels/lib/state-file.mjs
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
 function ensureDir2(dirPath) {
   mkdirSync6(dirPath, { recursive: true });
 }
 
 // src/runtime/channels/lib/runtime-paths.mjs
-var RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT ? resolve5(process.env.MIXDOG_RUNTIME_ROOT) : join8(tmpdir2(), "mixdog");
-var OWNER_DIR = join8(RUNTIME_ROOT, "owners");
-var ACTIVE_INSTANCE_FILE = join8(RUNTIME_ROOT, "active-instance.json");
+var RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT ? resolve5(process.env.MIXDOG_RUNTIME_ROOT) : join10(tmpdir2(), "mixdog");
+var OWNER_DIR = join10(RUNTIME_ROOT, "owners");
+var ACTIVE_INSTANCE_FILE = join10(RUNTIME_ROOT, "active-instance.json");
 var RUNTIME_STALE_TTL = 24 * 60 * 60 * 1e3;
 var STATUS_FILE_TTL = 6 * 60 * 60 * 1e3;
 var TMP_FILE_TTL = 60 * 60 * 1e3;
@@ -25546,7 +25786,7 @@ function touchUiHeartbeat(instanceId) {
   } catch {
   }
 }
-var SERVER_PID_FILE = join8(
+var SERVER_PID_FILE = join10(
   RUNTIME_ROOT,
   `server-${sanitize(resolvePluginData() ?? "default")}.pid`
 );
@@ -25766,7 +26006,7 @@ function scheduleHardExit(code = 0) {
   timer.unref?.();
 }
 function resolveTuiStderrLogPath() {
-  return process.env.MIXDOG_TUI_STDERR_LOG || join9(process.env.MIXDOG_RUNTIME_ROOT || join9(tmpdir3(), "mixdog"), "mixdog-tui.stderr.log");
+  return process.env.MIXDOG_TUI_STDERR_LOG || join11(process.env.MIXDOG_RUNTIME_ROOT || join11(tmpdir3(), "mixdog"), "mixdog-tui.stderr.log");
 }
 function ansiFg(rgb) {
   const m = /rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(String(rgb || ""));
@@ -25848,7 +26088,7 @@ function installTuiStderrGuard() {
   const originalWrite = process.stderr.write.bind(process.stderr);
   const logPath = resolveTuiStderrLogPath();
   try {
-    mkdirSync7(dirname7(logPath), { recursive: true });
+    mkdirSync7(dirname9(logPath), { recursive: true });
   } catch {
   }
   (0, import_mixdog_debug.rotateBoundedLog)(logPath, import_mixdog_debug.PLUGIN_LOG_MAX_BYTES, import_mixdog_debug.PLUGIN_LOG_KEEP_BYTES);

package/src/tui/engine/session-api.mjs

@@ -5,6 +5,7 @@ import { compactEventDetail, projectNameFromPath } from './labels.mjs';
 import { toolErrorDisplay } from './tool-result-text.mjs';
 import { isQueuedEntryEditable, promptDisplayText } from './queue-helpers.mjs';
 import { createEngineApiB } from './session-api-ext.mjs';
+import { buildDoctorReport } from '../app/doctor.mjs';
 
 export function createEngineApi(bag) {
   return { ...createEngineApiA(bag), ...createEngineApiB(bag) };
@@ -444,6 +445,24 @@ export function createEngineApiA(bag) {
         set({ commandBusy: false, commandStatus: null });
       }
     },
+    runDoctor: async () => {
+      if (getState().commandBusy) return null;
+      const startedAt = Date.now();
+      set({ commandBusy: true, commandStatus: { active: true, verb: 'Running diagnostics', startedAt, mode: 'doctor' } });
+      try {
+        // Yield one event-loop turn so Ink paints the running indicator before
+        // the (mostly synchronous) health checks run — same pattern as compact.
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const report = await buildDoctorReport(runtime, getState);
+        pushNotice(report, 'info');
+        return report;
+      } catch (e) {
+        pushNotice(`doctor failed: ${e?.message || e}`, 'error');
+        return null;
+      } finally {
+        set({ commandBusy: false, commandStatus: null });
+      }
+    },
     compact: async () => {
       if (getState().commandBusy) return null;
       if (getState().busy) {