tesseract-agent 0.9.34 → 0.9.35

package/dist-bundle/cli.js

@@ -30072,7 +30072,22 @@ function autoCompactEnvFor(pct2, supplied) {
     return {};
   return { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(Math.round(pct2)) };
 }
-var OVERFLOW_MAX_TRIES, OVERFLOW_COMPACT_MESSAGE, OVERFLOW_RESUME_MESSAGE;
+function shouldCompactProactively(a) {
+  if (a.mode === "off")
+    return "skip";
+  if (a.inFlight)
+    return "skip";
+  if (typeof a.pct !== "number" || !Number.isFinite(a.pct) || a.pct <= 0 || a.pct >= 100)
+    return "skip";
+  if (typeof a.usagePct !== "number" || !Number.isFinite(a.usagePct))
+    return "skip";
+  if (a.usagePct < a.pct)
+    return "reset";
+  if (typeof a.lastCompactPct === "number" && a.usagePct < a.lastCompactPct + PROACTIVE_REGROWTH_POINTS)
+    return "skip";
+  return "compact";
+}
+var OVERFLOW_MAX_TRIES, OVERFLOW_COMPACT_MESSAGE, OVERFLOW_RESUME_MESSAGE, PROACTIVE_REGROWTH_POINTS;
 var init_context_recovery = __esm({
   "../../packages/agent-core/dist/context-recovery.js"() {
     "use strict";
@@ -30080,6 +30095,7 @@ var init_context_recovery = __esm({
     OVERFLOW_MAX_TRIES = 3;
     OVERFLOW_COMPACT_MESSAGE = "/compact";
     OVERFLOW_RESUME_MESSAGE = "Continue.";
+    PROACTIVE_REGROWTH_POINTS = 5;
   }
 });
 
@@ -32595,6 +32611,65 @@ var init_agent_manager = __esm({
       setVerifierLlm(fn) {
         this.verifierLlm = fn;
       }
+      /**
+       * PROACTIVE compaction: keep an unattended run comfortably inside the window instead of
+       * letting it walk into the wall.
+       *
+       * The renderer already does this at the user's threshold — but only for a conversation
+       * it has on screen. Headless there was nothing, and the fallback everyone assumed
+       * (`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`, which the desktop also sets) turns out to be inert:
+       * measured against Claude Code 2.1.241, setting it to 25 left `autoCompactThreshold` at
+       * the CLI's own 167000 and the context climbed straight past 25%, 33%, 42%, 52% without
+       * compacting. So an unattended run honoured no threshold at all; its only protection was
+       * the wall-hit recovery, which is a last resort, not a setting.
+       *
+       * Only when NOBODY IS WATCHING. With a client attached the renderer owns this, and both
+       * doing it would spend two turns on one reclaim.
+       */
+      async maybeCompactProactively(live) {
+        const pct2 = (() => {
+          try {
+            return this.autoCompactPct?.();
+          } catch {
+            return void 0;
+          }
+        })();
+        const usage2 = await this.getContextUsage(live.sessionId).catch(() => null);
+        const verdict = shouldCompactProactively({
+          mode: live.unattended ?? "off",
+          pct: pct2,
+          usagePct: typeof usage2?.percentage === "number" ? usage2.percentage : null,
+          lastCompactPct: live.proactiveCompactedAt ?? null,
+          inFlight: live.overflowCompacting === true
+        });
+        if (verdict === "reset") {
+          live.proactiveCompactedAt = void 0;
+          return;
+        }
+        if (verdict !== "compact")
+          return;
+        live.proactiveCompactedAt = usage2?.percentage ?? 0;
+        live.overflowCompacting = true;
+        try {
+          log(`auto-compact: ${Math.round(usage2?.percentage ?? 0)}% of the window used (threshold ${String(pct2)}%) \u2014 compacting`);
+          await this.sendMessage({
+            message: OVERFLOW_COMPACT_MESSAGE,
+            url: "",
+            sessionId: live.sessionId,
+            projectDir: live.cwd,
+            origin: live.origin,
+            browserId: live.browserId,
+            windowId: live.windowId,
+            autoContinuation: true,
+            ...live.unattended === "auto" ? { unattended: true } : {},
+            ...live.model ? { model: live.model } : {}
+          });
+        } catch (err2) {
+          log("auto-compact failed:", err2 instanceof Error ? err2.message : String(err2));
+        } finally {
+          live.overflowCompacting = false;
+        }
+      }
       /**
        * Compact and resume after this session outgrew the window, when nobody is watching.
        *
@@ -32630,7 +32705,12 @@ var init_agent_manager = __esm({
               ...live.unattended === "auto" ? { unattended: true } : {},
               ...live.model ? { model: live.model } : {}
             };
-            await this.sendMessage({ ...base, message: OVERFLOW_COMPACT_MESSAGE });
+            live.overflowCompacting = true;
+            try {
+              await this.sendMessage({ ...base, message: OVERFLOW_COMPACT_MESSAGE });
+            } finally {
+              live.overflowCompacting = false;
+            }
             await this.sendMessage({ ...base, message: OVERFLOW_RESUME_MESSAGE });
           }
         });
@@ -32903,6 +32983,7 @@ ${full.slice(-8e3)}`;
           });
           if (action.kind === "done" || action.kind === "capped")
             return;
+          await this.maybeCompactProactively(live);
           await this.sendMessage({
             message: action.prompt,
             url: "",
@@ -34671,8 +34752,12 @@ CRITICAL RULES:
                 ...identityEnv(),
                 ...options.env,
                 // params.env carries CLAUDE_AUTOCOMPACT_PCT_OVERRIDE from the user's setting
-                // (getAgentSettings) — IF this CLI honours it, native mid-run compaction fires
-                // at the same threshold as our renderer-side proactive `/compact`.
+                // (getAgentSettings). MEASURED INERT on Claude Code 2.1.241: set to 25, the
+                // reported `autoCompactThreshold` stayed at the CLI's own 167000 and the
+                // conversation climbed past 25%, 33%, 42%, 52% without compacting once. Kept
+                // because it costs nothing and other CLI versions may honour it — but nothing
+                // depends on it: `maybeCompactProactively` is what actually holds an unattended
+                // run to the user's threshold.
                 ...params.env ?? {},
                 // FALLBACK, not an override: `params.env` wins whenever the desktop supplied a
                 // threshold. This fills the gap for a turn the daemon originated itself, which
@@ -35083,10 +35168,13 @@ ${RV_PHASE_DIRECTIVE}` : ""), live.sessionId) },
                   });
                 }
                 const limitRejection = live.usageLimitRejection ?? (r.subtype === "success" ? assistantUsageLimitFallback(live.lastAssistantContent) : void 0);
+                const resultText = typeof r.result === "string" ? r.result : "";
+                const textOverflow = r.is_error === true && isContextOverflow(resultText);
                 if (limitRejection) {
                   reportUsageLimit(limitRejection, turnSid);
-                } else if (r.subtype === "success") {
-                  live.overflowTries = 0;
+                } else if (r.subtype === "success" && !textOverflow) {
+                  if (!live.overflowCompacting)
+                    live.overflowTries = 0;
                   if (!turnStreamed && Array.isArray(live.lastAssistantContent)) {
                     for (const blk of live.lastAssistantContent) {
                       if (blk?.type === "thinking" && typeof blk.thinking === "string" && blk.thinking) {
@@ -35123,6 +35211,8 @@ ${RV_PHASE_DIRECTIVE}` : ""), live.sessionId) },
                   const didWork = typeof r.num_turns !== "number" || r.num_turns > 1;
                   if (live.rv && !continuable)
                     void this.runVerification(live, typeof r.result === "string" ? r.result : "", didWork);
+                  else
+                    void this.maybeCompactProactively(live);
                 } else if (live.interrupted) {
                   live.interrupted = false;
                   this.clearStopWatchdog(live);
@@ -35131,8 +35221,8 @@ ${RV_PHASE_DIRECTIVE}` : ""), live.sessionId) },
                   emit2({ type: "agent:status", sessionId: turnSid, status: "idle" });
                 } else {
                   const errors = Array.isArray(r.errors) ? r.errors.map(String).filter(Boolean) : [];
-                  const detail = errors.length > 0 ? errors.join("\n") : `Agent returned ${r.subtype}${r.stop_reason ? ` (stop_reason: ${r.stop_reason})` : ""}`;
-                  const contextHit = r.subtype === "error_max_turns" ? "max_turns" : String(r.subtype).includes("context") || r.stop_reason === "model_context_window_exceeded" ? "context_window" : void 0;
+                  const detail = textOverflow ? resultText : errors.length > 0 ? errors.join("\n") : `Agent returned ${r.subtype}${r.stop_reason ? ` (stop_reason: ${r.stop_reason})` : ""}`;
+                  const contextHit = r.subtype === "error_max_turns" ? "max_turns" : textOverflow || String(r.subtype).includes("context") || r.stop_reason === "model_context_window_exceeded" ? "context_window" : void 0;
                   const looksTransient = !contextHit && /overloaded|\b429\b|\b529\b|rate.?limit|too many requests|throttl|\b50[0234]\b|service unavailable|bad gateway|gateway timeout|timed? ?out|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE|ENOTFOUND|ENETUNREACH|EAI_AGAIN|socket hang up|network error|temporarily unavailable/i.test(detail);
                   log("Session result error:", turnSid, JSON.stringify({ subtype: r.subtype, stop_reason: r.stop_reason, errors, looksTransient }));
                   live.resultErrorReported = true;
@@ -36204,6 +36294,7 @@ __export(dist_exports2, {
   OVERFLOW_RESUME_MESSAGE: () => OVERFLOW_RESUME_MESSAGE,
   PRESENT_TOOL_NAMES: () => PRESENT_TOOL_NAMES,
   PRESENT_TOOL_SPECS: () => PRESENT_TOOL_SPECS,
+  PROACTIVE_REGROWTH_POINTS: () => PROACTIVE_REGROWTH_POINTS,
   SCREEN_CONTROL_SPECS: () => SCREEN_CONTROL_SPECS,
   SessionStore: () => SessionStore,
   TOKENS_CSS_FILE: () => TOKENS_CSS_FILE,
@@ -36266,6 +36357,7 @@ __export(dist_exports2, {
   setTokenPath: () => setTokenPath,
   setTokenSegments: () => setTokenSegments,
   setUnattendedLogSink: () => setUnattendedLogSink,
+  shouldCompactProactively: () => shouldCompactProactively,
   specParametersJsonSchema: () => specParametersJsonSchema,
   stringifyValue: () => stringifyValue,
   stripPromptPrefix: () => stripPromptPrefix,
@@ -75350,7 +75442,15 @@ var OPENCODE_ACP = {
   // Its own threshold, since ACP gives us no way to ASK it to compact. Without this the
   // auto-compact slider could not reach OpenCode at all and it compacted only at its own
   // hardcoded 95%.
-  tokenCompaction: { configEnv: "OPENCODE_CONFIG", bufferPath: ["compaction", "buffer"] },
+  // `reserved`, not `buffer` — read out of OpenCode's own bundle (1.18.21):
+  //   let l = cfg.compaction?.reserved ?? Math.min(20000, maxOutputTokens(model))
+  //   return model.limit.input ? max(0, model.limit.input - l) : max(0, context - maxOutput)
+  // `buffer` was not a key it knows, so this reserve had never once taken effect. Note the
+  // second branch: even under the right name the reserve is IGNORED for a model that does
+  // not declare `limit.input` — which is most of them (1329 of 7482 on models.dev), gpt-4o
+  // and gpt-4o-mini included. So this is worth writing correctly, and is NOT something the
+  // slider can rely on; `shouldCompactProactively` is what actually holds the line.
+  tokenCompaction: { configEnv: "OPENCODE_CONFIG", bufferPath: ["compaction", "reserved"] },
   compactCommand: "/compact",
   // ACP fallback; the HTTP RPC below is preferred
   // `opencode acp` serves the full HTTP API on the same process — verified: the ACP session
@@ -76446,7 +76546,56 @@ ${text9}`);
     const all = await listSessionsFor(projectDir);
     return all.filter((row) => row.title.toLowerCase().includes(q) || (sessionBodies.get(row.id) ?? "").includes(q));
   }
+  const proactiveCompactedAt = /* @__PURE__ */ new Map();
+  const sessionRekey = /* @__PURE__ */ new Map();
   const overflowTries = /* @__PURE__ */ new Map();
+  function contextUsageFor(sessionId) {
+    const model = sessionResolvedModel.get(sessionId) ?? sessionConfig.get(sessionId)?.currentModel;
+    const rep = sessionReported.get(sessionId);
+    const total = rep?.used ?? sessionUsage.get(sessionId)?.total;
+    const maxTokens = rep?.size ?? contextWindowFor(model) ?? void 0;
+    if (total === void 0 || !maxTokens)
+      return null;
+    return {
+      totalTokens: total,
+      maxTokens,
+      percentage: Math.min(100, Math.round(total / maxTokens * 1e3) / 10),
+      ...model ? { model } : {}
+    };
+  }
+  async function maybeCompactProactively(sid, params) {
+    try {
+      if (params.autoContinuation)
+        return;
+      if (!declared.contextCompaction)
+        return;
+      const live = sessionRekey.get(sid) ?? sid;
+      const usage2 = contextUsageFor(live);
+      const verdict = shouldCompactProactively({
+        mode: unattendedModeFor({ optedIn: params.unattended, origin: params.origin }),
+        pct: readDaemonAgentSettings().autoCompactPct,
+        usagePct: typeof usage2?.percentage === "number" ? usage2.percentage : null,
+        lastCompactPct: proactiveCompactedAt.get(live) ?? null,
+        inFlight: false
+      });
+      if (verdict === "reset") {
+        proactiveCompactedAt.delete(live);
+        return;
+      }
+      if (verdict !== "compact")
+        return;
+      proactiveCompactedAt.set(live, usage2?.percentage ?? 0);
+      console.warn(`[${LABEL2}] auto-compact: ${Math.round(usage2?.percentage ?? 0)}% of the window used \u2014 compacting`);
+      await sendMessage({ ...params, message: OVERFLOW_COMPACT_MESSAGE, sessionId: live, autoContinuation: true });
+      const now2 = sessionRekey.get(live) ?? live;
+      if (now2 !== live) {
+        proactiveCompactedAt.set(now2, proactiveCompactedAt.get(live) ?? 0);
+        proactiveCompactedAt.delete(live);
+      }
+    } catch (err2) {
+      console.warn(`[${LABEL2}] auto-compact failed:`, err2 instanceof Error ? err2.message : String(err2));
+    }
+  }
   async function sendMessage(params) {
     const origin = params.origin;
     const fail4 = (sessionId, error51, transient = false) => send4({ type: "chat:error", sessionId, clientRequestId: params.clientRequestId, error: error51, ...transient ? { transient: true } : {} }, origin);
@@ -76562,6 +76711,12 @@ ${text9}`);
       }
       sessionIndex.record({ id: next, cwd: params.projectDir, title, updatedAt: Date.now() });
       sessionIndex.forget(from);
+      sessionRekey.set(from, next);
+      const spentTries = overflowTries.get(from);
+      if (spentTries !== void 0) {
+        overflowTries.set(next, spentTries);
+        overflowTries.delete(from);
+      }
       send4({ type: "session:created", sessionId: next, clientRequestId: params.clientRequestId }, origin);
       send4({ type: "chat:complete", sessionId: next, clientRequestId: params.clientRequestId, messageId: randomUUID11(), result: "Compacted this conversation to free up context.", turnId: randomUUID11() }, origin);
       send4({ type: "agent:status", sessionId: next, clientRequestId: params.clientRequestId, status: "idle" }, origin);
@@ -76721,7 +76876,10 @@ ${text9}`);
           }
         }
       }
-      overflowTries.delete(sid);
+      void maybeCompactProactively(sid, params);
+      if (!(params.autoContinuation === true && params.message === OVERFLOW_COMPACT_MESSAGE)) {
+        overflowTries.delete(sid);
+      }
       send4({ type: "chat:complete", sessionId: sid, clientRequestId: params.clientRequestId, messageId, result: finalText, turnId, ...res?.stopReason ? { stopReason: res.stopReason } : {} }, origin);
       send4({ type: "agent:status", sessionId: sid, clientRequestId: params.clientRequestId, status: "idle" }, origin);
     } catch (e) {
@@ -76737,7 +76895,7 @@ ${text9}`);
           context: { sessionId: sid, engine: engine.id },
           compactAndResume: async () => {
             await sendMessage({ ...params, message: OVERFLOW_COMPACT_MESSAGE, sessionId: sid, autoContinuation: true });
-            await sendMessage({ ...params, message: OVERFLOW_RESUME_MESSAGE, sessionId: sid, autoContinuation: true });
+            await sendMessage({ ...params, message: OVERFLOW_RESUME_MESSAGE, sessionId: sessionRekey.get(sid) ?? sid, autoContinuation: true });
           }
         });
         if (recovered)
@@ -77015,21 +77173,7 @@ ${detail}` : detail, !overflow);
       }
     },
     ...declared.contextUsage ? {
-      getContextUsage: async (sessionId) => {
-        const model = sessionResolvedModel.get(sessionId) ?? sessionConfig.get(sessionId)?.currentModel;
-        const rep = sessionReported.get(sessionId);
-        const total = rep?.used ?? sessionUsage.get(sessionId)?.total;
-        const maxTokens = rep?.size ?? contextWindowFor(model) ?? void 0;
-        if (total === void 0 || !maxTokens)
-          return null;
-        const usage2 = {
-          totalTokens: total,
-          maxTokens,
-          percentage: Math.min(100, Math.round(total / maxTokens * 1e3) / 10),
-          ...model ? { model } : {}
-        };
-        return usage2;
-      }
+      getContextUsage: async (sessionId) => contextUsageFor(sessionId)
     } : {},
     ...declared.costTracking ? {
       getSessionCost: async (sessionId) => {
@@ -78173,7 +78317,61 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
     })();
     return initPromise;
   }
