tandem-editor 0.16.0 → 0.18.0

package/dist/cli/index.js

@@ -290,7 +290,7 @@ function resolveChannelDist(env = process.env, exists = existsSync) {
   return resolve2(PACKAGE_ROOT, "dist/channel/index.js");
 }
 function resolveCliVersion() {
-  if (true) return "0.16.0";
+  if (true) return "0.18.0";
   if (typeof __APP_VERSION__ !== "undefined") return __APP_VERSION__;
   for (const rel of ["../../package.json", "../../../package.json"]) {
     try {
@@ -1238,7 +1238,7 @@ function printPushStatus() {
 
 ` : "";
   console.error(
-    "\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
+    "\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 + a real-time monitor that\n  activates on Claude Code 2.1.212+ and needs no --dangerously-... flag):\n\n    claude plugin marketplace add bloknayrb/tandem\n    claude plugin install tandem@tandem-editor\n\n" + devInstructions
   );
 }
 var init_setup = __esm({
@@ -1822,7 +1822,7 @@ var init_types2 = __esm({
 
 // src/shared/types.ts
 import { z } from "zod";
-var AnnotationTypeSchema, AnnotationStatusSchema, HighlightColorSchema, SeveritySchema, TandemModeSchema, AuthorSchema, ReplyAuthorSchema, AnnotationActionSchema, ExportFormatSchema, DocumentFormatSchema, ToolErrorCodeSchema, ChannelErrorCodeSchema, CHANNEL_CONNECT_FAILED;
+var AnnotationTypeSchema, AnnotationStatusSchema, HighlightColorSchema, SeveritySchema, TandemModeSchema, AuthorSchema, ReplyAuthorSchema, AnnotationActionSchema, ExportFormatSchema, DocumentFormatSchema, ToolErrorCodeSchema, ChannelErrorCodeSchema, CHANNEL_CONNECT_FAILED, MONITOR_CONNECT_FAILED;
 var init_types3 = __esm({
   "src/shared/types.ts"() {
     "use strict";
@@ -1852,6 +1852,7 @@ var init_types3 = __esm({
     ]);
     ChannelErrorCodeSchema = z.enum(["CHANNEL_CONNECT_FAILED", "MONITOR_CONNECT_FAILED"]);
     CHANNEL_CONNECT_FAILED = "CHANNEL_CONNECT_FAILED";
+    MONITOR_CONNECT_FAILED = "MONITOR_CONNECT_FAILED";
   }
 });
 
@@ -2155,6 +2156,63 @@ function refreshMode(tandemUrl, logPrefix) {
     cachedModeFailedAt = Date.now();
   });
 }
+async function flushFinalAwareness(tandemUrl, logPrefix = "[Tandem]") {
+  if (shutdownTimers.awarenessTimer) clearTimeout(shutdownTimers.awarenessTimer);
+  if (shutdownTimers.clearAwarenessTimer) clearTimeout(shutdownTimers.clearAwarenessTimer);
+  if (outstandingAwareness.size > 0) {
+    await Promise.allSettled(outstandingAwareness);
+  }
+  if (shutdownTimers.lastDocumentId === null) return true;
+  try {
+    const res = await fetchWithTimeout(
+      `${tandemUrl}${API_CHANNEL_AWARENESS}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          documentId: shutdownTimers.lastDocumentId,
+          status: "idle",
+          active: false
+        })
+      },
+      CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
+    );
+    if (!res.ok) {
+      console.error(`${logPrefix} Shutdown awareness clear returned ${res.status}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    console.error(
+      `${logPrefix} Shutdown awareness clear failed:`,
+      describeFetchError(
+        err,
+        `${API_CHANNEL_AWARENESS} shutdown`,
+        CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
+      )
+    );
+    return false;
+  }
+}
+function _resetSseConsumerStateForTests() {
+  cachedMode = TANDEM_MODE_DEFAULT;
+  cachedModeAt = 0;
+  cachedModeFailedAt = 0;
+  _modeRefreshInFlight = null;
+  shutdownTimers.awarenessTimer = null;
+  shutdownTimers.clearAwarenessTimer = null;
+  shutdownTimers.lastDocumentId = null;
+  outstandingAwareness.clear();
+}
+function _setLastDocumentIdForTests(id) {
+  shutdownTimers.lastDocumentId = id;
+}
+function _getLastDocumentIdForTests() {
+  return shutdownTimers.lastDocumentId;
+}
+function _addOutstandingAwarenessForTests(p) {
+  trackAwareness(p);
+}
 var AWARENESS_DEBOUNCE_MS, AWARENESS_CLEAR_MS, MODE_CACHE_TTL_MS, STABLE_CONNECTION_MS, RETRY_MAX_DELAY_MS, shutdownTimers, outstandingAwareness, cachedMode, cachedModeAt, cachedModeFailedAt, _modeRefreshInFlight;
 var init_sse_consumer = __esm({
   "src/shared/sse-consumer.ts"() {
@@ -2417,6 +2475,114 @@ var init_channel = __esm({
   }
 });
 
+// src/monitor/run.ts
+var run_exports = {};
+__export(run_exports, {
+  _addOutstandingAwarenessForTests: () => _addOutstandingAwarenessForTests2,
+  _getLastDocumentIdForTests: () => _getLastDocumentIdForTests2,
+  _monitorTestExports: () => _monitorTestExports,
+  _resetMonitorStateForTests: () => _resetMonitorStateForTests,
+  _setLastDocumentIdForTests: () => _setLastDocumentIdForTests2,
+  connectAndStream: () => connectAndStream,
+  getCachedMode: () => getCachedMode2,
+  getModeSync: () => getModeSync2,
+  main: () => main,
+  shutdownMonitor: () => shutdownMonitor
+});
+function buildOptions() {
+  return {
+    tandemUrl: TANDEM_URL,
+    logPrefix: LOG_PREFIX,
+    errorCode: MONITOR_CONNECT_FAILED,
+    onEvent: (event) => {
+      const content = formatEventContent(event).replace(/\n/g, " ");
+      process.stdout.write(content + "\n");
+    },
+    onExhaustion: () => {
+      process.stdout.write(
+        "Tandem monitor disconnected \u2014 restart Tandem to restore real-time events\n"
+      );
+    }
+  };
+}
+async function main() {
+  installShutdownHandlers();
+  installStdoutErrorHandler();
+  console.error(`${LOG_PREFIX} Tandem monitor starting (server: ${TANDEM_URL})`);
+  await getCachedMode2().catch(() => {
+  });
+  await runEventConsumer(buildOptions());
+}
+async function connectAndStream(lastEventId, onEventId, onStable = () => {
+}) {
+  return connectAndStreamOnce(buildOptions(), lastEventId, { onEventId, onStable });
+}
+async function shutdownMonitor(signal) {
+  console.error(`${LOG_PREFIX} Received ${signal}, clearing awareness and exiting`);
+  const ok = await flushFinalAwareness(TANDEM_URL, LOG_PREFIX);
+  process.exit(ok ? 0 : 1);
+}
+function _setLastDocumentIdForTests2(id) {
+  _setLastDocumentIdForTests(id);
+}
+function _getLastDocumentIdForTests2() {
+  return _getLastDocumentIdForTests();
+}
+function _addOutstandingAwarenessForTests2(p) {
+  _addOutstandingAwarenessForTests(p);
+}
+function installShutdownHandlers() {
+  if (IS_VITEST) return;
+  const handler = (signal) => {
+    shutdownMonitor(signal).catch((err) => {
+      console.error(`${LOG_PREFIX} Shutdown handler failed:`, err);
+      process.exit(1);
+    });
+  };
+  process.on("SIGINT", () => handler("SIGINT"));
+  process.on("SIGTERM", () => handler("SIGTERM"));
+}
+function onStdoutError(err) {
+  console.error(`${LOG_PREFIX} stdout error (plugin-host pipe likely closed):`, err);
+  process.exit(1);
+}
+function installStdoutErrorHandler() {
+  if (IS_VITEST) return;
+  process.stdout.on("error", onStdoutError);
+}
+async function getCachedMode2() {
+  return getCachedMode(TANDEM_URL, LOG_PREFIX);
+}
+function getModeSync2() {
+  return getModeSync();
+}
+function _resetMonitorStateForTests() {
+  _resetSseConsumerStateForTests();
+  process.removeAllListeners("SIGINT");
+  process.removeAllListeners("SIGTERM");
+}
+var IS_VITEST, TANDEM_URL, LOG_PREFIX, _monitorTestExports;
+var init_run2 = __esm({
+  "src/monitor/run.ts"() {
+    "use strict";
+    init_cli_runtime();
+    init_types();
+    init_sse_consumer();
+    init_types3();
+    IS_VITEST = process.env.VITEST === "true";
+    if (!IS_VITEST) {
+      console.log = console.error;
+      console.warn = console.error;
+      console.info = console.error;
+    }
+    TANDEM_URL = resolveTandemUrl();
+    LOG_PREFIX = "[Monitor]";
+    _monitorTestExports = {
+      onStdoutError
+    };
+  }
+});
+
 // src/server/annotations/lockfile.ts
 function parseLockfile(raw) {
   const trimmed = raw.trim();
@@ -2447,8 +2613,12 @@ var init_lockfile = __esm({
 // src/cli/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
+  evaluateNpmStaleness: () => evaluateNpmStaleness,
+  evaluateOrphanedVite: () => evaluateOrphanedVite,
   evaluateStaleGlobal: () => evaluateStaleGlobal,
   globalTandemEditorVersion: () => globalTandemEditorVersion,
+  isTandemEditorRepo: () => isTandemEditorRepo,
+  probeTandemEditorRepo: () => probeTandemEditorRepo,
   runDoctor: () => runDoctor,
   runDoctorCli: () => runDoctorCli,
   summarizeDoctorResults: () => summarizeDoctorResults
@@ -2459,6 +2629,10 @@ import { request } from "http";
 import { createConnection as createConnection2 } from "net";
 import { homedir as homedir3, platform } from "os";
 import { join as join5 } from "path";
+function errorClass(err) {
+  if (err instanceof Error) return err.name;
+  return typeof err;
+}
 function checkNodeVersion(r) {
   const version2 = process.version;
   const major = Number.parseInt(version2.slice(1), 10);
@@ -2478,6 +2652,204 @@ function checkNodeModules(r) {
     r.fail("node_modules/ not found", "npm install");
   }
 }
+function recordEvaluation(r, result) {
+  if (!result) return;
+  if (result.status === "warn") {
+    r.warn(result.message, result.fix, result.data);
+    return;
+  }
+  if (result.status === "skip") {
+    r.pass(`skipped \u2014 ${result.message}`, result.fix, { ...result.data, skipped: true });
+    return;
+  }
+  r.pass(result.message, result.fix, result.data);
+}
+function probeTandemEditorRepo(dir) {
+  const read = readJson(join5(dir, "package.json"));
+  if (read.kind === "absent") return "no";
+  if (read.kind === "unreadable") return "unreadable";
+  const parsed = read.value;
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return "unreadable";
+  }
+  return parsed.name === "tandem-editor" ? "yes" : "no";
+}
+function isTandemEditorRepo(dir) {
+  return probeTandemEditorRepo(dir) === "yes";
+}
+function readJson(path8) {
+  let raw;
+  try {
+    raw = readFileSync3(path8, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return { kind: "absent" };
+    return { kind: "unreadable", reason: code ?? errorClass(err) };
+  }
+  try {
+    return { kind: "ok", value: JSON.parse(raw) };
+  } catch {
+    return { kind: "unreadable", reason: "not valid JSON" };
+  }
+}
+function parseLockfileEntry(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const entry = value;
+  if (entry.version !== void 0 && typeof entry.version !== "string") return null;
+  if (entry.optional !== void 0 && typeof entry.optional !== "boolean") return null;
+  return {
+    version: entry.version,
+    optional: entry.optional
+  };
+}
+function parseLockfileJson(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const obj = value;
+  if (obj.version !== void 0 && typeof obj.version !== "string") return null;
+  const version2 = obj.version;
+  if (obj.packages === void 0) return { version: version2 };
+  if (typeof obj.packages !== "object" || obj.packages === null || Array.isArray(obj.packages)) {
+    return null;
+  }
+  const packages = {};
+  for (const [path8, raw] of Object.entries(obj.packages)) {
+    const entry = parseLockfileEntry(raw);
+    if (!entry) return null;
+    packages[path8] = entry;
+  }
+  return { version: version2, packages };
+}
+function evaluateNpmStaleness(pkgInput, lockInput, hiddenLockInput) {
+  if (!pkgInput || !lockInput || !hiddenLockInput) return null;
+  const lock = parseLockfileJson(lockInput);
+  if (!lock) {
+    return {
+      status: "skip",
+      message: "cannot compare (package-lock.json has an unexpected structure)",
+      fix: "Restore it from git: git checkout package-lock.json",
+      data: { reason: "malformed-lock" }
+    };
+  }
+  const hiddenLock = parseLockfileJson(hiddenLockInput);
+  if (!hiddenLock) {
+    return {
+      status: "skip",
+      message: "cannot compare (node_modules/.package-lock.json has an unexpected structure)",
+      fix: "npm install",
+      data: { reason: "malformed-hidden-lock" }
+    };
+  }
+  const pkg = typeof pkgInput === "object" && !Array.isArray(pkgInput) ? pkgInput : {};
+  const pkgVersion = typeof pkg.version === "string" ? pkg.version : void 0;
+  if (pkgVersion && lock.version && pkgVersion !== lock.version) {
+    return {
+      status: "warn",
+      message: `package-lock.json (v${lock.version}) is out of date with package.json (v${pkgVersion})`,
+      fix: "npm install",
+      data: { packageVersion: pkgVersion, lockVersion: lock.version }
+    };
+  }
+  if (lock.version && hiddenLock.version && lock.version !== hiddenLock.version) {
+    return {
+      status: "warn",
+      message: `node_modules was installed from a different lockfile (v${hiddenLock.version} installed, v${lock.version} expected)`,
+      fix: "npm install",
+      data: { lockVersion: lock.version, installedVersion: hiddenLock.version }
+    };
+  }
+  const wanted = lock.packages ?? {};
+  const installed = hiddenLock.packages ?? {};
+  const wantedCount = Object.keys(wanted).filter((path8) => path8 !== "").length;
+  if (wantedCount === 0) {
+    return {
+      status: "skip",
+      message: "cannot compare (package-lock.json lists no packages \u2014 a lockfileVersion 1 file, or one written by something other than npm)",
+      fix: "npm install",
+      // No inferred `lockfileVersion` here: we did not read that field, and
+      // guessing it from the presence of `packages` would put a fabricated
+      // value under a real npm field name.
+      data: { reason: "no-comparable-packages" }
+    };
+  }
+  const drifted = [];
+  for (const [path8, entry] of Object.entries(wanted)) {
+    if (path8 === "") continue;
+    const got = installed[path8];
+    if (!got) {
+      if (!entry.optional) drifted.push(path8);
+    } else if (entry.version !== got.version) {
+      drifted.push(path8);
+    }
+  }
+  for (const path8 of Object.keys(installed)) {
+    if (path8 !== "" && !(path8 in wanted)) drifted.push(path8);
+  }
+  if (drifted.length > 0) {
+    return {
+      status: "warn",
+      message: `node_modules is stale \u2014 ${drifted.length} package(s) differ from package-lock.json (e.g. after a pull or branch switch)`,
+      fix: "npm install",
+      data: { driftCount: drifted.length, sample: drifted.slice(0, 5) }
+    };
+  }
+  const missingVersions = [];
+  if (!pkgVersion) missingVersions.push("package.json");
+  if (!lock.version) missingVersions.push("package-lock.json");
+  if (!hiddenLock.version) missingVersions.push("node_modules/.package-lock.json");
+  if (missingVersions.length > 0) {
+    return {
+      status: "skip",
+      message: `node_modules matches package-lock.json, but the version check could not run \u2014 no "version" field in ${missingVersions.join(", ")}`,
+      data: { reason: "no-comparable-version", missingVersions }
+    };
+  }
+  return {
+    status: "pass",
+    message: "node_modules matches package-lock.json",
+    data: { packageCount: Object.keys(installed).length }
+  };
+}
+function readLockfileOrReport(r, path8, label) {
+  const read = readJson(path8);
+  if (read.kind === "absent") {
+    r.pass(`skipped \u2014 cannot compare (${label} not found)`, void 0, {
+      skipped: true,
+      reason: "absent",
+      path: label
+    });
+    return { ok: false };
+  }
+  if (read.kind === "ok") {
+    if (typeof read.value === "object" && read.value !== null && !Array.isArray(read.value)) {
+      return { ok: true, value: read.value };
+    }
+    r.warn(
+      `${label} is not a JSON object \u2014 npm install staleness cannot be checked`,
+      "Check for a truncated or hand-edited file, then: npm install",
+      { reason: "not-an-object", path: label }
+    );
+    return { ok: false };
+  }
+  r.warn(
+    `${label} could not be read (${read.reason}) \u2014 npm install staleness cannot be checked`,
+    "Check for merge-conflict markers or a truncated file, then: npm install",
+    { reason: read.reason, path: label }
+  );
+  return { ok: false };
+}
+function checkNpmStaleness(r, repoDir) {
+  const pkgRead = readJson(join5(repoDir, "package.json"));
+  const pkg = pkgRead.kind === "ok" ? pkgRead.value : null;
+  const lock = readLockfileOrReport(r, join5(repoDir, "package-lock.json"), "package-lock.json");
+  if (!lock.ok) return;
+  const hiddenLock = readLockfileOrReport(
+    r,
+    join5(repoDir, "node_modules", ".package-lock.json"),
+    "node_modules/.package-lock.json"
+  );
+  if (!hiddenLock.ok) return;
+  recordEvaluation(r, evaluateNpmStaleness(pkg, lock.value, hiddenLock.value));
+}
 function checkMcpJson(r) {
   const mcpPath = join5(process.cwd(), ".mcp.json");
   if (!existsSync3(mcpPath)) {
@@ -2603,14 +2975,64 @@ async function checkPorts(r, wsPort, mcpPort) {
   }
   return { ws, mcp };
 }
+function evaluateOrphanedVite(input) {
+  const { viteUp, viteConfirmed, wsUp, mcpUp, wsPort, mcpPort, vitePort } = input;
+  if (!viteUp) return null;
+  if (!viteConfirmed) {
+    return {
+      status: "skip",
+      message: `cannot identify the process on :${vitePort} \u2014 it is listening but did not answer /@vite/client, so it is probably not a Vite dev server`,
+      data: { vite: false, ws: wsUp, mcp: mcpUp, reason: "unconfirmed-vite" }
+    };
+  }
+  if (!wsUp && !mcpUp) {
+    return {
+      status: "warn",
+      message: `Vite dev server on :${vitePort} is running but the backend (:${wsPort} + :${mcpPort}) is down \u2014 likely orphaned by a crashed dev session`,
+      fix: `If you meant to run the client alone (npm run dev:client), this is expected. Otherwise kill the process on :${vitePort} and restart: npm run dev:standalone`,
+      data: { vite: true, ws: wsUp, mcp: mcpUp }
+    };
+  }
+  if (wsUp !== mcpUp) {
+    return {
+      status: "skip",
+      message: `cannot tell whether the Vite dev server on :${vitePort} is orphaned \u2014 the backend is only partially up (:${wsPort} ${wsUp ? "up" : "down"}, :${mcpPort} ${mcpUp ? "up" : "down"}); see the ports check`,
+      data: { vite: true, ws: wsUp, mcp: mcpUp, reason: "partial-backend" }
+    };
+  }
+  return {
+    status: "pass",
+    message: `Vite dev server (:${vitePort}) running alongside the backend`,
+    data: { vite: true, ws: wsUp, mcp: mcpUp }
+  };
+}
+async function checkOrphanedVite(r, wsUp, mcpUp, wsPort, mcpPort, vitePort) {
+  const viteUp = await probePort(vitePort);
+  const viteConfirmed = viteUp ? await isViteDevServer(vitePort) : false;
+  recordEvaluation(
+    r,
+    evaluateOrphanedVite({ viteUp, viteConfirmed, wsUp, mcpUp, wsPort, mcpPort, vitePort })
+  );
+}
 function httpGet(url, timeoutMs = 3e3) {
   return new Promise((resolve4) => {
     const req = request(url, { timeout: timeoutMs }, (res) => {
       let body = "";
+      let bytes = 0;
+      let truncated = false;
       res.on("data", (chunk) => {
+        if (truncated) return;
+        bytes += Buffer.byteLength(chunk);
+        if (bytes > HTTP_MAX_BYTES) {
+          truncated = true;
+          res.destroy();
+          resolve4({ status: res.statusCode, data: null });
+          return;
+        }
         body += chunk;
       });
       res.on("end", () => {
+        if (truncated) return;
         try {
           resolve4({ status: res.statusCode, data: JSON.parse(body) });
         } catch {
@@ -2626,6 +3048,10 @@ function httpGet(url, timeoutMs = 3e3) {
     req.end();
   });
 }
+async function isViteDevServer(port) {
+  const result = await httpGet(`http://127.0.0.1:${port}/@vite/client`, 2e3);
+  return result?.status === 200;
+}
 async function checkHealth(r, mcpPort) {
   const result = await httpGet(`http://127.0.0.1:${mcpPort}/health`);
   if (!result) {
@@ -2865,7 +3291,7 @@ function evaluateStaleGlobal(bundled, globalVersion) {
   };
 }
 async function checkStaleGlobal(r) {
-  const bundled = true ? "0.16.0" : null;
+  const bundled = true ? "0.18.0" : null;
   if (!bundled) return;
   let globalVersion;
   try {
@@ -2884,16 +3310,37 @@ async function checkStaleGlobal(r) {
 async function runDoctor(opts = {}) {
   const wsPort = opts.wsPort ?? DEFAULT_WS_PORT;
   const mcpPort = opts.mcpPort ?? DEFAULT_MCP_PORT;
+  const vitePort = opts.vitePort ?? VITE_DEV_PORT;
   const r = new Recorder();
+  const cwd = process.cwd();
+  const repo = probeTandemEditorRepo(cwd);
+  const devRepo = repo === "yes";
   await r.check("node-version", () => checkNodeVersion(r));
   await r.check("node-modules", () => checkNodeModules(r));
+  if (repo === "unreadable") {
+    await r.check(
+      "dev-repo",
+      () => r.warn(
+        "package.json in the current directory could not be read \u2014 if this is the tandem-editor checkout, the npm-staleness and orphaned-Vite checks are being skipped",
+        "Check for merge-conflict markers or a truncated file: git checkout package.json"
+      )
+    );
+  }
+  if (devRepo) {
+    await r.check("npm-staleness", () => checkNpmStaleness(r, cwd));
+  }
   await r.check("mcp-json", () => checkMcpJson(r));
   await r.check("user-mcp-config", () => checkUserMcpConfig(r));
   await r.check("annotation-store", () => checkAnnotationStore(r));
   await r.check("stale-global", () => checkStaleGlobal(r));
-  const { mcp } = await r.check("ports", () => checkPorts(r, wsPort, mcpPort));
+  const ports = await r.check("ports", () => checkPorts(r, wsPort, mcpPort));
+  const ws = ports?.ws ?? false;
+  const mcp = ports?.mcp ?? false;
+  if (devRepo) {
+    await r.check("orphaned-vite", () => checkOrphanedVite(r, ws, mcp, wsPort, mcpPort, vitePort));
+  }
   if (mcp) {
-    const healthy = await r.check("health", () => checkHealth(r, mcpPort));
+    const healthy = await r.check("health", () => checkHealth(r, mcpPort)) ?? false;
     if (healthy) {
       await r.check("sse", () => checkSseEndpoint(r, mcpPort));
     }
@@ -2976,7 +3423,7 @@ async function runDoctorCli(opts = {}) {
   out("");
   return exitCode;
 }
-var Recorder;
+var Recorder, VITE_DEV_PORT, HTTP_MAX_BYTES;
 var init_doctor = __esm({
   "src/cli/doctor.ts"() {
     "use strict";
@@ -2987,11 +3434,29 @@ var init_doctor = __esm({
       warnings = 0;
       results = [];
       currentCheck = "";
+      /**
+       * Run one check under `name`. A throwing check is contained here and
+       * recorded as a `fail` rather than taking the whole report down.
+       *
+       * Returns `T | undefined` — NOT `T`. The `undefined` is load-bearing and
+       * must not be cast away: a crashed check produced no value, and the two
+       * callers that consume one (`ports` destructures `{ws, mcp}`; `health`
+       * gates the `sse` check) have to say what they want instead. Returning
+       * `undefined as T` would satisfy the compiler and then throw a TypeError
+       * on the destructure — converting a clear crash into a confusing one on
+       * the exact path this containment exists to protect.
+       */
       async check(name, fn) {
         const prev = this.currentCheck;
         this.currentCheck = name;
         try {
           return await fn();
+        } catch (err) {
+          this.fail(
+            `${name} check crashed (${errorClass(err)}) \u2014 the rest of the report is still valid`,
+            "Please report this at https://github.com/bloknayrb/tandem/issues"
+          );
+          return void 0;
         } finally {
           this.currentCheck = prev;
         }
@@ -3014,6 +3479,8 @@ var init_doctor = __esm({
         this.record("fail", msg, fix, fields);
       }
     };
+    VITE_DEV_PORT = 5173;
+    HTTP_MAX_BYTES = 256 * 1024;
   }
 });
 
@@ -3696,7 +4163,7 @@ import fs4 from "fs";
 function knownVersion(v) {
   return typeof v === "string" && KNOWN_VERSION_MAJORS.has(v.split(".")[0]);
 }
-function readJson(filePath) {
+function readJson2(filePath) {
   try {
     return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
   } catch {
@@ -3709,7 +4176,7 @@ function resolveLicenseState(deps) {
     return { gateActive: false };
   }
   const nowMs = now();
-  const lf = readJson(licenseFilePath(appDataDir));
+  const lf = readJson2(licenseFilePath(appDataDir));
   if (lf?.blob) {
     try {
       const meta = verify(lf.blob);
@@ -3726,7 +4193,7 @@ function resolveLicenseState(deps) {
     } catch {
     }
   }
-  const tf = readJson(trialFilePath(appDataDir));
+  const tf = readJson2(trialFilePath(appDataDir));
   const firstRunAt = tf?.firstRunAt ? new Date(tf.firstRunAt).getTime() : nowMs;
   const expiresAt = firstRunAt + TRIAL_MS;
   if (nowMs < expiresAt) {
@@ -3917,7 +4384,7 @@ process.once("unhandledRejection", (reason) => {
 `);
   process.exit(1);
 });
-var version = true ? "0.16.0" : "0.0.0-dev";
+var version = true ? "0.18.0" : "0.0.0-dev";
 var args = process.argv.slice(2);
 if (args.includes("--help") || args.includes("-h")) {
   console.log(`tandem v${version}
@@ -3945,6 +4412,10 @@ Usage:
                                     tandem server running on the host)
   tandem channel                    Run the Tandem channel shim (stdio MCP)
                                     (used by the plugin's tandem-channel entry)
+  tandem monitor                    Run the Tandem plugin monitor: stream event
+                                    lines to stdout for Claude Code to surface as
+                                    notifications (used by the plugin's
+                                    experimental.monitors entry; needs no flag)
   tandem --version
   tandem --help
 `);
@@ -3954,7 +4425,7 @@ if (args.includes("--version") || args.includes("-v")) {
   console.log(version);
   process.exit(0);
 }
-var isStdioMode = args[0] === "mcp-stdio" || args[0] === "channel";
+var isStdioMode = args[0] === "mcp-stdio" || args[0] === "channel" || args[0] === "monitor";
 if (!isStdioMode) {
   const { default: updateNotifier } = await import("update-notifier");
   updateNotifier({ pkg: { name: "tandem-editor", version } }).notify();
@@ -3990,6 +4461,9 @@ try {
   } else if (args[0] === "channel") {
     const { runChannelCli: runChannelCli2 } = await Promise.resolve().then(() => (init_channel(), channel_exports));
     await runChannelCli2();
+  } else if (args[0] === "monitor") {
+    const { main: main2 } = await Promise.resolve().then(() => (init_run2(), run_exports));
+    await main2();
   } else if (args[0] === "doctor") {
     const { runDoctorCli: runDoctorCli2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
     const exitCode = await runDoctorCli2({ json: args.includes("--json") });