tesseract-agent 0.11.2 → 0.11.3

package/dist-bundle/cli.js

@@ -37920,6 +37920,9 @@ import { spawn as spawn2, execSync, execFileSync } from "node:child_process";
 function setBrowserExtensionProbe(fn) {
   browserExtensionConnected = fn;
 }
+function isTurnBearingFrame(type) {
+  return type === "assistant" || type === "stream_event" || type === "user";
+}
 function findUserInstalledClaude(binName) {
   const home = homedir3();
   const abs = [
@@ -39980,50 +39983,72 @@ ${full.slice(-8e3)}`;
         let cappedOut = false;
         let narrated = false;
         const turn = live.turnSeq;
-        for (; ; ) {
-          if (live.rv !== rv) {
-            log(`[work] quiescence wait for ${live.sessionId} dropped \u2014 another run owns the session`);
-            this.clearWorkNarration(live, narrated);
-            return;
-          }
-          if (live.reaped) {
-            log(`[work] quiescence wait for ${live.sessionId} dropped \u2014 the session was torn down`);
-            this.clearWorkNarration(live, narrated);
-            return;
-          }
-          if (live.turnSeq !== turn) {
-            log(`[work] quiescence wait for ${live.sessionId} superseded by a new turn`);
-            this.clearWorkNarration(live, narrated);
-            return;
-          }
-          const v = live.ledger.verdict(Date.now());
-          if (v.quiescent)
-            break;
-          if (Date.now() - started2 >= QUIESCENCE_MAX_MS) {
-            cappedOut = true;
-            break;
-          }
-          if (!narrated && live.sessionId) {
-            narrated = true;
-            this.send({
-              type: "agent:narration",
-              sessionId: live.sessionId,
-              text: `Waiting for ${v.waiting.length} background ${v.waiting.length === 1 ? "task" : "tasks"} to finish\u2026`,
-              engineLabel: "Claude Code"
-            }, live.origin);
+        live.gradePending = true;
+        try {
+          for (; ; ) {
+            if (live.rv !== rv) {
+              log(`[work] quiescence wait for ${live.sessionId} dropped \u2014 another run owns the session`);
+              this.clearWorkNarration(live, narrated);
+              return;
+            }
+            if (live.gone) {
+              log(`[work] quiescence wait for ${live.sessionId} dropped \u2014 the session was torn down`);
+              this.clearWorkNarration(live, narrated);
+              return;
+            }
+            if (live.turnSeq !== turn) {
+              log(`[work] quiescence wait for ${live.sessionId} superseded by a new turn`);
+              this.clearWorkNarration(live, narrated);
+              return;
+            }
+            const v = live.ledger.verdict(Date.now());
+            if (v.quiescent)
+              break;
+            if (Date.now() - started2 >= QUIESCENCE_MAX_MS) {
+              cappedOut = true;
+              break;
+            }
+            if (!narrated && live.sessionId) {
+              narrated = true;
+              this.send({
+                type: "agent:narration",
+                sessionId: live.sessionId,
+                text: `Waiting for ${v.waiting.length} background ${v.waiting.length === 1 ? "task" : "tasks"} to finish\u2026`,
+                engineLabel: "Claude Code"
+              }, live.origin);
+            }
+            await new Promise((res) => setTimeout(res, QUIESCENCE_POLL_MS));
           }
-          await new Promise((res) => setTimeout(res, QUIESCENCE_POLL_MS));
+          this.clearWorkNarration(live, narrated);
+          live.ledger.sweep(Date.now());
+          const outstanding = live.ledger.summarize(Date.now());
+          if (cappedOut)
+            log(`[work] quiescence cap reached for ${live.sessionId}; grading anyway with: ${outstanding.join("; ") || "(nothing outstanding)"}`);
+          else if (Date.now() - started2 > 1e3)
+            log(`[work] ${live.sessionId} settled after ${Math.round((Date.now() - started2) / 1e3)}s \u2014 grading now`);
+          if (!cappedOut && outstanding.length)
+            log(`[work] grading with work still in flight: ${outstanding.join("; ")}`);
+          await this.runVerification(live, finalText, didWork);
+        } finally {
+          live.gradePending = false;
+        }
+      }
+      /**
+       * Mark a turn the engine started on its own as busy — exactly what a send does.
+       *
+       * Bumping `turnSeq` is deliberate: a quiescence wait for the PREVIOUS turn must see itself
+       * superseded, the same way it would by a turn we started, rather than grade the old final
+       * text while the new turn runs.
+       */
+      adoptSelfStartedTurn(live) {
+        log(`[turn] ${live.sessionId || "(pending)"} started a turn on its own \u2014 marking busy`);
+        live.streaming = true;
+        live.turnSeq++;
+        live.lastActivity = Date.now();
+        if (live.idleTimer) {
+          clearTimeout(live.idleTimer);
+          live.idleTimer = void 0;
         }
-        this.clearWorkNarration(live, narrated);
-        live.ledger.sweep(Date.now());
-        const outstanding = live.ledger.summarize(Date.now());
-        if (cappedOut)
-          log(`[work] quiescence cap reached for ${live.sessionId}; grading anyway with: ${outstanding.join("; ") || "(nothing outstanding)"}`);
-        else if (Date.now() - started2 > 1e3)
-          log(`[work] ${live.sessionId} settled after ${Math.round((Date.now() - started2) / 1e3)}s \u2014 grading now`);
-        if (!cappedOut && outstanding.length)
-          log(`[work] grading with work still in flight: ${outstanding.join("; ")}`);
-        await this.runVerification(live, finalText, didWork);
       }
       /** Take down the "waiting on background work" strip, if we put one up. */
       clearWorkNarration(live, narrated) {
@@ -42557,6 +42582,8 @@ ${unattendedReportDirective(params)}` : ""), live.sessionId) },
             }
             const sid = live.sessionId;
             const parentToolUseId = message.parent_tool_use_id ?? void 0;
