tandem-editor 0.13.0 → 0.13.6

package/dist/cli/index.js

@@ -370,10 +370,11 @@ var init_skill_content = __esm({
 });
 
 // src/shared/constants.ts
-var DEFAULT_MCP_PORT, TANDEM_REPO_URL, TANDEM_ISSUES_NEW_URL, MAX_FILE_SIZE, SESSION_MAX_AGE, TANDEM_MODE_DEFAULT, CHANNEL_MAX_RETRIES, CHANNEL_RETRY_DELAY_MS, CHANNEL_CONNECT_FETCH_TIMEOUT_MS, CHANNEL_SSE_INACTIVITY_TIMEOUT_MS, CHANNEL_MODE_FETCH_TIMEOUT_MS, CHANNEL_AWARENESS_FETCH_TIMEOUT_MS, CHANNEL_ERROR_REPORT_TIMEOUT_MS, CHANNEL_REPLY_FETCH_TIMEOUT_MS, CHANNEL_PERMISSION_FETCH_TIMEOUT_MS, CHANNEL_MAX_SSE_BUFFER_BYTES, TOKEN_FILE_NAME;
+var DEFAULT_WS_PORT, DEFAULT_MCP_PORT, TANDEM_REPO_URL, TANDEM_ISSUES_NEW_URL, MAX_FILE_SIZE, SESSION_MAX_AGE, TANDEM_MODE_DEFAULT, CHANNEL_MAX_RETRIES, CHANNEL_RETRY_DELAY_MS, CHANNEL_CONNECT_FETCH_TIMEOUT_MS, CHANNEL_SSE_INACTIVITY_TIMEOUT_MS, CHANNEL_MODE_FETCH_TIMEOUT_MS, CHANNEL_AWARENESS_FETCH_TIMEOUT_MS, CHANNEL_ERROR_REPORT_TIMEOUT_MS, CHANNEL_REPLY_FETCH_TIMEOUT_MS, CHANNEL_PERMISSION_FETCH_TIMEOUT_MS, CHANNEL_MAX_SSE_BUFFER_BYTES, TOKEN_FILE_NAME;
 var init_constants = __esm({
   "src/shared/constants.ts"() {
     "use strict";
+    DEFAULT_WS_PORT = 3478;
     DEFAULT_MCP_PORT = 3479;
     TANDEM_REPO_URL = "https://github.com/bloknayrb/tandem";
     TANDEM_ISSUES_NEW_URL = `${TANDEM_REPO_URL}/issues/new`;
@@ -886,6 +887,7 @@ async function applyConfig(configPath, ops) {
     ...ops.create
   };
   for (const key of ops.remove) {
+    if (key in ops.create) continue;
     if (merged[key]) {
       console.error(`  Note: removed mcpServers.${key} from ${configPath}`);
     }
@@ -929,21 +931,24 @@ function readSkillVersion(skillContent) {
 function validateChannelShimPrereq(channelPath) {
   return existsSync(channelPath);
 }
+function shouldRegisterChannelShim(targetKind, channelPath, override) {
+  if (targetKind === "claude-desktop") return false;
+  if (override !== void 0) return override;
+  return validateChannelShimPrereq(channelPath);
+}
 async function applyConfigWithToken(token, opts = {}) {
   const targets = detectTargets({ force: opts.force });
   let updated = 0;
   const errors = [];
   for (const t of targets) {
+    const withChannelShim = shouldRegisterChannelShim(t.kind, CHANNEL_DIST, opts.withChannelShim);
     const entries = buildMcpEntries(CHANNEL_DIST, {
-      withChannelShim: opts.withChannelShim,
+      withChannelShim,
       token: token ?? void 0,
       targetKind: t.kind
     });
     try {
-      await applyConfig(
-        t.configPath,
-        applyOpsForCli(entries, { withChannelShim: !!opts.withChannelShim })
-      );
+      await applyConfig(t.configPath, applyOpsForCli(entries, { withChannelShim }));
       updated++;
     } catch (err) {
       errors.push(`${t.label}: ${err instanceof Error ? err.message : String(err)}`);
@@ -1021,15 +1026,13 @@ Run 'npm run build' first, or drop --with-channel-shim to use the plugin monitor
   console.error("\nWriting MCP configuration...");
   let failures = 0;
   for (const t of targets) {
+    const withChannelShim = shouldRegisterChannelShim(t.kind, CHANNEL_DIST, opts.withChannelShim);
     const entries = buildMcpEntries(CHANNEL_DIST, {
-      withChannelShim: opts.withChannelShim,
+      withChannelShim,
       targetKind: t.kind
     });
     try {
-      await applyConfig(
-        t.configPath,
-        applyOpsForCli(entries, { withChannelShim: !!opts.withChannelShim })
-      );
+      await applyConfig(t.configPath, applyOpsForCli(entries, { withChannelShim }));
       console.error(`  \x1B[32m\u2713\x1B[0m ${t.label}`);
     } catch (err) {
       failures++;
@@ -1060,16 +1063,15 @@ Setup partially complete (${failures} target(s) failed). Start Tandem with: tand
     );
   }
   if (failures < targets.length) {
+    const channelRegistered = validateChannelShimPrereq(CHANNEL_DIST);
     const pluginManifest = join4(PACKAGE_ROOT, ".claude-plugin", "plugin.json");
-    const devInstructions = existsSync2(pluginManifest) ? `  Or for development, load directly from this package:
+    const devInstructions = existsSync2(pluginManifest) ? `  For development, you can also load the package directly:
 
     claude --plugin-dir ${PACKAGE_ROOT}
 
-` : `  (Development plugin dir not found at ${pluginManifest}; skipping local-plugin instructions.)
-
-`;
+` : "";
     console.error(
-      "\n\x1B[1mReal-time push notifications (recommended):\x1B[0m\n  Install the Tandem plugin for instant events (one-time):\n\n    claude plugin marketplace add bloknayrb/tandem\n    claude plugin install tandem@tandem-editor\n\n" + devInstructions + "  Without the plugin, Claude still works but relies on tandem_checkInbox polling.\n"
+      "\n\x1B[1mReal-time push notifications:\x1B[0m\n" + (channelRegistered ? "  \x1B[32mEnabled\x1B[0m \u2014 the channel shim is registered; Claude Code receives events in real time.\n  Relaunch any Claude Code session you started manually so it picks up the new server.\n\n" : "  \x1B[33mUnavailable\x1B[0m \u2014 dist/channel/index.js not found; Claude Code will poll via tandem_checkInbox.\n  Run 'npm run build' and re-run setup to enable push.\n\n") + "  A Tandem plugin is also published (skill + MCP; the real-time monitor it carries is\n  forward-looking, pending Claude Code support):\n\n    claude plugin marketplace add bloknayrb/tandem\n    claude plugin install tandem@tandem-editor\n\n" + devInstructions
     );
   }
 }
@@ -1644,7 +1646,7 @@ var init_types3 = __esm({
     SeveritySchema = z.enum(["info", "warning", "error", "success"]);
     TandemModeSchema = z.enum(["solo", "tandem"]);
     AuthorSchema = z.enum(["user", "claude", "import"]);
-    ReplyAuthorSchema = z.enum(["user", "claude"]);
+    ReplyAuthorSchema = z.enum(["user", "claude", "import"]);
     AnnotationActionSchema = z.enum(["accept", "dismiss"]);
     ExportFormatSchema = z.enum(["markdown", "json"]);
     DocumentFormatSchema = z.enum(["md", "txt", "html", "docx"]);
@@ -2228,6 +2230,515 @@ var init_channel = __esm({
   }
 });
 
+// src/cli/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  runDoctor: () => runDoctor,
+  runDoctorCli: () => runDoctorCli
+});
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { request } from "http";
+import { createConnection as createConnection2 } from "net";
+import { homedir as homedir2, platform } from "os";
+import { join as join5 } from "path";
+function checkNodeVersion(r) {
+  const version2 = process.version;
+  const major = Number.parseInt(version2.slice(1), 10);
+  if (major >= 22) {
+    r.pass(`Node.js ${version2} (>= 22 required)`);
+  } else {
+    r.fail(
+      `Node.js ${version2} \u2014 version 22+ required`,
+      "Install Node.js 22+ from https://nodejs.org"
+    );
+  }
+}
+function checkNodeModules(r) {
+  if (existsSync3(join5(process.cwd(), "node_modules"))) {
+    r.pass("node_modules/ exists");
+  } else {
+    r.fail("node_modules/ not found", "npm install");
+  }
+}
+function checkMcpJson(r) {
+  const mcpPath = join5(process.cwd(), ".mcp.json");
+  if (!existsSync3(mcpPath)) {
+    r.fail(".mcp.json not found", "Restore it from git: git checkout .mcp.json");
+    return;
+  }
+  let raw;
+  try {
+    raw = readFileSync3(mcpPath, "utf-8");
+  } catch (err) {
+    r.fail(`.mcp.json could not be read: ${errMsg(err)}`);
+    return;
+  }
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch (err) {
+    r.fail(`.mcp.json is not valid JSON: ${errMsg(err)}`);
+    return;
+  }
+  const servers = config.mcpServers;
+  if (!servers) {
+    r.fail('.mcp.json missing "mcpServers" key');
+    return;
+  }
+  const tandem = servers.tandem;
+  if (!tandem) {
+    r.fail('.mcp.json missing "tandem" server entry');
+  } else if (tandem.type !== "http" || !tandem.url?.includes("/mcp")) {
+    r.warn(`.mcp.json tandem: unexpected config \u2014 type=${tandem.type}, url=${tandem.url}`);
+  } else {
+    r.pass(`.mcp.json tandem \u2192 ${tandem.url}`);
+  }
+  const channel = servers["tandem-channel"];
+  if (!channel) {
+    r.warn(
+      ".mcp.json missing tandem-channel \u2014 Claude will use polling instead of push notifications"
+    );
+  } else {
+    const cmd = channel.command;
+    const args2 = (channel.args || []).join(" ");
+    if (cmd === "cmd" && args2.includes("/c")) {
+      r.warn(
+        `.mcp.json tandem-channel uses Windows-only "cmd /c" \u2014 won't work on macOS/Linux`,
+        'Change to: "command": "npx", "args": ["tsx", "src/channel/index.ts"]'
+      );
+    } else {
+      r.pass(`.mcp.json tandem-channel \u2192 ${cmd} ${args2}`);
+    }
+    if (!channel.env?.TANDEM_URL) {
+      r.warn(
+        "tandem-channel missing TANDEM_URL env var",
+        'Add "env": {"TANDEM_URL": "http://127.0.0.1:3479"}'
+      );
+    }
+  }
+}
+function checkUserMcpConfig(r) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const claudeCodePath = join5(home, ".claude.json");
+  if (!existsSync3(claudeCodePath)) {
+    r.warn(
+      "~/.claude.json not found",
+      "Run: tandem setup  (or ignore if using project-local .mcp.json)"
+    );
+    return;
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync3(claudeCodePath, "utf-8"));
+  } catch (err) {
+    r.warn(`~/.claude.json is malformed JSON: ${errMsg(err)}`, "Run: tandem setup to rewrite it");
+    return;
+  }
+  const servers = config?.mcpServers ?? {};
+  if (!servers.tandem) {
+    r.warn("tandem not registered in ~/.claude.json", "Run: tandem setup");
+  } else {
+    r.pass("tandem registered in ~/.claude.json");
+  }
+  if (!servers["tandem-channel"]) {
+    r.warn(
+      "tandem-channel not registered in ~/.claude.json \u2014 Claude Code will poll instead of receiving real-time push",
+      "Run: tandem setup"
+    );
+  } else {
+    r.pass("tandem-channel registered in ~/.claude.json");
+  }
+}
+function probePort(port, timeoutMs = 2e3) {
+  return new Promise((resolve4) => {
+    const socket = createConnection2({ port, host: "127.0.0.1" }, () => {
+      socket.destroy();
+      resolve4(true);
+    });
+    socket.setTimeout(timeoutMs);
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve4(false);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve4(false);
+    });
+  });
+}
+async function checkPorts(r) {
+  const [ws, mcp] = await Promise.all([probePort(WS_PORT), probePort(MCP_PORT)]);
+  if (ws && mcp) {
+    r.pass(`Ports ${WS_PORT} (WebSocket) + ${MCP_PORT} (MCP HTTP) in use`, void 0, { ws, mcp });
+  } else if (!ws && !mcp) {
+    r.fail(
+      `Ports ${WS_PORT} + ${MCP_PORT} not listening \u2014 server not running`,
+      "npm run dev:standalone",
+      { ws, mcp }
+    );
+  } else {
+    r.warn(
+      `Partial: port ${WS_PORT} ${ws ? "up" : "down"}, port ${MCP_PORT} ${mcp ? "up" : "down"}`,
+      "Server may be starting up or partially crashed",
+      { ws, mcp }
+    );
+  }
+  return { ws, mcp };
+}
+function httpGet(url, timeoutMs = 3e3) {
+  return new Promise((resolve4) => {
+    const req = request(url, { timeout: timeoutMs }, (res) => {
+      let body = "";
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        try {
+          resolve4({ status: res.statusCode, data: JSON.parse(body) });
+        } catch {
+          resolve4({ status: res.statusCode, data: null });
+        }
+      });
+    });
+    req.on("error", (err) => resolve4({ error: err.message }));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve4(null);
+    });
+    req.end();
+  });
+}
+async function checkHealth(r) {
+  const result = await httpGet(`http://127.0.0.1:${MCP_PORT}/health`);
+  if (!result) {
+    r.fail(`Server not responding on 127.0.0.1:${MCP_PORT}`, "npm run dev:standalone");
+    return false;
+  }
+  if (result.error) {
+    r.fail(
+      `Server not responding on 127.0.0.1:${MCP_PORT} (${result.error})`,
+      "npm run dev:standalone"
+    );
+    return false;
+  }
+  if (result.status !== 200) {
+    r.fail(`/health returned status ${result.status}`);
+    return false;
+  }
+  const d = result.data;
+  if (d) {
+    const session = d.hasSession ? "session active" : "no MCP session";
+    r.pass(`Server healthy (v${d.version}, ${d.transport}, ${session})`, void 0, {
+      version: d.version,
+      transport: d.transport,
+      hasSession: !!d.hasSession
+    });
+    if (!d.hasSession) {
+      r.warn("No active MCP session \u2014 Claude Code hasn't connected yet");
+    }
+  } else {
+    r.pass("Server responded on /health (could not parse body)");
+  }
+  return true;
+}
+function checkSseEndpoint(r) {
+  return new Promise((resolve4) => {
+    const req = request(`http://127.0.0.1:${MCP_PORT}/api/events`, { timeout: 2e3 }, (res) => {
+      req.destroy();
+      const ct = res.headers["content-type"] || "";
+      if (res.statusCode === 200 && ct.includes("text/event-stream")) {
+        r.pass("SSE event stream reachable (/api/events)");
+      } else {
+        r.warn(`/api/events responded with status ${res.statusCode}, content-type: ${ct}`);
+      }
+      resolve4();
+    });
+    req.on("error", (err) => {
+      r.warn(`/api/events not reachable: ${err.message}`);
+      resolve4();
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      r.warn("/api/events timed out");
+      resolve4();
+    });
+    req.end();
+  });
+}
+function resolveAppDataDir2() {
+  const override = process.env.TANDEM_APP_DATA_DIR;
+  if (override && override.length > 0) return override;
+  const home = homedir2();
+  switch (platform()) {
+    case "win32":
+      return join5(process.env.LOCALAPPDATA || join5(home, "AppData", "Local"), "tandem", "Data");
+    case "darwin":
+      return join5(home, "Library", "Application Support", "tandem");
+    default:
+      return join5(process.env.XDG_DATA_HOME || join5(home, ".local", "share"), "tandem");
+  }
+}
+function isPidLive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function checkAnnotationStore(r) {
+  const dir = join5(resolveAppDataDir2(), "annotations");
+  if (!existsSync3(dir)) {
+    r.pass(`Annotation store dir not yet created (${dir}) \u2014 first open will create it`, void 0, {
+      dir,
+      docCount: 0,
+      totalBytes: 0,
+      corruptCount: 0,
+      exists: false
+    });
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch (err) {
+    r.fail(`Annotation store dir unreadable: ${errMsg(err)}`, `Check permissions on ${dir}`);
+    return;
+  }
+  const jsonFiles = entries.filter((f) => f.endsWith(".json") && !f.endsWith(".corrupt.json"));
+  const corruptFiles = entries.filter((f) => f.includes(".corrupt."));
+  let totalBytes = 0;
+  let newest = { name: null, mtime: 0 };
+  let sampleSchemaVersion = null;
+  for (const f of jsonFiles) {
+    try {
+      const s = statSync2(join5(dir, f));
+      totalBytes += s.size;
+      if (s.mtimeMs > newest.mtime) {
+        newest = { name: f, mtime: s.mtimeMs };
+      }
+      if (sampleSchemaVersion === null) {
+        try {
+          const parsed = JSON.parse(readFileSync3(join5(dir, f), "utf-8"));
+          if (typeof parsed?.schemaVersion === "number") {
+            sampleSchemaVersion = parsed.schemaVersion;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  r.pass(
+    `Annotation store: ${jsonFiles.length} doc(s), ${formatBytes(totalBytes)} total`,
+    void 0,
+    {
+      dir,
+      docCount: jsonFiles.length,
+      totalBytes,
+      corruptCount: corruptFiles.length
+    }
+  );
+  if (newest.name) {
+    const ageMs = Date.now() - newest.mtime;
+    const ageStr = ageMs < 6e4 ? `${Math.floor(ageMs / 1e3)}s` : `${Math.floor(ageMs / 6e4)}m`;
+    r.pass(`Most recent annotation write: ${newest.name} (${ageStr} ago)`, void 0, {
+      name: newest.name,
+      mtimeMs: newest.mtime,
+      ageMs
+    });
+  }
+  if (sampleSchemaVersion !== null) {
+    r.pass(`Annotation schema version: ${sampleSchemaVersion}`, void 0, {
+      schemaVersion: sampleSchemaVersion
+    });
+  }
+  if (corruptFiles.length > 0) {
+    r.warn(
+      `${corruptFiles.length} quarantined annotation file(s) in ${dir}`,
+      "Safe to delete after inspection; kept 7d by design.",
+      {
+        corruptCount: corruptFiles.length,
+        dir
+      }
+    );
+  }
+  const lockPath = join5(dir, "store.lock");
+  if (!existsSync3(lockPath)) {
+    r.pass("Annotation store lock: not held (no running writer)", void 0, { lockHeld: false });
+    return;
+  }
+  try {
+    const raw = readFileSync3(lockPath, "utf-8").trim();
+    const pid = Number.parseInt(raw, 10);
+    if (!Number.isFinite(pid)) {
+      r.warn(
+        `Annotation store lock at ${lockPath} has unparseable content: "${raw}"`,
+        "Restart Tandem or delete the lock file if no server is running.",
+        { lockHeld: true, lockPath, lockContent: raw }
+      );
+      return;
+    }
+    if (isPidLive(pid)) {
+      r.pass(`Annotation store lock held by live PID ${pid}`, void 0, {
+        lockHeld: true,
+        pid,
+        pidLive: true
+      });
+    } else {
+      r.warn(
+        `Annotation store lock at ${lockPath} points to dead PID ${pid}`,
+        "The next server start will reclaim the stale lock automatically.",
+        { lockHeld: true, pid, pidLive: false }
+      );
+    }
+  } catch (err) {
+    r.warn(`Could not read annotation store lock: ${errMsg(err)}`);
+  }
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function runDoctor() {
+  const r = new Recorder();
+  await r.check("node-version", () => checkNodeVersion(r));
+  await r.check("node-modules", () => checkNodeModules(r));
+  await r.check("mcp-json", () => checkMcpJson(r));
+  await r.check("user-mcp-config", () => checkUserMcpConfig(r));
+  await r.check("annotation-store", () => checkAnnotationStore(r));
+  const { mcp } = await r.check("ports", () => checkPorts(r));
+  if (mcp) {
+    const healthy = await r.check("health", () => checkHealth(r));
+    if (healthy) {
+      await r.check("sse", () => checkSseEndpoint(r));
+    }
+  }
+  const summary = r.failures > 0 ? `${r.failures} issue(s) found.` : r.warnings > 0 ? `${r.warnings} warning(s) \u2014 Tandem should work, but check the items above.` : "All checks passed. Tandem is ready.";
+  return {
+    ok: r.failures === 0,
+    crashed: false,
+    failures: r.failures,
+    warnings: r.warnings,
+    summary,
+    error: null,
+    results: r.results
+  };
+}
+function colorTag(status) {
+  switch (status) {
+    case "pass":
+      return "\x1B[32m[PASS]\x1B[0m";
+    case "warn":
+      return "\x1B[33m[WARN]\x1B[0m";
+    case "fail":
+      return "\x1B[31m[FAIL]\x1B[0m";
+  }
+}
+async function runDoctorCli(opts = {}) {
+  const json = opts.json ?? false;
+  let report;
+  try {
+    report = await runDoctor();
+  } catch (err) {
+    const message = errMsg(err);
+    if (json) {
+      const crashed = {
+        ok: false,
+        crashed: true,
+        failures: 0,
+        warnings: 0,
+        summary: `Tandem Doctor crashed unexpectedly: ${message}`,
+        error: message,
+        results: []
+      };
+      process.stdout.write(`${JSON.stringify(crashed, null, 2)}
+`);
+    } else {
+      process.stderr.write(`
+  Tandem Doctor crashed unexpectedly: ${message}
+`);
+      process.stderr.write(
+        "  Please report this at https://github.com/bloknayrb/tandem/issues\n\n"
+      );
+    }
+    return 2;
+  }
+  const exitCode = report.failures > 0 ? 1 : 0;
+  if (json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    return exitCode;
+  }
+  const out = (line) => process.stdout.write(`${line}
+`);
+  out("");
+  out("  Tandem Doctor");
+  out("  =============");
+  out("");
+  for (const res of report.results) {
+    out(`  ${colorTag(res.status)} ${res.message}`);
+    if (res.status !== "pass" && res.fix) {
+      out(`         Fix: ${res.fix}`);
+    }
+  }
+  out("");
+  if (report.failures > 0) {
+    out(`  ${report.failures} issue(s) found. Fix the items above and re-run: tandem doctor`);
+  } else if (report.warnings > 0) {
+    out(`  ${report.warnings} warning(s) \u2014 Tandem should work, but check the items above.`);
+  } else {
+    out("  All checks passed. Tandem is ready.");
+  }
+  out("");
+  return exitCode;
+}
+var WS_PORT, MCP_PORT, Recorder;
+var init_doctor = __esm({
+  "src/cli/doctor.ts"() {
+    "use strict";
+    init_constants();
+    WS_PORT = DEFAULT_WS_PORT;
+    MCP_PORT = DEFAULT_MCP_PORT;
+    Recorder = class {
+      failures = 0;
+      warnings = 0;
+      results = [];
+      currentCheck = "";
+      async check(name, fn) {
+        const prev = this.currentCheck;
+        this.currentCheck = name;
+        try {
+          return await fn();
+        } finally {
+          this.currentCheck = prev;
+        }
+      }
+      record(status, msg, fix, fields) {
+        const entry = { check: this.currentCheck, status, message: msg };
+        if (fix) entry.fix = fix;
+        if (fields) entry.data = fields;
+        this.results.push(entry);
+      }
+      pass(msg, fix, fields) {
+        this.record("pass", msg, fix, fields);
+      }
+      warn(msg, fix, fields) {
+        this.warnings++;
+        this.record("warn", msg, fix, fields);
+      }
+      fail(msg, fix, fields) {
+        this.failures++;
+        this.record("fail", msg, fix, fields);
+      }
+    };
+  }
+});
+
 // src/shared/auth/token-file.ts
 import envPaths2 from "env-paths";
 import fs2 from "fs";
@@ -2396,11 +2907,11 @@ __export(start_exports, {
   runStart: () => runStart
 });
 import { spawn } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { dirname as dirname3, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function runStart() {
-  if (!existsSync3(SERVER_DIST)) {
+  if (!existsSync4(SERVER_DIST)) {
     console.error(`[Tandem] Server not found at ${SERVER_DIST}`);
     console.error("[Tandem] The installation may be corrupted. Try: npm install -g tandem-editor");
     process.exit(1);
@@ -2451,7 +2962,7 @@ process.once("unhandledRejection", (reason) => {
 `);
   process.exit(1);
 });
-var version = true ? "0.13.0" : "0.0.0-dev";
+var version = true ? "0.13.6" : "0.0.0-dev";
 var args = process.argv.slice(2);
 var isStdioMode = args[0] === "mcp-stdio" || args[0] === "channel";
 if (!isStdioMode) {
@@ -2465,6 +2976,9 @@ Usage:
   tandem setup                      Register MCP tools with your AI client (Claude Code / Claude Desktop by default)
   tandem setup --force              Register to default paths regardless of detection
   tandem setup --with-channel-shim  Also register the stdio channel shim (legacy opt-in)
+  tandem doctor                     Diagnose setup issues (Node version, .mcp.json,
+                                    ports, server health, annotation store)
+  tandem doctor --json              Same checks, emit a single JSON report on stdout
   tandem rotate-token               Rotate the auth token with a 60-second grace window
   tandem mcp-stdio                  Run as a stdio MCP server proxying to local HTTP
                                     (used by the plugin's Cowork bridge; requires
@@ -2497,6 +3011,10 @@ try {
   } else if (args[0] === "channel") {
     const { runChannelCli: runChannelCli2 } = await Promise.resolve().then(() => (init_channel(), channel_exports));
     await runChannelCli2();
+  } else if (args[0] === "doctor") {
+    const { runDoctorCli: runDoctorCli2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+    const exitCode = await runDoctorCli2({ json: args.includes("--json") });
+    process.exit(exitCode);
   } else if (args[0] === "rotate-token") {
     const { rotateToken: rotateToken2 } = await Promise.resolve().then(() => (init_rotate_token(), rotate_token_exports));
     await rotateToken2();