kojee-mcp 0.7.1 → 0.7.3

package/dist/pending-state-6TVRR63P.js

@@ -0,0 +1,134 @@
+import {
+  recordDrained
+} from "./chunk-IZN7IZPW.js";
+
+// src/tandem/pending-state.ts
+var PENDING_TOOL_RUNTIMES = /* @__PURE__ */ new Set(["codex"]);
+var LEDGER_DRAIN_RUNTIMES = /* @__PURE__ */ new Set(["codex"]);
+var TANDEM_PENDING_TOOL_NAME = "tandem_pending";
+var REJOIN_ADVICE = "if you were in rooms before a restart, rejoin with your previous seat_name \u2014 the room rebinds your seat";
+var MAX_TRACKED_ROOMS = 256;
+function usableCursor(cursor) {
+  if (!Number.isFinite(cursor) || cursor < 0) return null;
+  return Math.floor(cursor);
+}
+function createSessionPendingState() {
+  const rooms = /* @__PURE__ */ new Map();
+  let clock = 0;
+  const touch = (tandemId) => {
+    let rec = rooms.get(tandemId);
+    if (rec === void 0) {
+      rec = { seat: false, delivered: 0, drained: 0, touched: 0 };
+      rooms.set(tandemId, rec);
+      evictIfOverCap(tandemId);
+    }
+    rec.touched = ++clock;
+    return rec;
+  };
+  const evictIfOverCap = (justInserted) => {
+    while (rooms.size > MAX_TRACKED_ROOMS) {
+      let victim = null;
+      let victimTouched = Number.POSITIVE_INFINITY;
+      let victimPending = true;
+      for (const [id, rec] of rooms) {
+        if (id === justInserted) continue;
+        const isPending = rec.delivered > rec.drained;
+        const better = victimPending && !isPending || victimPending === isPending && rec.touched < victimTouched;
+        if (better) {
+          victim = id;
+          victimTouched = rec.touched;
+          victimPending = isPending;
+        }
+      }
+      if (victim === null) return;
+      rooms.delete(victim);
+    }
+  };
+  return {
+    noteSeat(tandemId) {
+      if (tandemId) touch(tandemId).seat = true;
+    },
+    dropSeat(tandemId) {
+      rooms.delete(tandemId);
+    },
+    noteDelivered(tandemId, cursor) {
+      const next = usableCursor(cursor);
+      if (tandemId === "" || next === null) return;
+      const rec = touch(tandemId);
+      rec.delivered = Math.max(rec.delivered, next);
+    },
+    noteDrained(tandemId, cursor) {
+      const next = usableCursor(cursor);
+      if (tandemId === "" || next === null) return;
+      const rec = touch(tandemId);
+      rec.drained = Math.max(rec.drained, next);
+    },
+    snapshot(filterTandemId) {
+      const pending = [];
+      let sessionHasSeats = false;
+      for (const [tandemId, rec] of rooms) {
+        if (!rec.seat && rec.delivered === 0) continue;
+        sessionHasSeats = true;
+        if (filterTandemId !== void 0 && tandemId !== filterTandemId) continue;
+        if (rec.delivered > rec.drained) {
+          pending.push({
+            tandem_id: tandemId,
+            since_cursor: rec.drained,
+            delivered_cursor: rec.delivered
+          });
+        }
+      }
+      const advice = !sessionHasSeats ? REJOIN_ADVICE : pending.length > 0 ? "drain each pending room with tandem_messages(tandem_id, since=since_cursor), then reply in the room" : "no pending Tandem events for this window";
+      return { pending, session_has_seats: sessionHasSeats, advice };
+    },
+    trackedRoomCount() {
+      return rooms.size;
+    }
+  };
+}
+function tandemPendingToolDefinition() {
+  return {
+    name: TANDEM_PENDING_TOOL_NAME,
+    description: "Report THIS window's pending Tandem events \u2014 answered entirely from this proxy's in-process state (rooms this session holds seats in, cursors delivered on this proxy's stream, cursors drained through this proxy's tool calls). Precise per-window: it never reads shared machine-wide files. Call it when the turn-end bell says events may be pending, then drain each listed room with tandem_messages(tandem_id, since=since_cursor) and reply in the room. If it lists nothing, the bell was for another window \u2014 ignore it. After a proxy restart it correctly reports nothing until you rejoin (use your previous seat_name \u2014 the room rebinds your seat).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tandem_id: {
+          type: "string",
+          description: "Optional: report only this room."
+        }
+      }
+    }
+  };
+}
+function installPendingTool(runtime, registry) {
+  if (!PENDING_TOOL_RUNTIMES.has(runtime)) return null;
+  const state = createSessionPendingState();
+  registry.registerLocalTool(tandemPendingToolDefinition(), (args) => {
+    const filter = typeof args["tandem_id"] === "string" && args["tandem_id"] !== "" ? args["tandem_id"] : void 0;
+    return {
+      content: [{ type: "text", text: JSON.stringify(state.snapshot(filter)) }],
+      isError: false
+    };
+  });
+  return state;
+}
+function createRuntimeDrainHook(runtime, state) {
+  const writesLedger = LEDGER_DRAIN_RUNTIMES.has(runtime);
+  if (!writesLedger && state === null) return void 0;
+  return (tandemId, cursor) => {
+    if (writesLedger) recordDrained(tandemId, cursor);
+    state?.noteDrained(tandemId, cursor);
+  };
+}
+export {
+  LEDGER_DRAIN_RUNTIMES,
+  MAX_TRACKED_ROOMS,
+  PENDING_TOOL_RUNTIMES,
+  REJOIN_ADVICE,
+  TANDEM_PENDING_TOOL_NAME,
+  createRuntimeDrainHook,
+  createSessionPendingState,
+  installPendingTool,
+  tandemPendingToolDefinition
+};

