tandem-editor 0.11.2 → 0.13.0

package/dist/monitor/index.js

@@ -14,12 +14,16 @@ var DEFAULT_MCP_PORT = 3479;
 var TANDEM_REPO_URL = "https://github.com/bloknayrb/tandem";
 var TANDEM_ISSUES_NEW_URL = `${TANDEM_REPO_URL}/issues/new`;
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
-var MAX_WS_PAYLOAD = 10 * 1024 * 1024;
-var IDLE_TIMEOUT = 30 * 60 * 1e3;
 var SESSION_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
 var TANDEM_MODE_DEFAULT = "tandem";
 var CHANNEL_MAX_RETRIES = 5;
 var CHANNEL_RETRY_DELAY_MS = 2e3;
+var CHANNEL_CONNECT_FETCH_TIMEOUT_MS = 1e4;
+var CHANNEL_SSE_INACTIVITY_TIMEOUT_MS = 6e4;
+var CHANNEL_MODE_FETCH_TIMEOUT_MS = 2e3;
+var CHANNEL_AWARENESS_FETCH_TIMEOUT_MS = 5e3;
+var CHANNEL_ERROR_REPORT_TIMEOUT_MS = 3e3;
+var CHANNEL_MAX_SSE_BUFFER_BYTES = 1e6;
 
 // src/shared/cli-runtime.ts
 function resolveTandemUrl(override) {
@@ -34,7 +38,7 @@ function resolveTandemUrlCandidate(override) {
   for (const url of candidates) {
     if (url !== void 0 && url.trim() !== "") return url.trim();
   }
-  return `http://localhost:${DEFAULT_MCP_PORT}`;
+  return `http://127.0.0.1:${DEFAULT_MCP_PORT}`;
 }
 function resolveAuthTokenCandidate(override) {
   const candidates = [
@@ -139,6 +143,12 @@ function formatEventContent(event) {
   }
 }
 
+// src/shared/api-paths.ts
+var API_EVENTS = "/api/events";
+var API_CHANNEL_AWARENESS = "/api/channel-awareness";
+var API_CHANNEL_ERROR = "/api/channel-error";
+var API_MODE = "/api/mode";
+
 // src/shared/fetch-with-timeout.ts
 async function fetchWithTimeout(url, init, timeoutMs) {
   const timeoutSignal = AbortSignal.timeout(timeoutMs);
@@ -4211,107 +4221,104 @@ var ToolErrorCodeSchema = external_exports.enum([
   "FILE_NOT_FOUND",
   "NO_DOCUMENT",
   "INVALID_RANGE",
+  "INVALID_ARGUMENT",
+  "NOT_FOUND",
+  "ANNOTATION_RESOLVED",
   "FORMAT_ERROR",
   "PERMISSION_DENIED"
 ]);
+var ChannelErrorCodeSchema = external_exports.enum(["CHANNEL_CONNECT_FAILED", "MONITOR_CONNECT_FAILED"]);
+var MONITOR_CONNECT_FAILED = "MONITOR_CONNECT_FAILED";
 
-// src/monitor/index.ts
-var IS_VITEST = process.env.VITEST === "true";
-if (!IS_VITEST) {
-  console.log = console.error;
-  console.warn = console.error;
-  console.info = console.error;
-}
-var TANDEM_URL = resolveTandemUrl();
+// src/shared/sse-consumer.ts
 var AWARENESS_DEBOUNCE_MS = 500;
 var AWARENESS_CLEAR_MS = 3e3;
 var MODE_CACHE_TTL_MS = 2e3;
-var MAX_SSE_BUFFER_BYTES = 1e6;
-var CONNECT_FETCH_TIMEOUT_MS = 1e4;
-var SSE_INACTIVITY_TIMEOUT_MS = 6e4;
-var MODE_FETCH_TIMEOUT_MS = 2e3;
-var AWARENESS_FETCH_TIMEOUT_MS = 5e3;
-var ERROR_REPORT_TIMEOUT_MS = 3e3;
 var STABLE_CONNECTION_MS = 6e4;
-var CHANNEL_RETRY_MAX_DELAY_MS = 3e4;
-async function main() {
-  installShutdownHandlers();
-  installStdoutErrorHandler();
-  console.error(`[Monitor] Tandem monitor starting (server: ${TANDEM_URL})`);
-  await getCachedMode().catch(() => {
+var RETRY_MAX_DELAY_MS = 3e4;
+var shutdownTimers = { awarenessTimer: null, clearAwarenessTimer: null, lastDocumentId: null };
+var outstandingAwareness = /* @__PURE__ */ new Set();
+function trackAwareness(p) {
+  outstandingAwareness.add(p);
+  p.finally(() => outstandingAwareness.delete(p));
+}
+var cachedMode = TANDEM_MODE_DEFAULT;
+var cachedModeAt = 0;
+var cachedModeFailedAt = 0;
+var _modeRefreshInFlight = null;
+async function runEventConsumer(opts) {
+  await getCachedMode(opts.tandemUrl, opts.logPrefix).catch(() => {
   });
   let retries = 0;
   let lastEventId;
   while (retries < CHANNEL_MAX_RETRIES) {
     try {
-      await connectAndStream(
-        lastEventId,
-        (id) => {
+      await connectAndStreamOnce(opts, lastEventId, {
+        onEventId: (id) => {
           lastEventId = id;
         },
-        () => {
+        onStable: () => {
           retries = 0;
         }
-      );
+      });
     } catch (err) {
       retries++;
       console.error(
-        `[Monitor] SSE connection failed (${retries}/${CHANNEL_MAX_RETRIES}):`,
+        `${opts.logPrefix} SSE connection failed (${retries}/${CHANNEL_MAX_RETRIES}):`,
         err instanceof Error ? err.message : err
       );
       if (retries >= CHANNEL_MAX_RETRIES) {
-        console.error("[Monitor] SSE connection exhausted, exiting");
+        console.error(`${opts.logPrefix} SSE connection exhausted, reporting error and exiting`);
         try {
           await fetchWithTimeout(
-            `${TANDEM_URL}/api/channel-error`,
+            `${opts.tandemUrl}${API_CHANNEL_ERROR}`,
             {
               method: "POST",
               headers: { "Content-Type": "application/json" },
               body: JSON.stringify({
-                error: "MONITOR_CONNECT_FAILED",
-                message: `Monitor lost connection after ${CHANNEL_MAX_RETRIES} retries.`
+                error: opts.errorCode,
+                message: `${opts.logPrefix} lost connection after ${CHANNEL_MAX_RETRIES} retries.`
               })
             },
-            ERROR_REPORT_TIMEOUT_MS
+            CHANNEL_ERROR_REPORT_TIMEOUT_MS
           );
         } catch (reportErr) {
           console.error(
-            "[Monitor] Could not report failure to server:",
-            reportErr instanceof Error ? reportErr.message : reportErr
+            `${opts.logPrefix} Could not report failure to server:`,
+            describeFetchError(reportErr, API_CHANNEL_ERROR, CHANNEL_ERROR_REPORT_TIMEOUT_MS)
           );
         }
-        process.stdout.write(
-          "Tandem monitor disconnected \u2014 restart Tandem to restore real-time events\n"
-        );
+        opts.onExhaustion?.();
         process.exit(1);
       }
-      const delay = Math.min(
-        CHANNEL_RETRY_DELAY_MS * 2 ** (retries - 1),
-        CHANNEL_RETRY_MAX_DELAY_MS
-      );
+      const delay = Math.min(CHANNEL_RETRY_DELAY_MS * 2 ** (retries - 1), RETRY_MAX_DELAY_MS);
       console.error(
-        `[Monitor] Retrying in ${delay}ms (attempt ${retries}/${CHANNEL_MAX_RETRIES})...`
+        `${opts.logPrefix} Retrying in ${delay}ms (attempt ${retries}/${CHANNEL_MAX_RETRIES})...`
       );
       await new Promise((r) => setTimeout(r, delay));
     }
   }
   console.error(
-    `[Monitor] Retry loop exited unexpectedly (retries=${retries}/${CHANNEL_MAX_RETRIES})`
+    `${opts.logPrefix} Retry loop exited unexpectedly (retries=${retries}/${CHANNEL_MAX_RETRIES})`
   );
   process.exit(1);
 }
-async function connectAndStream(lastEventId, onEventId, onStable = () => {
-}) {
+async function connectAndStreamOnce(opts, lastEventId, cb) {
+  const onStable = cb.onStable ?? (() => {
+  });
   const headers = { Accept: "text/event-stream" };
   if (lastEventId) headers["Last-Event-ID"] = lastEventId;
   const connectCtrl = new AbortController();
   const connectTimer = setTimeout(
     () => connectCtrl.abort(new Error("handshake timeout")),
-    CONNECT_FETCH_TIMEOUT_MS
+    CHANNEL_CONNECT_FETCH_TIMEOUT_MS
   );
   let res;
   try {
-    res = await authFetch(`${TANDEM_URL}/api/events`, { headers, signal: connectCtrl.signal });
+    res = await authFetch(`${opts.tandemUrl}${API_EVENTS}`, {
+      headers,
+      signal: connectCtrl.signal
+    });
   } finally {
     clearTimeout(connectTimer);
   }
@@ -4324,16 +4331,16 @@ async function connectAndStream(lastEventId, onEventId, onStable = () => {
   let lastActivityAt = Date.now();
   let inactivityTimedOut = false;
   const watchdog = setInterval(() => {
-    if (Date.now() - lastActivityAt > SSE_INACTIVITY_TIMEOUT_MS) {
+    if (Date.now() - lastActivityAt > CHANNEL_SSE_INACTIVITY_TIMEOUT_MS) {
       inactivityTimedOut = true;
       reader.cancel(new Error("SSE inactivity timeout")).catch(() => {
       });
     }
-  }, SSE_INACTIVITY_TIMEOUT_MS / 4);
+  }, CHANNEL_SSE_INACTIVITY_TIMEOUT_MS / 4);
   let pendingAwareness = null;
-  function clearAwareness(documentId) {
+  function clearAwarenessNow(documentId) {
     const p = fetchWithTimeout(
-      `${TANDEM_URL}/api/channel-awareness`,
+      `${opts.tandemUrl}${API_CHANNEL_AWARENESS}`,
       {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -4343,11 +4350,15 @@ async function connectAndStream(lastEventId, onEventId, onStable = () => {
           active: false
         })
       },
-      AWARENESS_FETCH_TIMEOUT_MS
+      CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
     ).catch((err) => {
       console.error(
-        "[Monitor] Awareness clear failed:",
-        describeFetchError(err, "/api/channel-awareness clear", AWARENESS_FETCH_TIMEOUT_MS)
+        `${opts.logPrefix} Awareness clear failed:`,
+        describeFetchError(
+          err,
+          `${API_CHANNEL_AWARENESS} clear`,
+          CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
+        )
       );
     });
     trackAwareness(p);
@@ -4358,7 +4369,7 @@ async function connectAndStream(lastEventId, onEventId, onStable = () => {
     pendingAwareness = null;
     if (event.documentId) shutdownTimers.lastDocumentId = event.documentId;
     const p = fetchWithTimeout(
-      `${TANDEM_URL}/api/channel-awareness`,
+      `${opts.tandemUrl}${API_CHANNEL_AWARENESS}`,
       {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -4368,17 +4379,21 @@ async function connectAndStream(lastEventId, onEventId, onStable = () => {
           active: true
         })
       },
-      AWARENESS_FETCH_TIMEOUT_MS
+      CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
     ).catch((err) => {
       console.error(
-        "[Monitor] Awareness update failed:",
-        describeFetchError(err, "/api/channel-awareness update", AWARENESS_FETCH_TIMEOUT_MS)
+        `${opts.logPrefix} Awareness update failed:`,
+        describeFetchError(
+          err,
+          `${API_CHANNEL_AWARENESS} update`,
+          CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
+        )
       );
     });
     trackAwareness(p);
     if (shutdownTimers.clearAwarenessTimer) clearTimeout(shutdownTimers.clearAwarenessTimer);
     shutdownTimers.clearAwarenessTimer = setTimeout(
-      () => clearAwareness(event.documentId),
+      () => clearAwarenessNow(event.documentId),
       AWARENESS_CLEAR_MS
     );
   }
@@ -4396,9 +4411,9 @@ async function connectAndStream(lastEventId, onEventId, onStable = () => {
       }
       lastActivityAt = Date.now();
       buffer += decoder.decode(value, { stream: true });
-      if (buffer.length > MAX_SSE_BUFFER_BYTES) {
+      if (buffer.length > CHANNEL_MAX_SSE_BUFFER_BYTES) {
         throw new Error(
-          `SSE buffer exceeded ${MAX_SSE_BUFFER_BYTES} bytes without a frame boundary`
+          `SSE buffer exceeded ${CHANNEL_MAX_SSE_BUFFER_BYTES} bytes without a frame boundary`
         );
       }
       let boundary;
@@ -4418,29 +4433,35 @@ async function connectAndStream(lastEventId, onEventId, onStable = () => {
           raw = JSON.parse(data);
         } catch (err) {
           console.error(
-            `[Monitor] SSE JSON parse failed (eventId=${eventId ?? "none"}, len=${data.length}): ${err instanceof Error ? err.message : err}. Tail:`,
+            `${opts.logPrefix} SSE JSON parse failed (eventId=${eventId ?? "none"}, len=${data.length}): ${err instanceof Error ? err.message : err}. Tail:`,
             data.slice(Math.max(0, data.length - 200))
           );
+          if (eventId) cb.onEventId(eventId);
           continue;
         }
         const event = parseTandemEvent(raw);
         if (!event) {
           console.error(
-            `[Monitor] SSE event failed validation (eventId=${eventId ?? "none"}): shape mismatch`
+            `${opts.logPrefix} SSE event failed validation (eventId=${eventId ?? "none"}): shape mismatch`
           );
+          if (eventId) cb.onEventId(eventId);
           continue;
         }
         if (event.type !== "chat:message") {
-          refreshMode();
+          refreshMode(opts.tandemUrl, opts.logPrefix);
           if (getModeSync() === "solo") {
-            console.error(`[Monitor] Solo mode: suppressed ${event.type} event`);
-            if (eventId) onEventId(eventId);
+            console.error(`${opts.logPrefix} Solo mode: suppressed ${event.type} event`);
+            if (eventId) cb.onEventId(eventId);
             continue;
           }
         }
-        const content = formatEventContent(event).replace(/\n/g, " ");
-        process.stdout.write(content + "\n");
-        if (eventId) onEventId(eventId);
+        try {
+          await opts.onEvent(event, eventId);
+        } catch (err) {
+          console.error(`${opts.logPrefix} onEvent failed (transport broken?):`, err);
+          throw err;
+        }
+        if (eventId) cb.onEventId(eventId);
         scheduleAwareness(event);
       }
     }
@@ -4454,14 +4475,73 @@ async function connectAndStream(lastEventId, onEventId, onStable = () => {
     pendingAwareness = null;
   }
 }
-var shutdownTimers = { awarenessTimer: null, clearAwarenessTimer: null, lastDocumentId: null };
-var _modeRefreshInFlight = null;
-var outstandingAwareness = /* @__PURE__ */ new Set();
-function trackAwareness(p) {
-  outstandingAwareness.add(p);
-  p.finally(() => outstandingAwareness.delete(p));
+async function fetchMode(tandemUrl) {
+  try {
+    const res = await fetchWithTimeout(
+      `${tandemUrl}${API_MODE}`,
+      {},
+      CHANNEL_MODE_FETCH_TIMEOUT_MS
+    );
+    if (!res.ok) return { ok: false, reason: `status ${res.status}` };
+    const body = await res.json();
+    const parsed = TandemModeSchema.safeParse(body.mode);
+    if (!parsed.success) return { ok: false, reason: `invalid mode ${JSON.stringify(body.mode)}` };
+    return { ok: true, mode: parsed.data };
+  } catch (err) {
+    return { ok: false, reason: describeFetchError(err, API_MODE, CHANNEL_MODE_FETCH_TIMEOUT_MS) };
+  }
+}
+async function getCachedMode(tandemUrl, logPrefix = "[Tandem]") {
+  const now = Date.now();
+  if (now - cachedModeAt < MODE_CACHE_TTL_MS && cachedModeAt !== 0) return cachedMode;
+  const result = await fetchMode(tandemUrl);
+  if (!result.ok) {
+    if (cachedModeAt !== 0) {
+      console.error(
+        `${logPrefix} Mode check failed (${result.reason}), preserving last known mode '${cachedMode}'`
+      );
+      return cachedMode;
+    }
+    console.error(
+      `${logPrefix} Mode check failed (${result.reason}), no prior mode \u2014 using cold-start default '${TANDEM_MODE_DEFAULT}'`
+    );
+    cachedMode = TANDEM_MODE_DEFAULT;
+    return TANDEM_MODE_DEFAULT;
+  }
+  cachedMode = result.mode;
+  cachedModeAt = now;
+  return cachedMode;
 }
-async function finalClearAwareness() {
+function getModeSync() {
+  return cachedMode;
+}
+function refreshMode(tandemUrl, logPrefix) {
+  if (_modeRefreshInFlight) return;
+  const now = Date.now();
+  if (now - cachedModeAt < MODE_CACHE_TTL_MS) return;
+  if (now - cachedModeFailedAt < MODE_CACHE_TTL_MS) return;
+  _modeRefreshInFlight = (async () => {
+    try {
+      const result = await fetchMode(tandemUrl);
+      if (result.ok) {
+        cachedMode = result.mode;
+        cachedModeAt = Date.now();
+        cachedModeFailedAt = 0;
+      } else {
+        cachedModeFailedAt = Date.now();
+        console.error(
+          `${logPrefix} Background mode refresh failed (${result.reason}), keeping cached`
+        );
+      }
+    } finally {
+      _modeRefreshInFlight = null;
+    }
+  })().catch((err) => {
+    console.error(`${logPrefix} refreshMode unexpected error:`, err);
+    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) {
@@ -4470,7 +4550,7 @@ async function finalClearAwareness() {
   if (shutdownTimers.lastDocumentId === null) return true;
   try {
     const res = await fetchWithTimeout(
-      `${TANDEM_URL}/api/channel-awareness`,
+      `${tandemUrl}${API_CHANNEL_AWARENESS}`,
       {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -4480,27 +4560,35 @@ async function finalClearAwareness() {
           active: false
         })
       },
-      AWARENESS_FETCH_TIMEOUT_MS
+      CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
     );
     if (!res.ok) {
-      console.error(`[Monitor] Shutdown awareness clear returned ${res.status}`);
+      console.error(`${logPrefix} Shutdown awareness clear returned ${res.status}`);
       return false;
     }
     return true;
   } catch (err) {
     console.error(
-      "[Monitor] Shutdown awareness clear failed:",
-      describeFetchError(err, "/api/channel-awareness shutdown", AWARENESS_FETCH_TIMEOUT_MS)
+      `${logPrefix} Shutdown awareness clear failed:`,
+      describeFetchError(
+        err,
+        `${API_CHANNEL_AWARENESS} shutdown`,
+        CHANNEL_AWARENESS_FETCH_TIMEOUT_MS
+      )
     );
     return false;
   }
 }
-async function shutdownMonitor(signal) {
-  console.error(`[Monitor] Received ${signal}, clearing awareness and exiting`);
-  const ok = await finalClearAwareness();
-  process.exit(ok ? 0 : 1);
+function _resetSseConsumerStateForTests() {
+  cachedMode = TANDEM_MODE_DEFAULT;
+  cachedModeAt = 0;
+  cachedModeFailedAt = 0;
+  _modeRefreshInFlight = null;
+  shutdownTimers.awarenessTimer = null;
+  shutdownTimers.clearAwarenessTimer = null;
+  shutdownTimers.lastDocumentId = null;
+  outstandingAwareness.clear();
 }
-var shutdownForTests = shutdownMonitor;
 function _setLastDocumentIdForTests(id) {
   shutdownTimers.lastDocumentId = id;
 }
@@ -4510,11 +4598,63 @@ function _getLastDocumentIdForTests() {
 function _addOutstandingAwarenessForTests(p) {
   trackAwareness(p);
 }
+
+// src/monitor/index.ts
+var IS_VITEST = process.env.VITEST === "true";
+if (!IS_VITEST) {
+  console.log = console.error;
+  console.warn = console.error;
+  console.info = console.error;
+}
+var TANDEM_URL = resolveTandemUrl();
+var LOG_PREFIX = "[Monitor]";
+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("[Monitor] Shutdown handler failed:", err);
+      console.error(`${LOG_PREFIX} Shutdown handler failed:`, err);
       process.exit(1);
     });
   };
@@ -4522,79 +4662,21 @@ function installShutdownHandlers() {
   process.on("SIGTERM", () => handler("SIGTERM"));
 }
 function onStdoutError(err) {
-  console.error("[Monitor] stdout error (plugin-host pipe likely closed):", 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);
 }
-var cachedMode = TANDEM_MODE_DEFAULT;
-var cachedModeAt = 0;
-var cachedModeFailedAt = 0;
-async function fetchMode() {
-  try {
-    const res = await fetchWithTimeout(`${TANDEM_URL}/api/mode`, {}, MODE_FETCH_TIMEOUT_MS);
-    if (!res.ok) return { ok: false, reason: `status ${res.status}` };
-    const body = await res.json();
-    const parsed = TandemModeSchema.safeParse(body.mode);
-    if (!parsed.success) return { ok: false, reason: `invalid mode ${JSON.stringify(body.mode)}` };
-    return { ok: true, mode: parsed.data };
-  } catch (err) {
-    return { ok: false, reason: describeFetchError(err, "/api/mode", MODE_FETCH_TIMEOUT_MS) };
-  }
-}
-async function getCachedMode() {
-  const now = Date.now();
-  if (now - cachedModeAt < MODE_CACHE_TTL_MS) return cachedMode;
-  const result = await fetchMode();
-  if (!result.ok) {
-    console.error(`[Monitor] Mode check failed (${result.reason}), failing closed to 'solo'`);
-    cachedMode = "solo";
-    return "solo";
-  }
-  cachedMode = result.mode;
-  cachedModeAt = now;
-  return cachedMode;
+async function getCachedMode2() {
+  return getCachedMode(TANDEM_URL, LOG_PREFIX);
 }
-function getModeSync() {
-  return cachedMode;
-}
-function refreshMode() {
-  if (_modeRefreshInFlight) return;
-  const now = Date.now();
-  if (now - cachedModeAt < MODE_CACHE_TTL_MS) return;
-  if (now - cachedModeFailedAt < MODE_CACHE_TTL_MS) return;
-  _modeRefreshInFlight = (async () => {
-    try {
-      const result = await fetchMode();
-      if (result.ok) {
-        cachedMode = result.mode;
-        cachedModeAt = Date.now();
-        cachedModeFailedAt = 0;
-      } else {
-        cachedModeFailedAt = Date.now();
-        console.error(
-          `[Monitor] Background mode refresh failed (${result.reason}), keeping cached`
-        );
-      }
-    } finally {
-      _modeRefreshInFlight = null;
-    }
-  })().catch((err) => {
-    console.error("[Monitor] refreshMode unexpected error:", err);
-    cachedModeFailedAt = Date.now();
-  });
+function getModeSync2() {
+  return getModeSync();
 }
 function _resetMonitorStateForTests() {
-  cachedMode = TANDEM_MODE_DEFAULT;
-  cachedModeAt = 0;
-  cachedModeFailedAt = 0;
-  _modeRefreshInFlight = null;
-  shutdownTimers.awarenessTimer = null;
-  shutdownTimers.clearAwarenessTimer = null;
-  shutdownTimers.lastDocumentId = null;
-  outstandingAwareness.clear();
+  _resetSseConsumerStateForTests();
   process.removeAllListeners("SIGINT");
   process.removeAllListeners("SIGTERM");
 }
@@ -4609,21 +4691,20 @@ var __thisFileNormalized = normalizeForCompare(fileURLToPath(import.meta.url));
 var isDirectRun = typeof process.argv[1] === "string" && normalizeForCompare(process.argv[1]) === __thisFileNormalized;
 if (isDirectRun && !IS_VITEST) {
   main().catch((err) => {
-    console.error("[Monitor] Fatal error:", err);
+    console.error(`${LOG_PREFIX} Fatal error:`, err);
     process.exit(1);
   });
 }
 export {
-  _addOutstandingAwarenessForTests,
-  _getLastDocumentIdForTests,
+  _addOutstandingAwarenessForTests2 as _addOutstandingAwarenessForTests,
+  _getLastDocumentIdForTests2 as _getLastDocumentIdForTests,
   _monitorTestExports,
   _resetMonitorStateForTests,
-  _setLastDocumentIdForTests,
+  _setLastDocumentIdForTests2 as _setLastDocumentIdForTests,
   connectAndStream,
-  getCachedMode,
-  getModeSync,
+  getCachedMode2 as getCachedMode,
+  getModeSync2 as getModeSync,
   main,
-  shutdownForTests,
   shutdownMonitor
 };
 //# sourceMappingURL=index.js.map