kojee-mcp 0.2.2 → 0.5.0

package/dist/chunk-W6YRLSD4.js

@@ -0,0 +1,143 @@
+// src/tandem/session-discovery.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function sessionDiscoveryDir() {
+  return path.join(os.homedir(), ".kojee", "sessions");
+}
+function sessionDiscoveryPath(sessionId) {
+  return path.join(sessionDiscoveryDir(), `${sessionId}.json`);
+}
+function discoveryFileName(key) {
+  return `cc-${key}.json`;
+}
+function writeSessionDiscovery(sessionId, entry) {
+  const dir = sessionDiscoveryDir();
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+  const filePath = sessionDiscoveryPath(sessionId);
+  fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), { mode: 384 });
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function readSessionDiscovery(sessionId) {
+  try {
+    const raw = fs.readFileSync(sessionDiscoveryPath(sessionId), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function cleanupSessionDiscovery(sessionId) {
+  try {
+    fs.unlinkSync(sessionDiscoveryPath(sessionId));
+  } catch {
+  }
+}
+function discoveryPathForKey(key) {
+  return path.join(sessionDiscoveryDir(), discoveryFileName(key));
+}
+function writeDiscoveryByKey(key, entry) {
+  const dir = sessionDiscoveryDir();
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+  const filePath = discoveryPathForKey(key);
+  fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), { mode: 384 });
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function cleanupDiscoveryByKey(key) {
+  try {
+    fs.unlinkSync(discoveryPathForKey(key));
+  } catch {
+  }
+}
+function readSessionDiscoveryByKey(key) {
+  try {
+    const raw = fs.readFileSync(discoveryPathForKey(key), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_SWEEP_MIN_AGE_MS = 6e4;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+function sweepStaleDiscovery(opts = {}) {
+  const minAgeMs = opts.minAgeMs ?? DEFAULT_SWEEP_MIN_AGE_MS;
+  const dir = sessionDiscoveryDir();
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    const filePath = path.join(dir, name);
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+    const ageMs = Math.max(0, now - stat.mtimeMs);
+    if (ageMs < minAgeMs) continue;
+    let parsed = null;
+    try {
+      parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+      }
+      continue;
+    }
+    if (parsed?.schema !== 2) {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+      }
+      continue;
+    }
+    if (typeof parsed.proxyPid !== "number" || !isProcessAlive(parsed.proxyPid)) {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+      }
+      continue;
+    }
+  }
+}
+
+export {
+  sessionDiscoveryDir,
+  sessionDiscoveryPath,
+  discoveryFileName,
+  writeSessionDiscovery,
+  readSessionDiscovery,
+  cleanupSessionDiscovery,
+  discoveryPathForKey,
+  writeDiscoveryByKey,
+  cleanupDiscoveryByKey,
+  readSessionDiscoveryByKey,
+  sweepStaleDiscovery
+};

package/dist/cli.js

@@ -1,37 +1,229 @@
 #!/usr/bin/env node
 import {
+  AuthModule,
+  VERSION,
   startProxy
-} from "./chunk-QKAUM3TR.js";
+} from "./chunk-LCFCCWMM.js";
+import "./chunk-QB22PD6T.js";
+import "./chunk-E26AHU6J.js";
+import "./chunk-BJMASMKX.js";
+import {
+  loadPairedConfig,
+  pairedConfigPath,
+  savePairedConfig
+} from "./chunk-GBOTBYEP.js";
 
 // src/cli.ts
 import { Command } from "commander";
 import crypto from "crypto";
+import os from "os";
 import path from "path";
