@evident-ai/cli 3.5.1-dev.bbaa769 → 3.5.1-dev.bf9e537

package/dist/index.js

@@ -1158,7 +1158,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.5.1-dev.bbaa769" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.5.1-dev.bf9e537" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -1630,12 +1630,18 @@ async function checkOpenCodeHealth(port) {
     return { healthy: false, error: message };
   }
 }
+function bodyExcerpt(body) {
+  const excerpt = body.replace(/\s+/g, " ").trim().slice(0, 160);
+  return excerpt ? ` (body="${excerpt}")` : " (empty body)";
+}
 async function checkOpenCode2Health(port, password) {
   try {
-    const response = await fetch(`http://127.0.0.1:${port}/global/health`, {
-      headers: {
-        Authorization: buildOpenCodeBasicAuthHeader(password)
-      },
+    const headers = {};
+    if (password !== void 0) {
+      headers.Authorization = buildOpenCodeBasicAuthHeader(password);
+    }
+    const response = await fetch(`http://127.0.0.1:${port}/api/health`, {
+      headers,
       signal: AbortSignal.timeout(2e3)
     });
     if (response.status === 401) {
@@ -1644,8 +1650,31 @@ async function checkOpenCode2Health(port, password) {
     if (!response.ok) {
       return { healthy: false, error: `HTTP ${response.status}` };
     }
-    const data = await response.json().catch(() => ({}));
-    return { healthy: true, version: data.version };
+    const body = await response.text();
+    const excerpt = bodyExcerpt(body);
+    let data;
+    try {
+      data = JSON.parse(body);
+    } catch (error2) {
+      return {
+        healthy: false,
+        error: `Invalid JSON health response${excerpt}: ${error2 instanceof Error ? error2.message : String(error2)}`
+      };
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      return {
+        healthy: false,
+        error: `Invalid health response${excerpt}: expected healthy=true`
+      };
+    }
+    const health = data;
+    if (health.healthy !== true) {
+      return {
+        healthy: false,
+        error: `Invalid health response${excerpt}: expected healthy=true`
+      };
+    }
+    return typeof health.version === "string" ? { healthy: true, version: health.version } : { healthy: true };
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : "Unknown error";
     return { healthy: false, error: message };
@@ -6399,6 +6428,7 @@ var DEFAULT_PAUSED_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_PAUSED_MAX_WAIT_MS = 10 * 60 * 1e3;
 var DEFAULT_STUCK_QUEUED_MS = 6e4;
 var HEARTBEAT_MS = 6e4;
+var ALIVE_WITHHELD_THRESHOLD_MS = 3 * HEARTBEAT_MS;
 var ABSOLUTE_MAX_PROCESSING_MS = 6 * 60 * 60 * 1e3;
 var B2_ABANDONMENT_MIN_PINNED_MS = 3 * 6e4;
 var AMBIGUOUS_FINISH_MAX_PINNED_MS = 3 * 6e4;
@@ -7603,7 +7633,7 @@ var ChannelDriver = class _ChannelDriver {
             return "dispatch";
           }
         }
-        return this.reattachRedrive(conv, sessionId, message, ocId);
+        return this.reattachRedrive(conv, sessionId, message, ocId, state);
       }
       if (ongoing === false) {
         if (state === "running" && isAmbiguousFinishPinnedRunning(messages, ocId ?? "")) {
@@ -7620,11 +7650,12 @@ var ChannelDriver = class _ChannelDriver {
     return "dispatch";
   }
   /**
-   * The `reattached` outcome (Task 3.3): the prior turn is STILL ONGOING per
-   * opencode's own status map — undo the false reclaim instead of starting a
-   * second turn.
+   * The `reattached` outcome (Task 3.3): opencode's own status map says the session
+   * is ongoing, so undo the false reclaim instead of starting a second turn. `state`
+   * carries the correlated message's observed state so the outcome does not claim
+   * that a queued message's own turn was already running.
    */
-  async reattachRedrive(conv, sessionId, message, ocId) {
+  async reattachRedrive(conv, sessionId, message, ocId, state) {
     let anchorMs;
     const parsed = message.processing_started_at ? Date.parse(message.processing_started_at) : NaN;
     if (!Number.isNaN(parsed)) {
@@ -7633,7 +7664,7 @@ var ChannelDriver = class _ChannelDriver {
       anchorMs = this.now();
       this.log({
         level: "warn",
-        message: `Re-drive: message ${message.id.slice(0, 8)} has null/unparseable processing_started_at (${String(message.processing_started_at)}) \u2014 this is expected when OpenCode accepted the turn but never started it; anchoring the watcher's absolute-age ceiling to now`,
+        message: `Re-drive: message ${message.id.slice(0, 8)} has no usable processing_started_at (${String(message.processing_started_at)}) \u2014 anchoring the watcher's absolute-age ceiling to now`,
         conversation_id: conv.id,
         message_id: message.id
       });
@@ -7662,17 +7693,19 @@ var ChannelDriver = class _ChannelDriver {
       return bound === "abandoned" ? "abandoned" : "unresolved";
     }
     this.clearRedriveUnresolved(message.id);
-    this.registerReadopted(conv, sessionId, message, ocId ?? "", anchorMs);
+    this.registerReadopted(conv, sessionId, message, ocId ?? "", anchorMs, this.now());
     this.dispatched.add(message.id);
     this.readopted.add(message.id);
-    this.ensureWatcherRunning(sessionId);
+    const watcherState = this.ensureWatcherRunning(sessionId);
     const watchedForMs = this.now() - anchorMs;
     void this.postSignal(conv.id, message.id, "redrive_reattached", {
-      watched_for_ms: watchedForMs
+      watched_for_ms: watchedForMs,
+      run_state: state,
+      watcher_state: watcherState
     });
     this.log({
       level: "warn",
-      message: `Re-drive: message ${message.id.slice(0, 8)} (session ${sessionId.slice(0, 8)}) was wrongly reclaimed to pending while its turn was still running (watched ${watchedForMs}ms) \u2014 restored to processing instead of re-dispatching`,
+      message: state === "running" ? `Re-drive: message ${message.id.slice(0, 8)} (session ${sessionId.slice(0, 8)}) was wrongly reclaimed to pending while its turn was still running (watched ${watchedForMs}ms) \u2014 restored to processing instead of re-dispatching` : `Re-drive: message ${message.id.slice(0, 8)} (session ${sessionId.slice(0, 8)}) was reclaimed to pending while its own turn had not started and the session was busy (watched ${watchedForMs}ms) \u2014 restored to processing instead of re-dispatching to avoid a duplicate`,
       conversation_id: conv.id,
       message_id: message.id
     });
@@ -8279,6 +8312,7 @@ var ChannelDriver = class _ChannelDriver {
       stuckReported: false,
       lastAliveAt: 0,
       aliveInFlight: false,
+      aliveWithheldSignalled: false,
       titleSynced: false,
       titleSyncInFlight: false,
       awaitingHumanLatched: false,
@@ -8338,9 +8372,12 @@ var ChannelDriver = class _ChannelDriver {
   /**
    * Register a RE-ADOPTED `processing` message with its session watcher
    * (ADR-0046, WI-4). Mirrors `registerInFlight` but anchors the give-up
-   * `deadline` to the row's SERVER-SIDE `processed_at` (Invariant 1), NEVER to
-   * `now`, so the paused/queued/unreachable cases settle on the same wall-clock a
-   * fresh dispatch would (10 min after `processed_at`, not 10 min from now).
+   * `deadline` to the attempt's SERVER-SIDE `processed_at` (Invariant 1), while
+   * `processingAnchorMs` keeps the absolute-age ceiling tied to the original turn.
+   * The deadline tracks THIS attempt; the ceiling tracks THE TURN. For a fresh
+   * dispatch both anchors are `now`; a restart re-adopt passes the server's
+   * `processed_at` for both, while a re-drive passes the newly stamped attempt time
+   * only for the deadline.
    *
    * This re-attaches into the SAME watcher, so the ADR-0047 progressing-vs-paused
    * give-up (`serviceInFlightMessage`) applies unchanged: a re-adopted turn
@@ -8361,7 +8398,7 @@ var ChannelDriver = class _ChannelDriver {
    * server already flipped to `processing`; the running/done transitions still
    * fire from the watcher's normal branches.
    */
-  registerReadopted(conv, sessionId, message, opencodeMessageId, processedAtMs) {
+  registerReadopted(conv, sessionId, message, opencodeMessageId, processedAtMs, watchDeadlineAnchorMs) {
     let watcher = this.watchers.get(sessionId);
     if (!watcher) {
       watcher = this.newSessionWatcher(conv);
@@ -8372,11 +8409,11 @@ var ChannelDriver = class _ChannelDriver {
       opencodeMessageId,
       message,
       dispatchedAt: this.now(),
-      // Anchor the absolute-age ceiling to the SERVER-SIDE `processed_at` (the same
-      // value seeding `deadline`), NOT `dispatchedAt` — so a re-adopted zombie's age
-      // reflects the real turn duration and the ceiling fires on the ORIGINAL turn.
+      // Anchor the absolute-age ceiling to the SERVER-SIDE `processed_at`, NOT
+      // `dispatchedAt` — so a re-adopted zombie's age reflects the real turn duration
+      // and the ceiling fires on the ORIGINAL turn.
       processingAnchorMs: processedAtMs,
-      deadline: processedAtMs + this.pausedMaxWaitMs,
+      deadline: watchDeadlineAnchorMs + this.pausedMaxWaitMs,
       // The server row is ALREADY `processing`; do not re-fire markProcessing.
       started: true,
       done: false,
@@ -8393,6 +8430,7 @@ var ChannelDriver = class _ChannelDriver {
       // with no extra `re_adopted` signal needed (folds old WI-6).
       lastAliveAt: 0,
       aliveInFlight: false,
+      aliveWithheldSignalled: false,
       titleSynced: false,
       titleSyncInFlight: false,
       awaitingHumanLatched: false,
@@ -8509,6 +8547,8 @@ var ChannelDriver = class _ChannelDriver {
    * tracked on the watcher and cleared when it settles; it never rejects (fully
    * guarded), so a failed poll/callback can never crash the run loop — the cron
    * stays as the safety net.
+   * Returns the branch taken so re-attach telemetry can show whether it left a
+   * ticking loop behind.
    *
    * The generation started here (#1618) is captured in the `.finally` closure
    * so a RETIRED loop settling late — after `reconcileWatchers` has already
@@ -8522,7 +8562,7 @@ var ChannelDriver = class _ChannelDriver {
         level: "debug",
         message: `No watcher entry exists for session ${sessionId} \u2014 nothing to do`
       });
-      return;
+      return "no_watcher";
     }
     this.ensureSessionErrorStream();
     if (watcher.loop) {
@@ -8531,7 +8571,7 @@ var ChannelDriver = class _ChannelDriver {
         message: `Watcher loop already running for session ${sessionId}; no-op with ${watcher.inFlight.size} message(s) in flight`,
         conversation_id: watcher.conv.id
       });
-      return;
+      return "already_running";
     }
     if (watcher.inFlight.size === 0) {
       this.log({
@@ -8540,7 +8580,7 @@ var ChannelDriver = class _ChannelDriver {
         conversation_id: watcher.conv.id
       });
       this.watchers.delete(sessionId);
-      return;
+      return "no_in_flight";
     }
     const generation = watcher.generation;
     this.log({
@@ -8556,6 +8596,7 @@ var ChannelDriver = class _ChannelDriver {
       }
     });
     watcher.loop = loop;
+    return "started";
   }
   ensureSessionErrorStream() {
     if (this.sessionErrorStream || this.stopped) return;
@@ -9081,7 +9122,8 @@ var ChannelDriver = class _ChannelDriver {
       this.removeInFlight(watcher, inFlight.evidentMessageId);
       return;
     }
-    if (activelyRunning && !inFlight.awaitingHumanLatched && !inFlight.aliveInFlight && this.now() - inFlight.lastAliveAt >= HEARTBEAT_MS) {
+    const heartbeatDue = activelyRunning && !inFlight.awaitingHumanLatched && !inFlight.aliveInFlight && this.now() - inFlight.lastAliveAt >= HEARTBEAT_MS;
+    if (heartbeatDue) {
       inFlight.aliveInFlight = true;
       this.log({
         level: "debug",
@@ -9091,7 +9133,10 @@ var ChannelDriver = class _ChannelDriver {
       });
       void this.postSignal(conv.id, inFlight.evidentMessageId, "alive").then((ok) => {
         inFlight.aliveInFlight = false;
-        if (ok) inFlight.lastAliveAt = this.now();
+        if (ok) {
+          inFlight.lastAliveAt = this.now();
+          inFlight.aliveWithheldSignalled = false;
+        }
         this.log({
           level: "debug",
           message: `Heartbeat POST for message ${inFlight.evidentMessageId} in session ${sessionId} completed with ok=${ok}`,
@@ -9143,6 +9188,16 @@ var ChannelDriver = class _ChannelDriver {
       inFlight.pausedOnPermission = false;
       inFlight.pausedClearConfirmed = false;
     }
+    const watchedForMs = this.now() - Math.max(inFlight.lastAliveAt, inFlight.dispatchedAt);
+    if (!heartbeatDue && !inFlight.aliveWithheldSignalled && watchedForMs >= ALIVE_WITHHELD_THRESHOLD_MS) {
+      inFlight.aliveWithheldSignalled = true;
+      const reason = inFlight.awaitingHumanLatched ? "awaiting_human" : inFlight.aliveInFlight ? "alive_in_flight" : "not_running";
+      void this.postSignal(conv.id, inFlight.evidentMessageId, "alive_withheld", {
+        reason,
+        run_state: state,
+        watched_for_ms: watchedForMs
+      });
+    }
     const siblingPaused = (sib) => openQuestions.has(sib.evidentMessageId) || openPermissions.has(sib.evidentMessageId) || sib.awaitingHumanLatched || sib.pausedOnQuestion || sib.pausedOnPermission;
     const hasActivelyRunningSibling = [...watcher.inFlight.values()].some(
       (sib) => sib.evidentMessageId !== inFlight.evidentMessageId && messageRunState(messages, sib.opencodeMessageId) === "running" && !siblingPaused(sib)
@@ -9153,15 +9208,15 @@ var ChannelDriver = class _ChannelDriver {
         const attempts = this.recordNeverStartedAttempt(id, sessionId);
         if (attempts >= MAX_NEVER_STARTED_ATTEMPTS) {
           inFlight.neverStartedResolved = true;
-          const watchedForMs = this.now() - inFlight.dispatchedAt;
+          const watchedForMs2 = this.now() - inFlight.dispatchedAt;
           this.log({
             level: "error",
-            message: `Message ${id.slice(0, 8)} never started after ${attempts} attempts (${watchedForMs}ms watched) \u2014 reporting the run failed; the accepted OpenCode copy was not cancelled`,
+            message: `Message ${id.slice(0, 8)} never started after ${attempts} attempts (${watchedForMs2}ms watched) \u2014 reporting the run failed; the accepted OpenCode copy was not cancelled`,
             conversation_id: conv.id,
             message_id: id
           });
           void this.postSignal(conv.id, id, "never_started_failed", {
-            watched_for_ms: watchedForMs,
+            watched_for_ms: watchedForMs2,
             attempts
           });
           await this.settleMessageNeverStarted(sessionId, watcher, inFlight, attempts);
@@ -9175,7 +9230,8 @@ var ChannelDriver = class _ChannelDriver {
         message_id: inFlight.evidentMessageId
       });
       void this.postSignal(conv.id, inFlight.evidentMessageId, "gave_up", {
-        watched_for_ms: this.now() - inFlight.dispatchedAt
+        watched_for_ms: this.now() - inFlight.dispatchedAt,
+        run_state: state
       });
       this.recordReleasedOpencodeId(
         inFlight.evidentMessageId,
@@ -9632,7 +9688,8 @@ var ChannelDriver = class _ChannelDriver {
     if ((state === "running" || state === "queued") && ocId) {
       const conv = this.convForRow(sessionId, row);
       const message = this.queuedMessageForRow(row);
-      this.registerReadopted(conv, sessionId, message, ocId, this.processedAtMs(row));
+      const processedAtMs = this.processedAtMs(row);
+      this.registerReadopted(conv, sessionId, message, ocId, processedAtMs, processedAtMs);
       this.dispatched.add(row.id);
       this.readopted.add(row.id);
       this.ensureWatcherRunning(sessionId);
@@ -9927,7 +9984,15 @@ var ChannelDriver = class _ChannelDriver {
       return;
     }
     this.unconfirmedDispatchFailures.delete(row.id);
-    this.registerReadopted(readoptConv, sessionId, readoptMessage, ocId, this.processedAtMs(row));
+    const processedAtMs = this.processedAtMs(row);
+    this.registerReadopted(
+      readoptConv,
+      sessionId,
+      readoptMessage,
+      ocId,
+      processedAtMs,
+      processedAtMs
+    );
     this.dispatched.add(row.id);
     this.readopted.add(row.id);
     this.awaitingReadopt.delete(row.id);
@@ -11347,25 +11412,6 @@ Port ${port} is already in use.`));
 import chalk6 from "chalk";
 import ora3 from "ora";
 import { select as select3 } from "@inquirer/prompts";
-async function probeOpenCode2WithoutPassword(port) {
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/global/health`, {
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (response.status === 401) {
-      return { healthy: false, authFailed: true, error: "HTTP 401" };
-    }
-    if (!response.ok) {
-      return { healthy: false, error: `HTTP ${response.status}` };
-    }
-    return { healthy: true };
-  } catch (error2) {
-    return {
-      healthy: false,
-      error: error2 instanceof Error ? error2.message : "Unknown error"
-    };
-  }
-}
 function unknownPasswordError(port) {
   return new Error(
     `OpenCode V2 (opencode2) is already running on port ${port} with a password this runner doesn't know. Free the port or pass --port.`
@@ -11373,7 +11419,7 @@ function unknownPasswordError(port) {
 }
 var INTERACTIVE_START_TIMEOUT_MS2 = 3e4;
 async function ensureOpenCode2Running(ctx) {
-  const initialHealth = await probeOpenCode2WithoutPassword(ctx.port);
+  const initialHealth = await checkOpenCode2Health(ctx.port);
   if (initialHealth.authFailed) {
     throw unknownPasswordError(ctx.port);
   }