+  const proactiveCompactedAt = /* @__PURE__ */ new Map();
   const overflowTries = /* @__PURE__ */ new Map();
+  function contextUsageFor(sessionId) {
+    const u = tokenUsage.get(sessionId);
+    if (!u?.window)
+      return null;
+    const current = u.lastTotal || u.total;
+    const usage2 = {
+      // `last`, NOT `total`. Measured: `total` is CUMULATIVE over the conversation and grows
+      // by exactly the previous turn's tokens (142,394 → 162,119 after a 19,725-token turn),
+      // so it can never fall. Reporting it as context usage meant the meter climbed past
+      // 100% of a 258k window on a conversation nowhere near full, never came down after a
+      // compaction, and — because this figure is what the proactive threshold reads — asked
+      // for compaction after compaction with the number refusing to move.
+      //
+      // `last.totalTokens` is the CURRENT context: the input the model actually saw on the
+      // most recent turn, which is what a window is measured against and what drops when a
+      // compaction succeeds.
+      // `|| u.total`, not `?? u.total`: the single writer stores `u.last?.totalTokens ?? 0`,
+      // so a missing `last` arrives here as 0 — which `??` passes straight through and the
+      // meter reads 0% on a full conversation. Under-reporting is the dangerous direction,
+      // because the proactive threshold then never fires and the context hits a hard
+      // overflow instead of compacting. Observed live: a `thread/tokenUsage/updated` whose
+      // `total` was all zeros while `last.totalTokens` was 4666, and the reverse.
+      totalTokens: current,
+      maxTokens: u.window,
+      percentage: Math.min(100, Math.round(current / u.window * 1e3) / 10)
+    };
+    return usage2;
+  }
+  async function maybeCompactProactively(threadId, params) {
+    try {
+      if (params.autoContinuation)
+        return;
+      const usage2 = contextUsageFor(threadId);
+      const verdict = shouldCompactProactively({
+        mode: unattendedModeFor({ optedIn: params.unattended, origin: params.origin }),
+        pct: readDaemonAgentSettings().autoCompactPct,
+        usagePct: typeof usage2?.percentage === "number" ? usage2.percentage : null,
+        lastCompactPct: proactiveCompactedAt.get(threadId) ?? null,
+        inFlight: false
+      });
+      if (verdict === "reset") {
+        proactiveCompactedAt.delete(threadId);
+        return;
+      }
+      if (verdict !== "compact")
+        return;
+      proactiveCompactedAt.set(threadId, usage2?.percentage ?? 0);
+      console.warn(`[${LABEL2}] auto-compact: ${Math.round(usage2?.percentage ?? 0)}% of the window used \u2014 compacting`);
+      await sendMessage({ ...params, message: OVERFLOW_COMPACT_MESSAGE, sessionId: threadId, autoContinuation: true });
+    } catch (err2) {
+      console.warn(`[${LABEL2}] auto-compact failed:`, err2 instanceof Error ? err2.message : String(err2));
+    }
+  }
   async function sendMessage(params) {
     const origin = params.origin;
     const cfg2 = resolve16(ENGINE_ID2);
@@ -78363,7 +78561,10 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
           }
         });
       }