+            if (!live.streaming && !live.reaped && isTurnBearingFrame(message.type))
+              this.adoptSelfStartedTurn(live);
             switch (message.type) {
               case "stream_event": {
                 const event = message.event;
@@ -43314,6 +43341,7 @@ ${err2.stack}` : ""}` : String(err2);
             emit2({ type: "agent:status", sessionId: sid, status: "error" });
           }
         } finally {
+          live.gone = true;
           if (live.idleTimer) {
             clearTimeout(live.idleTimer);
             live.idleTimer = void 0;
@@ -43522,6 +43550,7 @@ ${err2.stack}` : ""}` : String(err2);
           live.abort.abort();
         } catch {
         }
+        live.gone = true;
       }
       /** M7 — stop ONE background task (vs interruptSession which aborts the whole
        *  turn). Driver-only, same origin guard. No-op if the session/task is gone. */
@@ -44247,12 +44276,45 @@ ${lines.join("\n")}
       /** Close an idle session's Query (→ child process + IPC freed via runConsumer's
        *  finally), keeping the on-disk session resumable. Deletes from the live map
        *  FIRST so a racing sendMessage misses it and cleanly re-creates with resume. */
+      /**
+       * Is this session, whatever `streaming` says, still in the middle of something?
+       *
+       * `streaming` only tracks turns WE started. A CLI running its own background monitor
+       * starts turns by itself when events land, and between two of those — or during a long
+       * tool call inside one — the session reads as idle here while the engine is hard at work.
+       * The memory monitor's moderate-pressure reclaim reaped exactly such a session, 60 seconds
+       * "idle" with a batch barrier that had just reported "1 still running": the CLI carried on
+       * for another 69 minutes, un-mapped and ungradeable. Work the ledger is awaiting, a job
+       * that is running, a wait inside `await_jobs`, or a turn-end grade still waiting for
+       * quiescence — any of these means the session is busy.
+       */
+      hasWorkInFlight(live) {
+        if (live.gradePending)
+          return true;
+        if ((live.awaitDepth ?? 0) > 0)
+          return true;
+        try {
+          if (live.ledger.verdict(Date.now()).waiting.length > 0)
+            return true;
+        } catch {
+        }
+        try {
+          if (live.jobs?.list().some((j) => j.status === "running"))
+            return true;
+        } catch {
+        }
+        return false;
+      }
       reapIdleSession(sessionId, force = false) {
         const live = this.liveSessions.get(sessionId);
         if (!live || live.streaming || live.reaped)
           return false;
         if (this.isHeld(live) && !force)
           return false;
+        if (!force && this.hasWorkInFlight(live)) {
+          log(`[reap] ${sessionId} looks idle but has work in flight \u2014 left alone`);
+          return false;
+        }
         log("Reaping idle session:", sessionId);
         live.reaped = true;
         this.emitLifecycle("SessionEnd", { sessionId, reason: force ? "forced" : "idle-reap" });
@@ -44301,6 +44363,10 @@ ${lines.join("\n")}
         let n = 0;
         for (const live of [...this.liveSessions.values()]) {
           if (!live.streaming && !live.reaped) {
+            if (this.hasWorkInFlight(live)) {
+              log(`[reap] critical reclaim spared ${live.sessionId}: work in flight`);
+              continue;
+            }
             if (this.reapIdleSession(live.sessionId, true))
               n++;
           }
@@ -44325,6 +44391,7 @@ ${lines.join("\n")}
           if (live.reaped)
             continue;
           live.reaped = true;
+          live.gone = true;
           if (live.idleTimer) {
             clearTimeout(live.idleTimer);
             live.idleTimer = void 0;
@@ -110149,7 +110216,7 @@ var NetdEngine = class {
     p.relayed = p.relayed || relayed;
     this.#pendingEndpoints.set(k, p);
   }
-  startHandshake(staticPub, _nowMs) {
+  #flushHint(staticPub) {
     const k = staticPub.toString("hex");
     const p = this.#pendingEndpoints.get(k) ?? { endpoints: [], relayed: false };
     this.#pendingEndpoints.delete(k);
@@ -110158,6 +110225,12 @@ var NetdEngine = class {
         this.#lastError = `hint: ${r.detail}`;
     });
   }
+  startHandshake(staticPub, _nowMs) {
+    this.#flushHint(staticPub);
+  }
+  ensureHandshake(staticPub, _nowMs) {
+    this.#flushHint(staticPub);
+  }
   /** No UDP here — netd owns the socket. Never called in practice; kept for the interface. */
   injectUdp(_pkt, _from, _nowMs) {
   }
@@ -111066,7 +111139,7 @@ var MeshNode = class {
         this.#peers.set(hex6, staticPub);
       }
       engine.addPath(staticPub, `${address}:${port}`, false);
-      engine.startHandshake(staticPub, Date.now());
+      engine.ensureHandshake(staticPub, Date.now());
       this.#drain();
     } catch (e) {
       this.#lastError = e instanceof Error ? e.message : String(e);
@@ -111151,7 +111224,7 @@ var MeshNode = class {
             } catch {
             }
           }
-          engine.startHandshake(pk, Date.now());
+          engine.ensureHandshake(pk, Date.now());
           break;
         }
         case "mesh:gone": {
@@ -111295,7 +111368,7 @@ var MeshNode = class {
       for (const e of p.endpoints)
         engine.addPath(pk, `${p.observedIp}:${e.port}`, false);
     }
-    engine.startHandshake(pk, Date.now());
+    engine.ensureHandshake(pk, Date.now());
     const meshId = this.#engine?.meshId();
     try {
       if (meshId)

package/dist-bundle/mesh-core/index.d.ts

@@ -59,6 +59,9 @@ export declare class MeshEngine {
   /** A relayed path always ranks below a direct one, regardless of RTT. */
   addPath(staticPub: Buffer, endpoint: Endpoint, relayed: boolean): void;
   startHandshake(staticPub: Buffer, nowMs: number): void;
+  /** Idempotent connect nudge: no-op over a live session; initiates only on first contact
+   *  or a stale attempt. What a host calls when it (re)learns a peer. */
+  ensureHandshake(staticPub: Buffer, nowMs: number): void;
 
   injectTun(pkt: Buffer, nowMs: number): void;
   injectUdp(pkt: Buffer, from: Endpoint, nowMs: number): void;

package/dist-bundle/mesh-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fineguide-tesseract/mesh-core",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "main": "index.js",
   "types": "index.d.ts"
 }

package/package.json

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