-var KOJEE_DIR = path.join(process.env["HOME"] ?? "~", ".kojee");
+
+// src/tandem/pair.ts
+import fs from "fs";
+async function runPair(opts) {
+  if (loadPairedConfig(opts.configPath) !== null) {
+    throw new Error(
+      `Already paired (config exists at ${opts.configPath}). To re-pair this slot, delete the config file first. For a second account, use --keystore-path /custom/keypair.json.`
+    );
+  }
+  try {
+    fs.unlinkSync(opts.keystorePath);
+  } catch {
+  }
+  const auth = new AuthModule(opts.code, opts.url, opts.keystorePath);
+  await auth.ensureEnrolled();
+  let principal_id;
+  let agent_id;
+  try {
+    const me = await fetch(`${opts.url}/api/v1/users/me/`, {
+      headers: { Authorization: `DPoP ${opts.code}` }
+    });
+    if (me.ok) {
+      const body = await me.json();
+      principal_id = body.principal_id;
+      agent_id = body.agent_id;
+    }
+  } catch {
+  }
+  const config = {
+    token: opts.code,
+    broker_url: opts.url,
+    paired_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...principal_id ? { principal_id } : {},
+    ...agent_id ? { agent_id } : {}
+  };
+  savePairedConfig(opts.configPath, config);
+  const who = principal_id && agent_id ? `${principal_id} (${agent_id})` : "(use kojee-mcp without args to start the proxy)";
+  return { message: `Paired as ${who}. Keypair: ${opts.keystorePath}. Config: ${opts.configPath}.` };
+}
+
+// src/cli.ts
+var KOJEE_DIR = path.join(os.homedir(), ".kojee");
 function deriveKeystorePath(token) {
   const hash = crypto.createHash("sha256").update(token).digest("hex").slice(0, 12);
   return path.join(KOJEE_DIR, `keypair-${hash}.json`);
 }