-      overflowTries.delete(threadId);
+      void maybeCompactProactively(threadId, params);
+      if (!(params.autoContinuation === true && params.message === OVERFLOW_COMPACT_MESSAGE)) {
+        overflowTries.delete(threadId);
+      }
       send4({ type: "chat:complete", sessionId: threadId, clientRequestId: params.clientRequestId, messageId, result: finalText, turnId, ...stopReason ? { stopReason } : {} }, origin);
       send4({ type: "agent:status", sessionId: threadId, clientRequestId: params.clientRequestId, status: "idle" }, origin);
     } catch (e) {
@@ -78707,34 +78908,7 @@ ${text9}`;
       await transport.request("config/mcpServer/reload", {}).catch(() => {
       });
     },
-    getContextUsage: async (sessionId) => {
-      const u = tokenUsage.get(sessionId);
-      if (!u?.window)
-        return null;
-      const current = u.lastTotal || u.total;
-      const usage2 = {
-        // `last`, NOT `total`. Measured: `total` is CUMULATIVE over the conversation and grows
-        // by exactly the previous turn's tokens (142,394 → 162,119 after a 19,725-token turn),
-        // so it can never fall. Reporting it as context usage meant the meter climbed past
-        // 100% of a 258k window on a conversation nowhere near full, never came down after a
-        // compaction, and — because this figure is what the proactive threshold reads — asked
-        // for compaction after compaction with the number refusing to move.
-        //
-        // `last.totalTokens` is the CURRENT context: the input the model actually saw on the
-        // most recent turn, which is what a window is measured against and what drops when a
-        // compaction succeeds.
-        // `|| u.total`, not `?? u.total`: the single writer stores `u.last?.totalTokens ?? 0`,
-        // so a missing `last` arrives here as 0 — which `??` passes straight through and the
-        // meter reads 0% on a full conversation. Under-reporting is the dangerous direction,
-        // because the proactive threshold then never fires and the context hits a hard
-        // overflow instead of compacting. Observed live: a `thread/tokenUsage/updated` whose
-        // `total` was all zeros while `last.totalTokens` was 4666, and the reverse.
-        totalTokens: current,
-        maxTokens: u.window,
-        percentage: Math.min(100, Math.round(current / u.window * 1e3) / 10)
-      };
-      return usage2;
-    },
+    getContextUsage: async (sessionId) => contextUsageFor(sessionId),
     /** toolInjection, host half. Codex reads MCP servers from its config, so a change takes
      *  effect on the next install (the flag is reset so the write actually re-runs). */
     setInjectedMcpServers: (servers) => {
@@ -93088,7 +93262,12 @@ function setHostDaemonRole(on) {
     teardownHostRole();
   }
 }
+function rdeskOrMeshOnlyBuild() {
+  return process.env.CCB_RDESK_ONLY === "1" || process.env.CCB_MESH_ONLY === "1";
+}
 function sharingEnabled() {
+  if (rdeskOrMeshOnlyBuild())
+    return false;
   return sharing || hostDaemonRole || process.env.CCB_HOST_DAEMON === "1";
 }
 var serverSelected = false;
@@ -94064,6 +94243,8 @@ function stopHeartbeat() {
   }
 }
 function registerAsHost() {
+  if (rdeskOrMeshOnlyBuild())
+    return;
   void ensureP2pReady();
   const kind = process.env.CCB_HOST_KIND === "cloud" ? "cloud" : void 0;
   const name = kind === "cloud" ? "Cloud agent" : hostname4();
@@ -103152,7 +103333,7 @@ async function runDaemon(opts = {}) {
     }
   } catch {
   }
-  if (ownsMachine)
+  if (ownsMachine && !WE_ARE_RDESK_ONLY)
     setHostDaemonRole(true);
   const localToken = randomBytes10(24).toString("hex");
   const sendToViewer = (kind, sessionId, clientId, msg) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tesseract-agent",
-  "version": "0.9.34",
+  "version": "0.9.35",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",