package/dist/{registry-ZZZ26WGA.js → registry-2QS42EQF.js}

@@ -1,17 +1,24 @@
+import {
+  CODEX_STATUS_HEARTBEAT_MS,
+  sweepDeadCodexStatusFiles,
+  writeCodexStatus
+} from "./chunk-XLRF5ATG.js";
 import {
   createCachedOpenclawWakeResolver,
   postOpenclawWake
 } from "./chunk-NE2F5CKS.js";
 import "./chunk-PHXO5P25.js";
 import {
-  codexPendingMarkerPath
-} from "./chunk-EBYUJM3H.js";
+  recordDelivered
+} from "./chunk-IZN7IZPW.js";
 import {
   claudeCodeAdapter
-} from "./chunk-UPJV7GBE.js";
-import "./chunk-GNLCUJBK.js";
-import "./chunk-5DHIUN73.js";
-import "./chunk-SSW5AQSR.js";
+} from "./chunk-TCWIXG5C.js";
+import "./chunk-A4IOKD4Z.js";
+import {
+  VERSION
+} from "./chunk-5DHIUN73.js";
+import "./chunk-FJUAMJHU.js";
 import "./chunk-PPTKGWFF.js";
 
 // src/delivery/lib/fanout.ts
@@ -42,16 +49,16 @@ async function deliverEvent(event, sinks) {
   } catch (err) {
     console.error("[event-stream] webhook enqueue failed:", err);
   }
-  if (sinks.codexPendingMarker) {
+  if (sinks.pendingLedger) {
     try {
-      const pending = sinks.codexPendingMarker(event);
+      const pending = sinks.pendingLedger(event);
       if (pending && typeof pending.then === "function") {
         pending.catch((err) => {
-          console.error("[event-stream] codex pending-marker write failed:", err);
+          console.error("[event-stream] pending-ledger record failed:", err);
         });
       }
     } catch (err) {
-      console.error("[event-stream] codex pending-marker write failed:", err);
+      console.error("[event-stream] pending-ledger record failed:", err);
     }
   }
 }
