mixdog 0.7.1

package/scripts/config-preserve-smoke.mjs

@@ -0,0 +1,180 @@
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// This smoke exercises config-merge preservation, not the user-data backup
+// path, so skip the backup entirely — otherwise updateSection writes real
+// backups under ~/.claude/backups/mixdog-user-data on every run. The seed
+// guard also drops `.initialized-*.json` markers into the backup ROOT (not
+// gated by the skip flag), so redirect that root into the temp dir too.
+process.env.MIXDOG_SKIP_USER_DATA_BACKUP = '1';
+
+const tmp = mkdtempSync(join(tmpdir(), 'mixdog-config-preserve-'));
+process.env.CLAUDE_PLUGIN_DATA = tmp;
+process.env.MIXDOG_USER_DATA_BACKUP_ROOT = join(tmp, 'backups');
+mkdirSync(tmp, { recursive: true });
+
+const { updateSection, readSection } = await import('../src/shared/config.mjs');
+const {
+  mergeConfig,
+  mergeAgentConfig,
+  mergeMemoryConfig,
+  mergeSearchConfig,
+  mergeEndpointConfig,
+  mergeWebhookEndpointConfig,
+} = await import('../setup/config-merge.mjs');
+
+let failed = 0;
+function assert(label, cond) {
+  const pass = !!cond;
+  process.stdout.write(`${label}: ${pass ? 'PASS' : 'FAIL'}\n`);
+  if (!pass) failed++;
+}
+
+// (a) ngrokDomain survives partial webhook save
+updateSection('channels', () => ({
+  backend: 'discord',
+  webhook: { enabled: true, ngrokDomain: 'x.ngrok-free.dev' },
+}));
+updateSection('channels', (current) => mergeConfig(current, {
+  webhook: { enabled: true, respectQuiet: false },
+}));
+const chA = readSection('channels');
+assert('webhook.ngrokDomain preserved', chA?.webhook?.ngrokDomain === 'x.ngrok-free.dev');
+assert('webhook.respectQuiet updated', chA?.webhook?.respectQuiet === false);
+
+// (d) a plaintext authtoken in the on-disk webhook is NEVER re-persisted
+// (keychain-only invariant) while ngrokDomain still survives the merge.
+updateSection('channels', () => ({
+  backend: 'discord',
+  webhook: { enabled: true, ngrokDomain: 'y.ngrok-free.dev', authtoken: 'PLAINTEXT-MUST-DROP' },
+}));
+updateSection('channels', (current) => mergeConfig(current, {
+  webhook: { enabled: true, respectQuiet: true },
+}));
+const chD = readSection('channels');
+assert('webhook plaintext authtoken stripped', chD?.webhook?.authtoken === undefined);
+assert('webhook.ngrokDomain survives authtoken strip', chD?.webhook?.ngrokDomain === 'y.ngrok-free.dev');
+
+// (b) schedules.respectQuiet sidecar survives partial schedules save
+updateSection('channels', (current) => ({
+  ...current,
+  schedules: { respectQuiet: false, customSidecar: 'keep-me' },
+}));
+updateSection('channels', (current) => mergeConfig(current, {
+  schedules: { respectQuiet: true },
+}));
+const chB = readSection('channels');
+assert('schedules.customSidecar preserved', chB?.schedules?.customSidecar === 'keep-me');
+assert('schedules.respectQuiet updated', chB?.schedules?.respectQuiet === true);
+
+// (c) agent unmanaged top-level field survives partial bridge save
+updateSection('agent', () => ({
+  customSidecar: 'agent-keep',
+  bridge: { maxWorkers: 2 },
+}));
+updateSection('agent', (current) => mergeAgentConfig(current, { bridge: { timeoutMs: 90000 } }));
+const agent = readSection('agent');
+assert('agent.customSidecar preserved', agent?.customSidecar === 'agent-keep');
+assert('agent.bridge merged', agent?.bridge?.maxWorkers === 2 && agent?.bridge?.timeoutMs === 90000);
+
+// (e) schedule endpoint config.json — REAL disk round-trip: skill sidecars
+// (timezone/mode) survive a partial UI edit-save.
+{
+  const dir = join(tmp, 'schedules', 'sched1');
+  mkdirSync(dir, { recursive: true });
+  const cfgPath = join(dir, 'config.json');
+  writeFileSync(cfgPath, JSON.stringify({ time: '09:00', days: 'daily', timezone: 'America/Chicago', mode: 'cron' }, null, 2));
+  const incoming = { time: '10:00', days: 'weekday', model: 'fast', enabled: true };
+  const merged = mergeEndpointConfig(JSON.parse(readFileSync(cfgPath, 'utf8')), incoming);
+  writeFileSync(cfgPath, JSON.stringify(merged, null, 2));
+  const after = JSON.parse(readFileSync(cfgPath, 'utf8'));
+  assert('schedule.timezone preserved (disk)', after.timezone === 'America/Chicago');
+  assert('schedule.mode preserved (disk)', after.mode === 'cron');
+  assert('schedule.time updated (disk)', after.time === '10:00');
+}
+
+// (f) webhook endpoint config.json — REAL disk round-trip: omitted secret +
+// parser survive a partial edit-save, and role stays pinned to webhook-handler.
+{
+  const dir = join(tmp, 'webhooks', 'wh1');
+  mkdirSync(dir, { recursive: true });
+  const cfgPath = join(dir, 'config.json');
+  writeFileSync(cfgPath, JSON.stringify({ secret: 'hmac-key', parser: 'github', channel: 'main', role: 'webhook-handler' }, null, 2));
+  const incoming = { channel: 'alerts', model: 'default' };
+  const merged = mergeWebhookEndpointConfig(JSON.parse(readFileSync(cfgPath, 'utf8')), incoming);
+  writeFileSync(cfgPath, JSON.stringify(merged, null, 2));
+  const after = JSON.parse(readFileSync(cfgPath, 'utf8'));
+  assert('webhook.secret preserved (disk)', after.secret === 'hmac-key');
+  assert('webhook.parser preserved (disk)', after.parser === 'github');
+  assert('webhook.channel updated (disk)', after.channel === 'alerts');
+  assert('webhook.role pinned (disk)', after.role === 'webhook-handler');
+}
+
+// (g) mergeKept hardening: a stray array/string on EITHER side never spreads
+// into numeric keys.
+{
+  const m1 = mergeEndpointConfig({ keep: 1 }, ['x']);
+  assert('mergeKept ignores array incoming', m1.keep === 1 && m1['0'] === undefined);
+  const m2 = mergeEndpointConfig(['y'], { keep: 2 });
+  assert('mergeKept ignores array existing', m2.keep === 2 && m2['0'] === undefined);
+}
+
+// (h) memory — partial save preserves providers / user / cycle1 omitted keys
+// (POST /memory/config → updateSection + mergeMemoryConfig).
+updateSection('memory', () => ({
+  providers: { openai: { model: 'gpt-4o', temperature: 0.2 } },
+  user: { name: 'Alice', title: 'Engineer' },
+  cycle1: { interval: 60, timeout: 120000, batchSize: 8 },
+}));
+updateSection('memory', (current) => mergeMemoryConfig(current, {
+  cycle1: { interval: 90 },
+}));
+const mem = readSection('memory');
+assert('memory.providers preserved', mem?.providers?.openai?.model === 'gpt-4o' && mem?.providers?.openai?.temperature === 0.2);
+assert('memory.user preserved', mem?.user?.name === 'Alice' && mem?.user?.title === 'Engineer');
+assert('memory.cycle1 omitted keys preserved', mem?.cycle1?.timeout === 120000 && mem?.cycle1?.batchSize === 8);
+assert('memory.cycle1.interval updated', mem?.cycle1?.interval === 90);
+
+// (i) search — partial save preserves provider / models / crawl omitted keys
+// (POST /search/config → updateSection + mergeSearchConfig).
+updateSection('search', () => ({
+  provider: 'tavily',
+  models: { anthropic: 'claude-haiku', openai: 'gpt-4o-mini' },
+  crawl: { enabled: true, maxDepth: 2, respectRobots: true },
+  requestTimeoutMs: 30000,
+  rawSearch: { maxResults: 8, credentials: {} },
+}));
+updateSection('search', (current) => mergeSearchConfig(current, {
+  requestTimeoutMs: 45000,
+}));
+const sr = readSection('search');
+assert('search.provider preserved', sr?.provider === 'tavily');
+assert('search.models preserved', sr?.models?.anthropic === 'claude-haiku' && sr?.models?.openai === 'gpt-4o-mini');
+assert('search.crawl preserved', sr?.crawl?.enabled === true && sr?.crawl?.maxDepth === 2 && sr?.crawl?.respectRobots === true);
+assert('search.requestTimeoutMs updated', sr?.requestTimeoutMs === 45000);
+
+// (j) channels.channelsConfig — intentional FULL REPLACE: deleting a channel in
+// the UI must drop its disk row (no stale entry); a partial save that omits
+// channelsConfig entirely must preserve the existing map (length>0 guard).
+updateSection('channels', () => ({
+  backend: 'discord',
+  channelsConfig: {
+    'chan-a': { name: 'alpha', enabled: true },
+    'chan-b': { name: 'beta', enabled: true },
+  },
+}));
+updateSection('channels', (current) => mergeConfig(current, {
+  channelsConfig: { 'chan-a': { name: 'alpha', enabled: false } },
+}));
+const chJ1 = readSection('channels');
+assert('channelsConfig deleted channel removed', chJ1?.channelsConfig?.['chan-b'] === undefined);
+assert('channelsConfig kept channel updated', chJ1?.channelsConfig?.['chan-a']?.enabled === false);
+updateSection('channels', (current) => mergeConfig(current, {
+  webhook: { enabled: true },
+}));
+const chJ2 = readSection('channels');
+assert('channelsConfig survives unrelated partial save', chJ2?.channelsConfig?.['chan-a']?.name === 'alpha');
+
+try { rmSync(tmp, { recursive: true, force: true }); } catch {}
+process.exit(failed ? 1 : 0);