+function defaultPairedKeystorePath() {
+  return path.join(KOJEE_DIR, "keypair.json");
+}
 var program = new Command().name("kojee-mcp").description(
   "Local MCP proxy for Kojee \u2014 handles DPoP auth, tool discovery, and governance transparently"
-).version("0.2.2").requiredOption(
-  "--token <token>",
-  "Gateway token"
-).requiredOption(
-  "--url <url>",
-  "Broker base URL (e.g. https://kojee.ai)"
-).option(
+).version(VERSION).enablePositionalOptions();
+program.command("pair <code>").description("Pair this machine against Kojee using a pair code from the dashboard").requiredOption("--url <url>", "Broker base URL (e.g. https://rosie-server.kojee.net)").option("--keystore-path <path>", "Path to keypair.json (default ~/.kojee/keypair.json)").action(async (code, opts) => {
+  const url = opts.url.replace(/\/+$/, "");
+  const keystorePath = opts.keystorePath ?? defaultPairedKeystorePath();
+  const configPath = opts.keystorePath ? path.join(path.dirname(opts.keystorePath), "config.json") : pairedConfigPath();
+  try {
+    const result = await runPair({ code, url, keystorePath, configPath });
+    console.error(result.message);
+  } catch (err) {
+    console.error("[kojee-mcp pair] Failed:", err.message);
+    process.exit(1);
+  }
+});
+program.command("hook").description("Run a kojee MCP hook script (called by Claude Code via ~/.claude/settings.json)").requiredOption("--type <type>", "Hook type: stop or user-prompt-submit").action(async (opts) => {
+  if (opts.type === "stop") {
+    const { runStopHook } = await import("./stop-hook-VLQS6QPR.js");
+    await runStopHook();
+    process.exit(0);
+  } else if (opts.type === "user-prompt-submit") {
+    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-C42DPDBO.js");
+    await runUserPromptSubmitHook();
+    process.exit(0);
+  } else {
+    console.error(`Unknown hook type: ${opts.type}. Expected 'stop' or 'user-prompt-submit'.`);
+    process.exit(1);
+  }
+});
+program.command("install-hooks").description("Install kojee Stop + UserPromptSubmit hooks in ~/.claude/settings.json (idempotent)").option("--hooks-path <path>", "Override default ~/.claude/settings.json").option("--uninstall", "Remove kojee hook entries instead of installing them").action(async (opts) => {
+  const { installHooks, uninstallHooks } = await import("./install-D2HIPOMT.js");
+  if (opts.uninstall) {
+    const removed = uninstallHooks({ hooksPath: opts.hooksPath });
+    console.error(removed ? "Removed kojee hook entries." : "No kojee hook entries found.");
+  } else {
+    const { stop, ups } = installHooks({ hooksPath: opts.hooksPath });
+    console.error(
+      "Installed kojee hooks in " + (opts.hooksPath ?? "~/.claude/settings.json") + `:
+  - Stop:              ${stop === "added" ? "\u2713 added" : "\u21BB already installed"}
+  - UserPromptSubmit:  ${ups === "added" ? "\u2713 added" : "\u21BB already installed"}
+Restart Claude Code for hooks to take effect.`
+    );
+  }
+});
+program.command("tail <path>").description("Stream a file's contents and follow appends (portable replacement for `tail -F`)").action(async (filePath) => {
+  const { runTail } = await import("./tail-stream-UZ42UIWO.js");
+  try {
+    await runTail(filePath);
+  } catch (err) {
+    console.error("[kojee-mcp tail] Error:", err.message);
+    process.exit(1);
+  }
+});
+program.command("doctor").description("Diagnose the kojee wake path (proxy, hook-server, SSE stream, event log, Monitor) and print the exact wake recipe").action(async () => {
+  const { runDoctor } = await import("./doctor-GILTOH2R.js");
+  const code = await runDoctor();
+  process.exit(code);
+});
+program.command("init").description("Install kojee into Claude Code (MCP server entry + hooks). Run after `kojee-mcp pair`.").option("--config-path <path>", "Override default ~/.claude.json").option("--uninstall", "Remove the kojee MCP server entry and hooks").action(async (opts) => {
+  const { loadPairedConfig: loadPairedConfig2 } = await import("./paired-config-RB4SABOS.js");
+  if (loadPairedConfig2() === null && !opts.uninstall) {
+    console.error("Not paired. Run `kojee-mcp pair <code> --url <broker>` first, then re-run `init`.");
+    process.exit(1);
+  }
+  const { runInit, runUninstall } = await import("./install-D2HIPOMT.js");
+  if (opts.uninstall) {
+    const report = runUninstall({ configPath: opts.configPath });
+    console.error(formatUninstall(report));
+  } else {
+    const report = runInit({ configPath: opts.configPath });
+    console.error(formatInit(report));
+  }
+});
+function formatInit(report) {
+  const tick = (s) => {
+    if (s === "added") return "\u2713 added";
+    if (s === "already-installed") return "\u21BB already installed";
+    if (s === "preserved-different") return "\u26A0 preserved (existing entry differs \u2014 left untouched)";
+    if (s === "not-found") return "\u2014 not found";
+    return s ?? "\u2014";
+  };
+  const lines = ["Installing kojee for Claude:"];
+  for (const t of report.targets) {
+    const label = t.kind === "cli" ? "CLI" : "Claude.app";
+    lines.push("");
+    lines.push(`  ${t.path} (${label})`);
+    lines.push(`    mcpServers.kojee           ${tick(t.mcpServer)}`);
+    if (t.kind === "cli") {
+      if (t.hooksPath) {
+        lines.push(`  ${t.hooksPath} (hooks)`);
+      }
+      lines.push(`    hooks.Stop                 ${tick(t.stopHook)}`);
+      lines.push(`    hooks.UserPromptSubmit     ${tick(t.userPromptSubmitHook)}`);
+    } else {
+      lines.push(`    (hooks not applicable for Claude.app agent mode)`);
+    }
+  }
+  lines.push("");
+  const desktopWritten = report.targets.some((t) => t.kind === "desktop" && t.mcpServer === "added");
+  if (desktopWritten) {
+    lines.push(
+      "Existing Claude.app agent-mode sessions snapshotted the previous config",
+      "and won't pick up this change automatically. Start a NEW agent-mode",
+      "session (not a resumed one) to use the updated kojee config.",
+      ""
+    );
+  }
+  lines.push("To verify: in any new CC session, run /mcp and confirm `kojee` is listed.");
+  lines.push("                          run /hooks and confirm both Stop and UserPromptSubmit show the kojee entries.");
+  lines.push("To remove: `kojee-mcp init --uninstall`");
+  return lines.join("\n");
+}
+function formatUninstall(report) {
+  const lines = ["Removing kojee from Claude:"];
+  for (const t of report.targets) {
+    const label = t.kind === "cli" ? "CLI" : "Claude.app";
+    lines.push("");
+    lines.push(`  ${t.path} (${label})`);
+    lines.push(`    mcpServers.kojee   ${t.mcpServer ? "\u2713 removed" : "\u2014 not found"}`);
+    if (t.kind === "cli") {
+      if (t.hooksPath) {
+        lines.push(`  ${t.hooksPath} (hooks)`);
+      }
+      lines.push(`    hook entries       ${t.hooks ? "\u2713 removed" : "\u2014 not found"}`);
+    }
+  }
+  return lines.join("\n");
+}
+program.option("--token <token>", "Gateway token (for token-mode)").option("--url <url>", "Broker base URL (for token-mode; required if --token is passed)").option(
   "--keystore-path <path>",
-  "Path to persisted keypair file (defaults to per-token path under ~/.kojee/)"
+  "Path to keypair file (defaults to per-token path under ~/.kojee/)"
 ).action(async (opts) => {
-  const url = opts.url.replace(/\/+$/, "");
-  const keystorePath = opts.keystorePath ?? deriveKeystorePath(opts.token);
+  let token = opts.token;
+  let url = opts.url;
+  let keystorePath = opts.keystorePath;
+  if (token) {
+    if (!url) {
+      console.error("--url is required when --token is provided");
+      process.exit(1);
+    }
+    url = url.replace(/\/+$/, "");
+    keystorePath ??= deriveKeystorePath(token);
+  } else {
+    const { loadPairedConfig: loadPairedConfig2 } = await import("./paired-config-RB4SABOS.js");
+    const cfg = loadPairedConfig2();
+    if (!cfg) {
+      console.error(
+        "No --token provided and no ~/.kojee/config.json found. Run `kojee-mcp pair <code> --url <broker>` first."
+      );
+      process.exit(1);
+    }
+    token = cfg.token;
+    url = (opts.url ?? cfg.broker_url).replace(/\/+$/, "");
+    keystorePath ??= defaultPairedKeystorePath();
+  }
   try {
-    await startProxy({
-      token: opts.token,
-      url,
-      keystorePath
-    });
+    await startProxy({ token, url, keystorePath });
   } catch (err) {
     console.error("[kojee-mcp] Fatal error:", err);
     process.exit(1);

package/dist/doctor-GILTOH2R.js

@@ -0,0 +1,222 @@
+import {
+  buildMonitorSpawn,
+  buildReplyRecipe
+} from "./chunk-E26AHU6J.js";
+import {
+  deriveDiscoveryKey,
+  findClaudeAncestorPid
+} from "./chunk-BJMASMKX.js";
+import {
+  monitorHeartbeatPath,
+  statusLogPath
+} from "./chunk-VLZADEFC.js";
+import {
+  discoveryPathForKey,
+  readSessionDiscoveryByKey
+} from "./chunk-W6YRLSD4.js";
+import {
+  loadPairedConfig
+} from "./chunk-GBOTBYEP.js";
+
+// src/doctor.ts
+import fs from "fs";
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+function defaultStat(path) {
+  try {
+    const s = fs.statSync(path);
+    return { mtimeMs: s.mtimeMs, size: s.size };
+  } catch {
+    return null;
+  }
+}
+var STATUS_TAIL_BYTES = 64 * 1024;
+function defaultReadLastStatusLine(path) {
+  let fd = null;
+  try {
+    const { size } = fs.statSync(path);
+    const start = Math.max(0, size - STATUS_TAIL_BYTES);
+    const len = size - start;
+    if (len === 0) return null;
+    fd = fs.openSync(path, "r");
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, start);
+    const text = buf.toString("utf8");
+    const statusLines = text.split("\n").filter((l) => l.includes("kojee-status"));
+    return statusLines.length > 0 ? statusLines[statusLines.length - 1] : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+async function collectDoctorReport(deps = {}) {
+  const fetchFn = deps.fetchFn ?? fetch;
+  const isPidAlive = deps.isPidAlive ?? defaultIsPidAlive;
+  const statFile = deps.statFile ?? defaultStat;
+  const readLastStatusLine = deps.readLastStatusLine ?? defaultReadLastStatusLine;
+  const readDiscovery = deps.readDiscovery ?? readSessionDiscoveryByKey;
+  const projectDir = deps.projectDir ?? process.env["CLAUDE_PROJECT_DIR"];
+  const ccPid = deps.ccPid !== void 0 ? deps.ccPid : await findClaudeAncestorPid();
+  const discoveryKey = deriveDiscoveryKey(projectDir, ccPid);
+  const discoveryPath = discoveryPathForKey(discoveryKey);
+  const checks = [];
+  const paired = deps.pairedConfigPresent !== void 0 ? deps.pairedConfigPresent : loadPairedConfig() !== null;
+  checks.push({
+    name: "paired config",
+    ok: paired,
+    detail: paired ? "present" : "MISSING \u2014 run `kojee-mcp pair <code> --url <broker>`"
+  });
+  const discovery = readDiscovery(discoveryKey);
+  let logPath = null;
+  if (!discovery) {
+    checks.push({
+      name: "session discovery",
+      ok: false,
+      detail: `no discovery file at ${discoveryPath} (key=${discoveryKey}) \u2014 proxy not running for this session?`
+    });
+  } else {
+    logPath = discovery.eventLogPath ?? null;
+    const proxyPid = discovery.proxyPid ?? discovery.pid;
+    const alive = typeof proxyPid === "number" && isPidAlive(proxyPid);
+    checks.push({
+      name: "proxy process",
+      ok: alive,
+      detail: alive ? `alive (pid=${proxyPid})` : `DEAD (pid=${proxyPid ?? "?"}) \u2014 restart Claude Code`
+    });
+    const base = `http://127.0.0.1:${discovery.port}`;
+    const health = await probeJson(fetchFn, `${base}/health`);
+    checks.push({
+      name: "hook-server /health",
+      ok: health !== null,
+      detail: health !== null ? "ok" : "unreachable"
+    });
+    const statusProbe = await probeJsonWithStatus(fetchFn, `${base}/status`);
+    if (statusProbe.json === null && statusProbe.routeAbsent) {
+      checks.push({
+        name: "hook-server /status",
+        ok: "unknown",
+        detail: "proxy predates /status (old version) \u2014 stream state unknown; restart the session to upgrade"
+      });
+    } else if (statusProbe.json === null) {
+      checks.push({ name: "hook-server /status", ok: false, detail: "unreachable" });
+    } else {
+      const status = statusProbe.json;
+      const s = status;
+      const connected = s.connected === true;
+      const stale = s.stale === true;
+      const hbAge = s.lastHeartbeatAgeMs;
+      const hbStr = hbAge === null || hbAge === void 0 ? "no heartbeat yet" : `last heartbeat ${Math.round(hbAge / 1e3)}s ago`;
+      checks.push({
+        name: "SSE stream",
+        ok: connected && !stale ? true : connected ? "warn" : false,
+        detail: `${s.stream ?? "?"}; ${hbStr}; subscribed=${s.subscribedTandemCount ?? 0}; reconnects=${s.reconnectCount ?? 0}${stale ? " \u2014 STALE" : ""}`
+      });
+    }
+  }
+  if (logPath) {
+    const logStat = statFile(logPath);
+    if (!logStat) {
+      checks.push({ name: "messages log", ok: false, detail: `missing at ${logPath}` });
+    } else {
+      const ageMs = Date.now() - logStat.mtimeMs;
+      checks.push({
+        name: "messages log",
+        ok: true,
+        detail: `${logPath} (${logStat.size} bytes, mtime ${Math.round(ageMs / 1e3)}s ago)` + (logStat.size === 0 ? " \u2014 no Tandem messages yet (normal)" : "")
+      });
+    }
+    const statusPath = statusLogPath(logPath);
+    const statusStat = statFile(statusPath);
+    const lastStatus = readLastStatusLine(statusPath);
+    if (!statusStat) {
+      checks.push({ name: "status stream", ok: "warn", detail: `no status sibling at ${statusPath}` });
+    } else {
+      const sAge = Date.now() - statusStat.mtimeMs;
+      checks.push({
+        name: "status stream",
+        ok: true,
+        detail: `${statusPath} (${statusStat.size} bytes, mtime ${Math.round(sAge / 1e3)}s ago)` + (lastStatus ? `
+      last status: ${lastStatus.trim()}` : " \u2014 no status lines yet")
+      });
+    }
+    const sentinel = monitorHeartbeatPath(logPath);
+    const sentinelStat = statFile(sentinel);
+    const sentinelFresh = sentinelStat !== null && Date.now() - sentinelStat.mtimeMs < 5e3;
+    checks.push({
+      name: "Monitor (tail) heartbeat",
+      ok: sentinelFresh ? true : "warn",
+      detail: sentinelFresh ? "live (a Monitor is reading the log)" : "no fresh sentinel \u2014 spawn the Monitor (recipe below)"
+    });
+  }
+  checks.push({
+    name: "wire contract",
+    ok: "unknown",
+    detail: "fixture-vs-wire drift is NOT unit-testable \u2014 periodically reconcile the SSE wire `kind` enum (spec [tell,ask,ack,status] vs live [message,status,system]) against a live backend; see tests/fixtures/tandem-event.ts NOTE 7."
+  });
+  const recipe = logPath ? { monitorSpawn: buildMonitorSpawn(logPath), reply: buildReplyRecipe() } : null;
+  const verdict = checks.some((c) => c.ok === false) ? "broken" : checks.some((c) => c.ok === "warn") ? "degraded" : "healthy";
+  return { discoveryKey, discoveryPath, logPath, checks, recipe, verdict };
+}
+async function probeJson(fetchFn, url) {
+  try {
+    const res = await fetchFn(url);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function probeJsonWithStatus(fetchFn, url) {
+  try {
+    const res = await fetchFn(url);
+    if (res.ok) return { json: await res.json(), routeAbsent: false };
+    const routeAbsent = res.status === 404 || res.status === 405;
+    return { json: null, routeAbsent };
+  } catch {
+    return { json: null, routeAbsent: false };
+  }
+}
+function formatDoctorReport(report) {
+  const mark = (ok) => ok === true ? "\u2713" : ok === "warn" ? "\u26A0" : ok === "unknown" ? "?" : "\u2717";
+  const lines = [];
+  lines.push(`kojee-mcp doctor \u2014 verdict: ${report.verdict.toUpperCase()}`);
+  lines.push("");
+  lines.push(`  discovery key: ${report.discoveryKey}`);
+  for (const c of report.checks) {
+    lines.push(`  ${mark(c.ok)} ${c.name}: ${c.detail}`);
+  }
+  lines.push("");
+  if (report.recipe) {
+    lines.push("Wake recipe (spawn once at session start):");
+    lines.push(`  ${report.recipe.monitorSpawn}`);
+    lines.push(`Then ${report.recipe.reply}.`);
+  } else {
+    lines.push("No event-log path resolved \u2014 the proxy isn't running for this session.");
+    lines.push("Start Claude Code (which spawns the kojee proxy), then re-run doctor.");
+  }
+  return lines.join("\n");
+}
+async function runDoctor() {
+  const report = await collectDoctorReport();
+  console.error(formatDoctorReport(report));
+  return report.verdict === "broken" ? 1 : 0;
+}
+export {
+  collectDoctorReport,
+  defaultReadLastStatusLine,
+  formatDoctorReport,
+  runDoctor
+};

package/dist/event-log-R6VW6GAF.js

@@ -0,0 +1,17 @@
+import {
+  STATUS_LINE_PREFIX,
+  monitorHeartbeatPath,
+  nudgeSentinelPath,
+  startEventLog,
+  statusLogPath,
+  sweepStaleEventLogs
+} from "./chunk-VLZADEFC.js";
+import "./chunk-W6YRLSD4.js";
+export {
+  STATUS_LINE_PREFIX,
+  monitorHeartbeatPath,
+  nudgeSentinelPath,
+  startEventLog,
+  statusLogPath,
+  sweepStaleEventLogs
+};

package/dist/event-queue-5YVJFR3E.js

@@ -0,0 +1,43 @@
+// src/tandem/event-queue.ts
+var EventQueue = class {
+  entries = [];
+  capacity;
+  maxAgeMs;
+  constructor(opts = {}) {
+    this.capacity = opts.capacity ?? 200;
+    this.maxAgeMs = opts.maxAgeMs ?? 10 * 6e4;
+  }
+  push(event) {
+    const now = Date.now();
+    this.entries = this.entries.filter((e) => now - e.receivedAt <= this.maxAgeMs);
+    this.entries.push({
+      event,
+      receivedAt: now,
+      deliveredViaChannel: false,
+      deliveredViaMonitor: false,
+      deliveredViaHook: false
+    });
+    while (this.entries.length > this.capacity) this.entries.shift();
+  }
+  markChannelDelivered(eventId) {
+    const entry = this.entries.find((e) => e.event.id === eventId);
+    if (entry) entry.deliveredViaChannel = true;
+  }
+  markMonitorDelivered(eventId) {
+    const entry = this.entries.find((e) => e.event.id === eventId);
+    if (entry) entry.deliveredViaMonitor = true;
+  }
+  takeForHook() {
+    const eligible = this.entries.filter(
+      (e) => !e.deliveredViaChannel && !e.deliveredViaMonitor && !e.deliveredViaHook
+    );
+    for (const e of eligible) e.deliveredViaHook = true;
+    return eligible;
+  }
+  snapshot() {
+    return [...this.entries];
+  }
+};
+export {
+  EventQueue
+};