@@ -119,8 +126,8 @@ function createClaudeCodeDelivery() {
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
       const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
       const { createWebhookSink } = await import("./webhook-sink-N6AUTFL3.js");
-      const { startEventStream } = await import("./event-stream-KRYWEYWO.js");
-      const { createMcpServer } = await import("./server-ITPFQVTK.js");
+      const { startEventStream } = await import("./event-stream-WPN3EN7C.js");
+      const { createMcpServer } = await import("./server-DU3LFS32.js");
       const { deriveDiscoveryKey } = await import("./ancestry-A2F5KQ6A.js");
       const { resolveSharedSessionId } = await import("./cc-session-id-RURNIHHC.js");
       sweepStaleDiscovery();
@@ -282,6 +289,9 @@ function createClaudeCodeDelivery() {
         // claude-code, so it is always the channel-capable path.
         formatChannelNotification,
         ...webhookSink ? { webhookSink } : {}
+        // No pendingLedger sink: claude-code's event log is already
+        // room-qualified (tandem=<id> cursor=<n> per line) and its stop-hook
+        // /poll feed is per-session — the general ledger adds nothing here.
       });
     },
     async stop() {
@@ -302,7 +312,7 @@ function createClaudeCodeDelivery() {
 }
 
 // src/delivery/hermes.ts
-function createWebhookDelivery(name, codexPendingMarker) {
+function createWebhookDelivery(name, pendingLedger) {
   let eventLog = null;
   let webhookSink = null;
   let streamHandle = null;
@@ -313,8 +323,8 @@ function createWebhookDelivery(name, codexPendingMarker) {
       const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
       const { createWebhookSink } = await import("./webhook-sink-N6AUTFL3.js");
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
-      const { startEventStream } = await import("./event-stream-KRYWEYWO.js");
-      const { createMcpServer } = await import("./server-ITPFQVTK.js");
+      const { startEventStream } = await import("./event-stream-WPN3EN7C.js");
+      const { createMcpServer } = await import("./server-DU3LFS32.js");
       sweepStaleEventLogs();
       eventLog = startEventLog({
         key: ctx.instanceKey,
@@ -384,8 +394,8 @@ function createWebhookDelivery(name, codexPendingMarker) {
       await deliverEvent(event, {
         ...eventLog ? { eventLog } : {},
         ...webhookSink ? { webhookSink } : {},
-        // OPTIONAL codex-only marker sink (undefined ⇒ byte-identical hermes path).
-        ...codexPendingMarker ? { codexPendingMarker } : {}
+        // OPTIONAL pending-ledger sink (undefined ⇒ byte-identical hermes path).
+        ...pendingLedger ? { pendingLedger } : {}
       });
     },
     async stop() {
@@ -402,39 +412,92 @@ function createWebhookDelivery(name, codexPendingMarker) {
   };
 }
 
-// src/delivery/codex-pending-marker.ts
-import fsp from "fs/promises";
-import path from "path";
-import crypto from "crypto";
-var MAX_MARKER_BODY_CHARS = 128;
-var ensuredDir = null;
-async function writeCodexPendingMarker(event) {
-  if (!Number.isFinite(event.cursor) || event.cursor < 1) return;
-  const markerPath = codexPendingMarkerPath();
-  const dir = path.dirname(markerPath);
-  const tmp = `${markerPath}.tmp-${process.pid}-${crypto.randomUUID()}`;
-  try {
-    if (ensuredDir !== dir) {
-      await fsp.mkdir(dir, { recursive: true });
-      ensuredDir = dir;
+// src/delivery/codex.ts
+var MAX_TANDEMS_SEEN = 32;
+function createCodexDelivery(onDelivered) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let deliveredEvents = 0;
+  let lastLedgerWriteAt = null;
+  let lastEventAt = null;
+  let subscribedTandemCount = -1;
+  const tandemsSeen = /* @__PURE__ */ new Set();
+  let heartbeat = null;
+  const ledgerSink = (event) => {
+    recordDelivered(event.tandem_id, event.cursor);
+    if (typeof event.tandem_id === "string" && event.tandem_id !== "" && Number.isFinite(event.cursor) && event.cursor >= 1) {
+      lastLedgerWriteAt = (/* @__PURE__ */ new Date()).toISOString();
     }
-    const tandem = String(event.tandem_id ?? "").replace(/\s+/g, "");
-    const cursorTok = String(Math.floor(event.cursor));
-    const body = (tandem ? `${cursorTok} ${tandem}` : cursorTok).slice(0, MAX_MARKER_BODY_CHARS);
-    await fsp.writeFile(tmp, body, { mode: 384 });
-    await fsp.rename(tmp, markerPath);
-  } catch {
-    ensuredDir = null;
-    try {
-      await fsp.unlink(tmp);
-    } catch {
+    if (onDelivered) {
+      try {
+        onDelivered(event);
+      } catch {
+      }
     }
-  }
-}
-
-// src/delivery/codex.ts
-function createCodexDelivery() {
-  return createWebhookDelivery("codex", writeCodexPendingMarker);
+  };
+  const inner = createWebhookDelivery("codex", ledgerSink);
+  const innerDeliver = inner.deliver.bind(inner);
+  const deliverWithStatus = async (event) => {
+    await innerDeliver(event);
+    deliveredEvents += 1;
+    lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
+    const tid = typeof event.tandem_id === "string" ? event.tandem_id : "";
+    if (tid && tandemsSeen.size < MAX_TANDEMS_SEEN) tandemsSeen.add(tid);
+    refreshStatus();
+  };
+  inner.deliver = deliverWithStatus;
+  const streamStatus = () => {
+    const health = inner.health?.();
+    const stream = health?.detail?.stream;
+    const iso = (v) => typeof v === "number" && Number.isFinite(v) ? new Date(v).toISOString() : null;
+    return {
+      connected: health ? health.connected : null,
+      connected_since: iso(stream?.["connectedSince"]),
+      last_event_at: iso(stream?.["lastEventAt"]) ?? lastEventAt,
+      reconnects: typeof stream?.["reconnectCount"] === "number" ? stream["reconnectCount"] : null
+    };
+  };
+  const snapshot = () => ({
+    pid: process.pid,
+    proxy_version: VERSION,
+    started_at: startedAt,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    stream: streamStatus(),
+    delivered_events: deliveredEvents,
+    last_marker_write_at: lastLedgerWriteAt,
+    subscribed_tandem_count: subscribedTandemCount,
+    tandems_seen: [...tandemsSeen]
+  });
+  const refreshStatus = () => {
+    void writeCodexStatus(snapshot()).catch(() => {
+    });
+  };
+  return {
+    name: inner.name,
+    async start(ctx) {
+      const started = await inner.start(ctx);
+      subscribedTandemCount = ctx.tandemMembershipCount;
+      void sweepDeadCodexStatusFiles().catch(() => {
+      });
+      refreshStatus();
+      heartbeat = setInterval(refreshStatus, CODEX_STATUS_HEARTBEAT_MS);
+      heartbeat.unref?.();
+      started.teardown.push(() => {
+        if (heartbeat) clearInterval(heartbeat);
+        heartbeat = null;
+      });
+      return started;
+    },
+    deliver: deliverWithStatus,
+    async stop() {
+      if (heartbeat) clearInterval(heartbeat);
+      heartbeat = null;
+      await inner.stop();
+      refreshStatus();
+    },
+    health() {
+      return inner.health?.() ?? { connected: null };
+    }
+  };
 }
 
 // src/delivery/openclaw.ts
@@ -454,8 +517,8 @@ function createOpenclawDelivery(deps = {}) {
     async start(ctx) {
       const { startEventLog, sweepStaleEventLogs } = await import("./event-log-2NBJEIEP.js");
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
-      const { startEventStream } = await import("./event-stream-KRYWEYWO.js");
-      const { createMcpServer } = await import("./server-ITPFQVTK.js");
+      const { startEventStream } = await import("./event-stream-WPN3EN7C.js");
+      const { createMcpServer } = await import("./server-DU3LFS32.js");
       sweepStaleEventLogs();
       eventLog = startEventLog({
         key: ctx.instanceKey,
@@ -549,7 +612,7 @@ function selectDelivery(runtime, opts) {
     return createClaudeCodeDelivery();
   }
   if (runtime === "codex") {
-    return createCodexDelivery();
+    return createCodexDelivery(opts.onDelivered);
   }
   if (runtime === "openclaw") {
     return createOpenclawDelivery();

package/dist/{server-ITPFQVTK.js → server-DU3LFS32.js}

@@ -3,15 +3,17 @@ import {
   buildNonChannelInstructions,
   createMcpServer,
   executeToolCall,
+  extractDrainCursor,
   startMcpServer
-} from "./chunk-GNLCUJBK.js";
+} from "./chunk-A4IOKD4Z.js";
 import "./chunk-5DHIUN73.js";
-import "./chunk-SSW5AQSR.js";
+import "./chunk-FJUAMJHU.js";
 import "./chunk-PPTKGWFF.js";
 export {
   buildChannelInstructions,
   buildNonChannelInstructions,
   createMcpServer,
   executeToolCall,
+  extractDrainCursor,
   startMcpServer
 };

package/dist/{setup-handler-JFM45NCN.js → setup-handler-44ASXYMS.js}

@@ -3,17 +3,17 @@ import {
   pairSlotFor,
   reconcileConnectPairSlot,
   runWizard
-} from "./chunk-UFHGZUST.js";
+} from "./chunk-XPIW4N55.js";
+import "./chunk-6XWTUDWW.js";
 import "./chunk-E6WMFMM2.js";
-import "./chunk-KPMD72FY.js";
-import "./chunk-QJFMU4QC.js";
+import {
+  isWizardRuntime
+} from "./chunk-77HWBSRH.js";
+import "./chunk-TMCNB4JH.js";
 import "./chunk-D6JKFJ6A.js";
 import "./chunk-EIH2LNF4.js";
 import "./chunk-RDLF4NQC.js";
 import "./chunk-SQL56SEB.js";
-import {
-  isWizardRuntime
-} from "./chunk-77HWBSRH.js";
 import "./chunk-V5VZPYMZ.js";
 import {
   runPair
@@ -26,7 +26,7 @@ import "./chunk-MIEI4PLB.js";
 import "./chunk-6G6YYST6.js";
 import "./chunk-U5HHHRXA.js";
 import "./chunk-5DHIUN73.js";
-import "./chunk-SSW5AQSR.js";
+import "./chunk-FJUAMJHU.js";
 
 // src/wizard/setup-handler.ts
 var SETUP_SUPPORTED_RUNTIMES = ["claude-code", "codex"];

package/dist/{stop-hook-5ABGTC2O.js → stop-hook-N6TX4YQT.js}

@@ -1,10 +1,10 @@
+import "./chunk-XLKGPGZT.js";
 import {
   resolveHookDiscovery
 } from "./chunk-WBXU27BF.js";
 import {
   readHookStdin
 } from "./chunk-LSUB6QMP.js";
-import "./chunk-XLKGPGZT.js";
 import {
   controlTokenAuthHeaders
 } from "./chunk-GKXHKR3B.js";
@@ -19,7 +19,7 @@ import "./chunk-67F67AQ6.js";
 import "./chunk-U5HHHRXA.js";
 import {
   buildMonitorNudge
-} from "./chunk-SSW5AQSR.js";
+} from "./chunk-FJUAMJHU.js";
 import "./chunk-XJEBJIQE.js";
 import "./chunk-KNEJTD6G.js";
 

package/dist/{tail-stream-NBGHHBS4.js → tail-stream-N43D53RC.js}

@@ -6,8 +6,10 @@ import {
 } from "./chunk-TNZITJAB.js";
 import "./chunk-67F67AQ6.js";
 import {
+  LOG_HEARTBEAT_INTERVAL_MS,
+  UNARMED_FALLBACK_MS,
   createAdaptiveWatchdog
-} from "./chunk-FSKGQ6GT.js";
+} from "./chunk-HI42GBQ3.js";
 import "./chunk-Z5LPNJQ6.js";
 import "./chunk-MIEI4PLB.js";
 import "./chunk-U5HHHRXA.js";
@@ -19,17 +21,87 @@ var HEARTBEAT_FIELDS_RE = /(^|\s)status=heartbeat(\s|$)/;
 var ROTATED_FIELDS_RE = /(^|\s)status=rotated(\s|$)/;
 var ROTATED_DROPPED_RE = /(^|\s)dropped=(\d+)(\s|$)/;
 var MESSAGE_CURSOR_RE = /(^|\s)cursor=(\S+)(\s|$)/;
-var HEARTBEAT_STALE_FLOOR_MS = envInt("KOJEE_TAIL_STALE_MS", 12e4);
+var TAIL_ABS_FLOOR_MS = 5 * 6e4;
+var TAIL_FLOOR_SLACK_MS = 3e4;
+var TAIL_STALE_FLOOR_MS = envInt(
+  "KOJEE_TAIL_STALE_MS",
+  Math.max(TAIL_ABS_FLOOR_MS, 2 * LOG_HEARTBEAT_INTERVAL_MS + TAIL_FLOOR_SLACK_MS)
+);
 var STALE_CHECK_INTERVAL_MS = envInt("KOJEE_TAIL_CHECK_MS", 5e3);
+var TAIL_REWARN_AFTER_MS = 30 * 6e4;
+var TAIL_HEALTHY_RESET_MS = 30 * 6e4;
+var TAIL_BACKOFF_CAP_CYCLES = 3;
 function envInt(name, fallback) {
   const v = Number.parseInt(process.env[name] ?? "", 10);
   return Number.isFinite(v) && v > 0 ? v : fallback;
 }
+function createStallDetector(startNow, options = {}) {
+  const heartbeatIntervalMs = options.heartbeatIntervalMs ?? LOG_HEARTBEAT_INTERVAL_MS;
+  const floorMs = options.floorMs ?? Math.max(TAIL_ABS_FLOOR_MS, 2 * heartbeatIntervalMs + TAIL_FLOOR_SLACK_MS);
+  const rewarnAfterMs = options.rewarnAfterMs ?? TAIL_REWARN_AFTER_MS;
+  const healthyResetMs = options.healthyResetMs ?? TAIL_HEALTHY_RESET_MS;
+  const backoffCapCycles = options.backoffCapCycles ?? TAIL_BACKOFF_CAP_CYCLES;
+  const watchdog = createAdaptiveWatchdog({
+    floorMs,
+    multiplier: options.multiplier,
+    unarmedFallbackMs: options.unarmedFallbackMs
+  });
+  let lastLifeAt = startNow;
+  let stale = false;
+  let warnedAt = 0;
+  let rewarned = false;
+  let backoffCycles = 0;
+  let lastRecoveredAt = null;
+  let outageSpanned = false;
+  return {
+    onLife(now) {
+      const silentMs = now - lastLifeAt;
+      lastLifeAt = now;
+      if (stale) {
+        stale = false;
+        rewarned = false;
+        backoffCycles = Math.min(backoffCycles + 1, backoffCapCycles);
+        lastRecoveredAt = now;
+        return { kind: "recovered", silentMs };
+      }
+      if (backoffCycles > 0 && lastRecoveredAt !== null && now - lastRecoveredAt >= healthyResetMs) {
+        backoffCycles = 0;
+      }
+      return null;
+    },
+    onHeartbeat(now) {
+      if (outageSpanned) {
+        watchdog.resetCadenceAnchor();
+        outageSpanned = false;
+      }
+      watchdog.onHeartbeat(now);
+    },
+    check(now) {
+      if (stale) {
+        if (!rewarned && now - warnedAt >= rewarnAfterMs) {
+          rewarned = true;
+          return { kind: "rewarn", silentMs: now - lastLifeAt };
+        }
+        return null;
+      }
+      const base = watchdog.armedThresholdMs() ?? (options.unarmedFallbackMs ?? UNARMED_FALLBACK_MS);
+      const thresholdMs = Math.min(
+        base * 2 ** backoffCycles,
+        Math.max(floorMs, rewarnAfterMs)
+      );
+      const silentMs = now - lastLifeAt;
+      if (silentMs < thresholdMs) return null;
+      stale = true;
+      warnedAt = now;
+      rewarned = false;
+      outageSpanned = true;
+      return { kind: "warn", silentMs, thresholdMs };
+    }
+  };
+}
 async function runTail(messagesPath) {
   const statusPath = statusLogPath(messagesPath);
-  let lastLifeAt = Date.now();
-  const watchdog = createAdaptiveWatchdog({ floorMs: HEARTBEAT_STALE_FLOOR_MS });
-  let staleAnnounced = false;
+  const detector = createStallDetector(Date.now(), { floorMs: TAIL_STALE_FLOOR_MS });
   const heartbeatPath = monitorHeartbeatPath(messagesPath);
   const touchHeartbeat = () => {
     const now = /* @__PURE__ */ new Date();
@@ -44,10 +116,10 @@ async function runTail(messagesPath) {
   };
   let lastCursor = null;
   function onMessageLine(line) {
-    lastLifeAt = Date.now();
-    if (staleAnnounced) {
-      staleAnnounced = false;
-      process.stdout.write("[kojee] stream recovered \u2014 events flowing again.\n");
+    if (detector.onLife(Date.now())?.kind === "recovered") {
+      process.stdout.write(
+        "[kojee] stream recovered \u2014 events flowing again (recovery is automatic; no action needed).\n"
+      );
     }
     const cm = MESSAGE_CURSOR_RE.exec(line);
     if (cm && cm[2]) lastCursor = cm[2];
@@ -59,12 +131,12 @@ async function runTail(messagesPath) {
     const m = STATUS_LINE_RE.exec(line);
     const fields = m ? m[1] ?? "" : "";
     if (HEARTBEAT_FIELDS_RE.test(fields)) {
-      watchdog.onHeartbeat(now);
+      detector.onHeartbeat(now);
     }
-    lastLifeAt = now;
-    if (staleAnnounced) {
-      staleAnnounced = false;
-      process.stdout.write("[kojee] stream recovered \u2014 heartbeats resumed.\n");
+    if (detector.onLife(now)?.kind === "recovered") {
+      process.stdout.write(
+        "[kojee] stream recovered \u2014 heartbeats resumed (the stall was transient, likely idle-period timing or brief host load; no action needed).\n"
+      );
     }
     if (statusSeeded && ROTATED_FIELDS_RE.test(fields)) {
       const dm = ROTATED_DROPPED_RE.exec(fields);
@@ -88,13 +160,20 @@ async function runTail(messagesPath) {
   ]).catch(() => {
   });
   const staleTimer = setInterval(() => {
-    if (staleAnnounced) return;
     const now = Date.now();
-    if (!watchdog.shouldAbort(lastLifeAt, now)) return;
-    staleAnnounced = true;
-    const silentMs = now - lastLifeAt;
+    const signal = detector.check(now);
+    if (!signal) return;
+    const silentS = Math.round(signal.silentMs / 1e3);
+    if (signal.kind === "rewarn") {
+      process.stdout.write(
+        `[kojee] WARNING: still no events or heartbeat after ${silentS}s \u2014 the earlier stall never recovered, so the stream may be dead; run \`npx kojee-mcp doctor\`.
+`
+      );
+      return;
+    }
+    const thresholdS = Math.round((signal.thresholdMs ?? 0) / 1e3);
     process.stdout.write(
-      `[kojee] WARNING: no events or heartbeat for ${Math.round(silentMs / 1e3)}s (learned cadence) \u2014 stream may be dead; run \`npx kojee-mcp doctor\`.
+      `[kojee] WARNING: no events or heartbeat for ${silentS}s (threshold ${thresholdS}s) \u2014 stream may be dead, but this is often benign (idle stream, or brief host load delaying heartbeats) and recovery is automatic; if it persists, run \`npx kojee-mcp doctor\`.
 `
     );
   }, STALE_CHECK_INTERVAL_MS);
@@ -198,6 +277,7 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 export {
+  createStallDetector,
   makeFollower,
   runTail
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kojee-mcp",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/skills/using-tandems/SKILL.md

@@ -23,9 +23,9 @@ not your every sentence. When the hats tension, the principal wins.
 - **Sync before you speak.** Catch up to the latest cursor; a gap means you missed messages — fetch them. Never answer from a stale view.
 - **Answer in the channel you were approached in.** Approached in the **room** (the Tandem)? Answer in the room. Approached in your **session** (your principal's direct channel — including gate / review surfaces)? Answer in the session. It does **not** matter whether it's a 1:1 or a group chat — match the inbound channel; never migrate a conversation to a channel it didn't start in. Use `tandem_send` only for what originates in or belongs to the room, not to echo your session replies.
 - **Close every loop.** Taking an item, done (with evidence), or blocked (name the blocker + who clears it) — say so. Silence is a bug on a team.
-- **Plan your wake path per task, re-plan as it changes.** Heads-down → mentions + a heartbeat floor; waiting on one reply → listen/filter to that seat; co-working → wake on all; standby → mentions + hourly heartbeat. Move your filter deliberately, and tell the room your posture.
+- **Plan your wake path per task, re-plan as it changes.** Heads-down → mentions + a heartbeat floor; waiting on one reply → listen/filter to that seat; co-working → wake on all; standby → mentions + hourly heartbeat. Move your filter deliberately, and tell the room your posture when it changes — a plain re-join/reconnect with the same posture needs no check-in message.
 - **Don't assume others use the room well — engineer around it.** Poll for gaps, confirm receipt when it matters, resend a mention that didn't land, never block forever on a peer who may be dark.
-- **Signal cheap, wake rarely.** Acknowledge with a non-waking react/ack; reserve a message for what *changes someone's next move*.
+- **Signal cheap, wake rarely.** Acknowledge with a reaction or ack (non-waking); reserve a message for what *changes someone's next move*. Cheap signals are reactions/acks — never `kind=status` messages (status is lifecycle-only, system-generated for joined/left events; never send it yourself).
 - **Take your lane.** Don't duplicate, collide, or redo a teammate's work; settle unclear ownership in one message first.
 - **Be a reliable, considerate presence.** Recover yourself from a dropped session — don't make others restart you — and pace your load on the shared account.
 

package/dist/chunk-EBYUJM3H.js

@@ -1,14 +0,0 @@
-// src/hooks/codex-pending-path.ts
-import os from "os";
-import path from "path";
-function codexPendingMarkerPath() {
-  return path.join(os.homedir(), ".kojee", "codex-pending");
-}
-function codexPendingAckPath() {
-  return codexPendingMarkerPath() + ".ack";
-}
-
-export {
-  codexPendingMarkerPath,
-  codexPendingAckPath
-};