package/scripts/doctor.mjs

@@ -0,0 +1,484 @@
+#!/usr/bin/env bun
+/**
+ * mixdog doctor - health diagnostics for the mixdog plugin.
+ * Usage:
+ *   bun scripts/doctor.mjs           # run checks only
+ *   bun scripts/doctor.mjs --setup   # run checks then launch setup UI
+ *
+ * Pure Node/Bun built-ins only. No external deps. Cross-OS.
+ * Exit 0 unless FAIL count > 0, then exit 1.
+ */
+import { existsSync, readFileSync, statSync, readdirSync, lstatSync } from 'fs';
+import { join, basename, dirname } from 'path';
+import { homedir, tmpdir } from 'os';
+import { spawnSync, spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { createConnection } from 'net';
+import { createRequire } from 'module';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// ---------------------------------------------------------------------------
+// Resolve PLUGIN_ROOT and PLUGIN_DATA
+// ---------------------------------------------------------------------------
+const PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT || dirname(__dirname);
+
+function resolvePluginData() {
+  if (process.env.CLAUDE_PLUGIN_DATA) return process.env.CLAUDE_PLUGIN_DATA;
+  const dirName = basename(PLUGIN_ROOT);
+  // Cache layout: <plugin>/<marketplace>/<semver>/
+  if (/^\d+\.\d+\.\d+/.test(dirName)) {
+    const pluginName = basename(join(PLUGIN_ROOT, '..'));
+    const marketplace = basename(join(PLUGIN_ROOT, '..', '..'));
+    return join(homedir(), '.claude', 'plugins', 'data', `${pluginName}-${marketplace}`);
+  }
+  // Marketplace layout: root IS the plugin dir
+  const marketplace = dirName;
+  let pluginName = 'mixdog';
+  try {
+    const manifest = JSON.parse(readFileSync(join(PLUGIN_ROOT, '.claude-plugin', 'plugin.json'), 'utf8'));
+    if (typeof manifest?.name === 'string' && manifest.name.trim()) pluginName = manifest.name.trim();
+  } catch { /* fall through */ }
+  return join(homedir(), '.claude', 'plugins', 'data', `${pluginName}-${marketplace}`);
+}
+
+const PLUGIN_DATA = resolvePluginData();
+const isSetup = process.argv.includes('--setup');
+
+// ---------------------------------------------------------------------------
+// Result tracking
+// ---------------------------------------------------------------------------
+const rows = [];
+let failCount = 0;
+let warnCount = 0;
+let okCount = 0;
+
+function addRow(status, label, detail) {
+  rows.push({ status, label, detail: detail ?? '' });
+  if (status === 'FAIL') failCount++;
+  else if (status === 'WARN') warnCount++;
+  else okCount++;
+}
+const ok   = (label, detail) => addRow('OK',   label, detail);
+const warn = (label, detail) => addRow('WARN', label, detail);
+const fail = (label, detail) => addRow('FAIL', label, detail);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function readJson(p) {
+  try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; }
+}
+
+function parsePositivePid(value) {
+  const pid = Number(value);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+
+function getActiveOwnerPid(inst) {
+  return parsePositivePid(inst?.ownerLeadPid)
+    ?? parsePositivePid(inst?.terminalLeadPid)
+    ?? parsePositivePid(inst?.supervisor_pid)
+    ?? parsePositivePid(inst?.instanceId);
+}
+
+function dirSize(p, limitBytes = Infinity) {
+  let total = 0;
+  try {
+    const entries = readdirSync(p, { withFileTypes: true });
+    for (const e of entries) {
+      if (total >= limitBytes) break;
+      const full = join(p, e.name);
+      try {
+        if (e.isDirectory()) total += dirSize(full, limitBytes - total);
+        else total += statSync(full).size;
+      } catch { /* skip inaccessible */ }
+    }
+  } catch { /* skip inaccessible dir */ }
+  return total;
+}
+
+function toMB(bytes) { return (bytes / 1024 / 1024).toFixed(1); }
+
+function semverGte(a, b) {
+  // Returns true if version string a >= b (numeric segments only)
+  const pa = a.replace(/[^0-9.]/g, '').split('.').map(Number);
+  const pb = b.replace(/[^0-9.]/g, '').split('.').map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] ?? 0, nb = pb[i] ?? 0;
+    if (na > nb) return true;
+    if (na < nb) return false;
+  }
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Check 1: Version sync (package.json vs .claude-plugin/plugin.json)
+// ---------------------------------------------------------------------------
+(function checkVersionSync() {
+  const pkgPath    = join(PLUGIN_ROOT, 'package.json');
+  const pluginPath = join(PLUGIN_ROOT, '.claude-plugin', 'plugin.json');
+  const pkg    = readJson(pkgPath);
+  const plugin = readJson(pluginPath);
+  if (!pkg)    { fail('Version sync', `cannot read ${pkgPath}`); return; }
+  if (!plugin) { fail('Version sync', `cannot read ${pluginPath}`); return; }
+  const pv = pkg.version ?? '(missing)';
+  const pjv = plugin.version ?? '(missing)';
+  if (pv === pjv) ok('Version sync', `${pv}`);
+  else fail('Version sync', `package.json=${pv} vs plugin.json=${pjv}`);
+})();
+
+// ---------------------------------------------------------------------------
+// Check 2: Bun version >= 1.1.0
+// ---------------------------------------------------------------------------
+(function checkBunVersion() {
+  // When running under bun, Bun.version is available; otherwise fall back to CLI.
+  let version = typeof Bun !== 'undefined' ? Bun.version : null;
+  if (!version) {
+    const r = spawnSync('bun', ['--version'], { encoding: 'utf8' });
+    version = (r.stdout ?? '').trim();
+  }
+  if (!version) { fail('Bun version', 'bun not found on PATH'); return; }
+  const clean = version.replace(/^v/, '');
+  if (semverGte(clean, '1.1.0')) ok('Bun version', `${clean} (>= 1.1.0)`);
+  else fail('Bun version', `${clean} < 1.1.0 - upgrade required`);
+})();
+
+// ---------------------------------------------------------------------------
+// Check 3: Bun source (system PATH vs plugin-local vs absent)
+// ---------------------------------------------------------------------------
+(function checkBunSource() {
+  const isWin = process.platform === 'win32';
+  // Try system PATH first.
+  const whichCmd = isWin ? 'where.exe' : 'which';
+  const r = spawnSync(whichCmd, ['bun'], { encoding: 'utf8' });
+  if (r.status === 0 && r.stdout) {
+    const first = r.stdout.split(/\r?\n/).map(l => l.trim()).find(l => l.length > 0);
+    if (first && existsSync(first)) { ok('Bun source', `system: ${first}`); return; }
+  }
+  // Check plugin-local node_modules/.bin/bun.
+  const localBin = join(PLUGIN_ROOT, 'node_modules', '.bin', isWin ? 'bun.exe' : 'bun');
+  if (existsSync(localBin)) { ok('Bun source', `local: ${localBin}`); return; }
+  // Not found - bootstrap will install on first launch.
+  warn('Bun source', 'not found (bootstrap will install via npm on first launch)');
+})();
+
+// ---------------------------------------------------------------------------
+// Check 4: Shell availability
+// ---------------------------------------------------------------------------
+(function checkShellSource() {
+  const isWindows = process.platform === 'win32'
+    || !!(process.env.WINDIR || process.env.SystemRoot);
+  if (!isWindows) {
+    if (existsSync('/bin/sh')) ok('Shell source', '/bin/sh');
+    else fail('Shell source', '/bin/sh not found');
+    return;
+  }
+  const explicit = process.env.CLAUDE_CODE_SHELL;
+  if (explicit) {
+    const stem = basename(explicit).toLowerCase().replace(/\.exe$/, '');
+    if (stem !== 'pwsh' && stem !== 'powershell') {
+      warn('Shell source', `CLAUDE_CODE_SHELL is ignored on Windows unless it is PowerShell/pwsh: ${explicit}`);
+    } else if (existsSync(explicit)) {
+      ok('Shell source', `PowerShell: ${explicit}`);
+      return;
+    } else {
+      warn('Shell source', `CLAUDE_CODE_SHELL set but not found: ${explicit}`);
+    }
+  }
+  const candidates = [
+    join(process.env.ProgramFiles || 'C:\\Program Files', 'PowerShell', '7', 'pwsh.exe'),
+    join(process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) { ok('Shell source', `PowerShell: ${c}`); return; }
+  }
+  const r = spawnSync('where.exe', ['powershell.exe'], { encoding: 'utf8' });
+  const found = (r.stdout || '').split(/\r?\n/).map(l => l.trim()).find(l => l && existsSync(l));
+  if (found) ok('Shell source', `PowerShell: ${found}`);
+  else fail('Shell source', 'PowerShell not found');
+})();
+
+// ---------------------------------------------------------------------------
+// Check 4: Active supervisor
+// ---------------------------------------------------------------------------
+(function checkSupervisor() {
+  const instancePath = join(tmpdir(), 'mixdog', 'active-instance.json');
+  if (!existsSync(instancePath)) {
+    warn('Supervisor', 'active-instance.json not found - supervisor not running');
+    return;
+  }
+  const inst = readJson(instancePath);
+  if (!inst) { warn('Supervisor', 'active-instance.json unreadable or invalid JSON'); return; }
+  const pid = getActiveOwnerPid(inst);
+  if (!pid) { warn('Supervisor', 'owner PID missing in active-instance.json'); return; }
+  let alive = false;
+  try { process.kill(pid, 0); alive = true; } catch { alive = false; }
+  if (!alive) { warn('Supervisor', `ownerPid=${pid} is not alive`); return; }
+  const ready = inst.backendReady === true;
+  if (ready) ok('Supervisor', `ownerPid=${pid} alive, backendReady=true`);
+  else warn('Supervisor', `ownerPid=${pid} alive but backendReady=${inst.backendReady} — permission hooks may be fail-open (bypassed) until the daemon is ready`);
+})();
+
+// ---------------------------------------------------------------------------
+// Check 4.5: Hook IPC pipe reachability (fail-open warning)
+// ---------------------------------------------------------------------------
+// Hooks are fail-open by design: if the daemon/pipe is down, the shim exits 0
+// and the server emits "null", so nothing is blocked. Surface that clearly so
+// an operator knows permission hooks are bypassed until the daemon is restored.
+// See SECURITY.md "Fail-open Hook Model".
+await (async function checkHookPipe() {
+  let pipePath;
+  try {
+    pipePath = require('../lib/hook-pipe-path.cjs')();
+  } catch (err) {
+    warn('Hook pipe', `cannot resolve pipe path: ${err?.message || String(err)}`);
+    return;
+  }
+  const reachable = await new Promise((resolve) => {
+    let done = false;
+    const finish = (val) => { if (!done) { done = true; resolve(val); } };
+    let sock;
+    try {
+      sock = createConnection(pipePath);
+    } catch { finish(false); return; }
+    const timer = setTimeout(() => { try { sock.destroy(); } catch {} finish(false); }, 1000);
+    sock.once('connect', () => { clearTimeout(timer); try { sock.destroy(); } catch {} finish(true); });
+    sock.once('error', () => { clearTimeout(timer); try { sock.destroy(); } catch {} finish(false); });
+  });
+  if (reachable) {
+    ok('Hook pipe', `reachable at ${pipePath}`);
+  } else {
+    warn('Hook pipe', `unreachable at ${pipePath} — permission hooks are FAIL-OPEN (bypassed); restart the daemon to restore them`);
+  }
+})();
+
+// ---------------------------------------------------------------------------
+// Check 5: Plugin DATA dir - required config files
+// ---------------------------------------------------------------------------
+(function checkDataDir() {
+  const configFile   = join(PLUGIN_DATA, 'mixdog-config.json');
+  const workflowFile = join(PLUGIN_DATA, 'user-workflow.json');
+  const missingFiles = [];
+  if (!existsSync(configFile))   missingFiles.push('mixdog-config.json');
+  if (!existsSync(workflowFile)) missingFiles.push('user-workflow.json');
+  if (missingFiles.length === 0) ok('Plugin DATA dir', PLUGIN_DATA);
+  else warn('Plugin DATA dir', `missing: ${missingFiles.join(', ')} in ${PLUGIN_DATA}`);
+})();
+
+// ---------------------------------------------------------------------------
+// Check 6: Cache layout - ~/.claude/plugins/cache/trib-plugin/mixdog/<ver>/
+// ---------------------------------------------------------------------------
+(function checkCacheLayout() {
+  const cacheBase = join(homedir(), '.claude', 'plugins', 'cache', 'trib-plugin', 'mixdog');
+  if (!existsSync(cacheBase)) {
+    warn('Cache layout', `cache dir not found: ${cacheBase}`);
+    return;
+  }
+  let entries;
+  try { entries = readdirSync(cacheBase, { withFileTypes: true }); } catch {
+    warn('Cache layout', `cannot read ${cacheBase}`);
+    return;
+  }
+  const verDirs = entries.filter(e => e.isDirectory());
+  if (verDirs.length === 0) { warn('Cache layout', 'no version directories found'); return; }
+
+  const THRESHOLD = 100 * 1024 * 1024; // 100 MB
+  let anyFail = false;
+  for (const vd of verDirs) {
+    const verPath = join(cacheBase, vd.name);
+    const nmPath  = join(verPath, 'node_modules');
+    if (!existsSync(nmPath)) {
+      ok(`Cache ${vd.name}`, 'no node_modules');
+      continue;
+    }
+    let isJunction = false;
+    try {
+      const lst = lstatSync(nmPath);
+      isJunction = lst.isSymbolicLink();
+    } catch { /* treat as real */ }
+    const kind = isJunction ? 'junction/symlink' : 'real';
+    if (isJunction) {
+      ok(`Cache ${vd.name}`, `node_modules=${kind}`);
+    } else {
+      const sz = dirSize(nmPath, THRESHOLD + 1);
+      const mb = toMB(sz);
+      if (sz > THRESHOLD) {
+        warn(`Cache ${vd.name}`, `node_modules=${kind} ${mb} MB (> 100 MB - regression risk)`);
+        anyFail = true;
+      } else {
+        ok(`Cache ${vd.name}`, `node_modules=${kind} ${mb} MB`);
+      }
+    }
+  }
+})();
+
+// ---------------------------------------------------------------------------
+// Check 7: Voice runtime
+// ---------------------------------------------------------------------------
+await (async function checkVoiceRuntime() {
+  try {
+    const { resolveVoiceRuntime } = await import('../src/channels/lib/voice-runtime-fetcher.mjs');
+    const runtime = resolveVoiceRuntime(PLUGIN_DATA);
+    if (runtime?.installed) {
+      ok('Voice runtime', `${runtime.kind}: whisper=${basename(runtime.whisperCmd || '')}, ffmpeg=${basename(runtime.ffmpegPath || '')}, model=${runtime.modelName || basename(runtime.modelPath || '')}`);
+      return;
+    }
+    const missing = [
+      runtime?.binary ? null : 'binary',
+      runtime?.model ? null : 'model',
+      runtime?.ffmpeg ? null : 'ffmpeg',
+    ].filter(Boolean);
+    warn('Voice runtime', `not installed - missing: ${missing.join(', ')}`);
+  } catch (err) {
+    warn('Voice runtime', `check failed: ${err?.message || String(err)}`);
+  }
+})();
+
+// ---------------------------------------------------------------------------
+// Check 8: Required npm dependencies
+// ---------------------------------------------------------------------------
+(function checkDeps() {
+  const required = [
+    '@modelcontextprotocol/sdk',
+    'zod',
+    'openai',
+    'pg',
+  ];
+  // Search in PLUGIN_ROOT/node_modules (typical) and parent cache node_modules.
+  const nmCandidates = [
+    join(PLUGIN_ROOT, 'node_modules'),
+    join(PLUGIN_ROOT, '..', 'node_modules'),
+  ];
+  const missing = [];
+  for (const dep of required) {
+    const found = nmCandidates.some(nm => existsSync(join(nm, dep)));
+    if (!found) missing.push(dep);
+  }
+  if (missing.length === 0) ok('Required deps', required.join(', '));
+  else fail('Required deps', `missing: ${missing.join(', ')}`);
+})();
+
+// ---------------------------------------------------------------------------
+// Check 9.5: Cache / sidecar storage sizes
+// ---------------------------------------------------------------------------
+(function checkCacheStorage() {
+  const targets = [
+    { p: join(PLUGIN_DATA, 'code-graph-cache.json'), label: 'code-graph-cache.json' },
+    { p: join(PLUGIN_DATA, 'code-graph-cache'),      label: 'code-graph-cache/' },
+    { p: join(PLUGIN_DATA, 'sidecars'),              label: 'sidecars/' },
+    { p: join(PLUGIN_DATA, 'sessions-archive'),      label: 'sessions-archive/' },
+    { p: join(PLUGIN_DATA, 'shell-output'),          label: 'shell-output/' },
+    { p: join(PLUGIN_DATA, 'shell-jobs'),            label: 'shell-jobs/' },
+  ];
+  const WARN_THRESHOLD = 100 * 1024 * 1024; // 100 MB per target
+  const lines = [];
+  const oversized = [];
+  for (const { p, label } of targets) {
+    if (!existsSync(p)) continue;
+    let sz = 0;
+    try {
+      const st = statSync(p);
+      sz = st.isDirectory() ? dirSize(p, WARN_THRESHOLD * 2 + 1) : st.size;
+    } catch { continue; }
+    if (sz === 0) continue;
+    const mb = toMB(sz);
+    lines.push(`${label}=${mb} MB`);
+    if (sz > WARN_THRESHOLD) oversized.push(`${label} ${mb} MB`);
+  }
+  if (lines.length === 0) ok('Cache storage', 'no cache artefacts');
+  else if (oversized.length > 0) warn('Cache storage', `oversized (> 100 MB): ${oversized.join(', ')} | all: ${lines.join(', ')}`);
+  else ok('Cache storage', lines.join(', '));
+})();
+
+// ---------------------------------------------------------------------------
+// Check 9: Log file sizes
+// ---------------------------------------------------------------------------
+(function checkLogs() {
+  const WARN_THRESHOLD = 50 * 1024 * 1024; // 50 MB
+  let logEntries;
+  try {
+    logEntries = readdirSync(PLUGIN_DATA, { withFileTypes: true })
+      .filter(e => e.isFile() && e.name.endsWith('.log'));
+  } catch {
+    ok('Logs', 'data dir not yet created or no log files');
+    return;
+  }
+  if (logEntries.length === 0) { ok('Logs', 'no log files'); return; }
+  const large = [];
+  const lines = [];
+  for (const e of logEntries) {
+    const p = join(PLUGIN_DATA, e.name);
+    let sz = 0;
+    try { sz = statSync(p).size; } catch { /* skip */ }
+    const mb = toMB(sz);
+    lines.push({ name: e.name, size: sz, text: `${e.name}=${mb} MB` });
+    if (sz > WARN_THRESHOLD) large.push(`${e.name} ${mb} MB`);
+  }
+  if (large.length > 0) warn('Logs', `oversized (> 50 MB): ${large.join(', ')}`);
+  else if (lines.length > 300) warn('Logs', `${lines.length} files (> 300) — likely stale per-PID log accumulation`);
+  else {
+    lines.sort((a, b) => b.size - a.size);
+    const shown = lines.slice(0, 8).map(e => e.text);
+    const suffix = lines.length > shown.length ? `, +${lines.length - shown.length} more` : '';
+    ok('Logs', `${lines.length} files; largest: ${shown.join(', ')}${suffix}`);
+  }
+})();
+
+// ---------------------------------------------------------------------------
+// Check 9.7: Memory DB size (Postgres pgdata)
+// ---------------------------------------------------------------------------
+(function checkMemoryDbSize() {
+  const pgdata = join(PLUGIN_DATA, 'pgdata');
+  if (!existsSync(pgdata)) { ok('Memory DB size', 'pgdata not found'); return; }
+  const WARN_THRESHOLD = 1024 * 1024 * 1024; // 1 GB
+  let total = 0;
+  try { total = dirSize(pgdata); } catch { warn('Memory DB size', `cannot read ${pgdata}`); return; }
+  const baseBytes = existsSync(join(pgdata, 'base')) ? dirSize(join(pgdata, 'base')) : 0;
+  const walBytes  = existsSync(join(pgdata, 'pg_wal')) ? dirSize(join(pgdata, 'pg_wal')) : 0;
+  const detail = `pgdata ${toMB(total)} MB (base ${toMB(baseBytes)}, wal ${toMB(walBytes)})`;
+  if (total >= WARN_THRESHOLD) warn('Memory DB size', `${detail} — >= 1 GB, review memory retention`);
+  else ok('Memory DB size', detail);
+})();
+
+// ---------------------------------------------------------------------------
+// Print report
+// ---------------------------------------------------------------------------
+const SEP = '-'.repeat(62);
+console.log('');
+console.log('mixdog doctor');
+console.log(SEP);
+for (const { status, label, detail } of rows) {
+  const tag = `[${status}]`.padEnd(6);
+  console.log(`${tag} ${label}${detail ? ': ' + detail : ''}`);
+}
+console.log(SEP);
+console.log(`${okCount} OK  ${warnCount} WARN  ${failCount} FAIL`);
+console.log('');
+
+// ---------------------------------------------------------------------------
+// --setup: launch setup UI after report
+// ---------------------------------------------------------------------------
+if (isSetup) {
+  const launchScript = join(PLUGIN_ROOT, 'setup', 'launch.mjs');
+  if (!existsSync(launchScript)) {
+    console.error(`[FAIL] setup launcher not found: ${launchScript}`);
+    process.exit(1);
+  }
+  console.log('Launching setup UI...');
+  const child = spawn(process.execPath, [launchScript], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: PLUGIN_ROOT,
+    windowsHide: true,
+    env: {
+      ...process.env,
+      CLAUDE_PLUGIN_ROOT: PLUGIN_ROOT,
+      CLAUDE_PLUGIN_DATA: PLUGIN_DATA,
+    },
+  });
+  child.unref();
+}
+
+process.exit(failCount > 0 ? 1 : 0);