@evident-ai/cli 3.5.2-dev.4912967 → 3.5.2-dev.507f0a3

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
 
 // src/commands/login.ts
@@ -1158,7 +1157,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.5.2-dev.4912967" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.5.2-dev.507f0a3" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -1172,6 +1171,23 @@ var authProvider = null;
 function setTelemetryAuthProvider(provider) {
   authProvider = provider;
 }
+var diagnosticsReporter = null;
+function setTelemetryDiagnosticsReporter(reporter) {
+  diagnosticsReporter = reporter;
+}
+function reportTelemetryDiagnostic(message) {
+  if (!diagnosticsReporter) {
+    console.error(message);
+    return;
+  }
+  try {
+    diagnosticsReporter(message);
+  } catch (error2) {
+    console.error(
+      `Telemetry diagnostics reporter failed: ${error2 instanceof Error ? error2.message : String(error2)}; original diagnostic: ${message}`
+    );
+  }
+}
 var FLUSH_FAILURE_LOG_INTERVAL_MS = 6e4;
 var lastFlushFailureLoggedAt = 0;
 var suppressedFlushFailureCount = 0;
@@ -1237,7 +1253,9 @@ async function flushEvents() {
         signal: controller.signal
       });
       if (!response.ok) {
-        console.error(`Telemetry flush failed: ${response.status}`);
+        reportTelemetryDiagnostic(
+          `Telemetry could not send events (HTTP ${response.status}); runner and OpenCode are unaffected`
+        );
       }
     } finally {
       clearTimeout(timeout);
@@ -1247,7 +1265,9 @@ async function flushEvents() {
     if (now - lastFlushFailureLoggedAt >= FLUSH_FAILURE_LOG_INTERVAL_MS) {
       const message = error2 instanceof Error ? error2.message : String(error2);
       const suffix = suppressedFlushFailureCount > 0 ? ` (${suppressedFlushFailureCount} more suppressed in the last ${FLUSH_FAILURE_LOG_INTERVAL_MS / 1e3}s)` : "";
-      console.error(`Telemetry flush error: ${message}${suffix}`);
+      reportTelemetryDiagnostic(
+        `Telemetry flush failed: ${message}; runner and OpenCode are unaffected${suffix}`
+      );
       lastFlushFailureLoggedAt = now;
       suppressedFlushFailureCount = 0;
     } else {
@@ -1317,25 +1337,72 @@ function parseOpenCodeLogLine(line) {
   const level = levelMatch[1].toUpperCase();
   if (level !== "WARN" && level !== "ERROR") return null;
   const sessionMatch = normalisedLine.match(/(?:^|\s)sessionID=(\S+)/);
-  return { level: level === "WARN" ? "warn" : "error", sessionID: sessionMatch?.[1] };
+  const messageMatch = normalisedLine.match(/(?:^|\s)message=(?:"((?:\\.|[^"])*)"|(\S+))/);
+  const parsed = {
+    level: level === "WARN" ? "warn" : "error",
+    sessionID: sessionMatch?.[1]
+  };
+  const message = messageMatch?.[1] ?? messageMatch?.[2];
+  if (message !== void 0) parsed.message = message;
+  return parsed;
 }
 var MAX_LINE_BUFFER_BYTES = 16 * 1024;
+var REPEAT_SUPPRESSION_WINDOW_MS = 6e4;
 function createOpenCodeActivityForwarder(getContext) {
   let buffer = Buffer.alloc(0);
-  const flushLine = (line) => {
-    const parsed = parseOpenCodeLogLine(line);
-    if (!parsed) return;
+  const repeatStates = /* @__PURE__ */ new Map();
+  const forwardLine = (line, parsed, repeatsSuppressed = 0) => {
+    const metadata = {
+      ...parsed.sessionID ? { sessionID: parsed.sessionID } : {},
+      ...repeatsSuppressed > 0 ? { repeats_suppressed: repeatsSuppressed } : {}
+    };
     forwardRunnerActivity(
       {
         level: parsed.level,
         error: line,
-        metadata: parsed.sessionID ? { sessionID: parsed.sessionID } : void 0,
+        metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
         source: "opencode"
       },
       getContext()
     );
   };
-  return (chunk) => {
+  const expireRepeatStates = (now, currentKey) => {
+    for (const [key, state] of repeatStates) {
+      if (key === currentKey || now - state.lastForwardedAt < REPEAT_SUPPRESSION_WINDOW_MS) {
+        continue;
+      }
+      if (state.repeatsSuppressed > 0) {
+        forwardLine(state.line, state.parsed, state.repeatsSuppressed);
+      }
+      repeatStates.delete(key);
+    }
+  };
+  const flushLine = (line) => {
+    const parsed = parseOpenCodeLogLine(line);
+    if (!parsed) return;
+    const now = Date.now();
+    const key = parsed.message === void 0 ? void 0 : `${parsed.level}\0${parsed.message}`;
+    expireRepeatStates(now, key);
+    if (key === void 0) {
+      forwardLine(line, parsed);
+      return;
+    }
+    const previous = repeatStates.get(key);
+    if (!previous || now - previous.lastForwardedAt >= REPEAT_SUPPRESSION_WINDOW_MS) {
+      forwardLine(line, parsed, previous?.repeatsSuppressed ?? 0);
+      repeatStates.set(key, {
+        line,
+        parsed,
+        lastForwardedAt: now,
+        repeatsSuppressed: 0
+      });
+      return;
+    }
+    previous.line = line;
+    previous.parsed = parsed;
+    previous.repeatsSuppressed++;
+  };
+  const forward = ((chunk) => {
     buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf-8")]);
     let newlineIndex;
     while ((newlineIndex = buffer.indexOf(10)) !== -1) {
@@ -1346,7 +1413,16 @@ function createOpenCodeActivityForwarder(getContext) {
       flushLine(buffer.toString("utf-8"));
       buffer = Buffer.alloc(0);
     }
+  });
+  forward.flush = () => {
+    for (const state of repeatStates.values()) {
+      if (state.repeatsSuppressed > 0) {
+        forwardLine(state.line, state.parsed, state.repeatsSuppressed);
+      }
+    }
+    repeatStates.clear();
   };
+  return forward;
 }
 var MAX_MESSAGE_LENGTH = 500;
 var MAX_METADATA_VALUE_LENGTH = 200;
@@ -1372,7 +1448,7 @@ function redactHomeDirectory(message) {
   }
   return result + message.slice(searchFrom);
 }
-function redact(message) {
+function redactDiagnosticText(message) {
   const redacted = message.replace(/esk_[A-Za-z0-9_-]+/g, "esk_***").replace(/ct_[A-Za-z0-9_-]+/g, "ct_***").replace(/(?<![A-Za-z0-9_-])sk-ant-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g, "sk-ant-***").replace(/(?<![A-Za-z0-9_-])sk-proj-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g, "sk-proj-***").replace(/(?<![A-Za-z0-9_-])sk-[A-Za-z0-9]{20,}(?![A-Za-z0-9_-])/g, "sk-***").replace(/(?<![A-Za-z0-9_-])(gh[oprsu])_[A-Za-z0-9]{20,}(?![A-Za-z0-9_-])/g, "$1_***").replace(/(?<![A-Za-z0-9_-])github_pat_[A-Za-z0-9_]{20,}(?![A-Za-z0-9_-])/g, "github_pat_***").replace(/https?:\/\/\S+/g, "<url>");
   return redactHomeDirectory(redacted);
 }
@@ -1384,14 +1460,17 @@ function sanitiseMetadata(metadata) {
   if (!metadata) return {};
   const entries = Object.entries(metadata).slice(0, MAX_METADATA_ENTRIES);
   if (Object.keys(metadata).length > entries.length) {
-    console.error(
-      `[runner-activity-telemetry] dropped ${Object.keys(metadata).length - entries.length} metadata entries`
+    reportTelemetryDiagnostic(
+      `Runner activity telemetry dropped ${Object.keys(metadata).length - entries.length} metadata entries; those entries were not sent`
     );
   }
   const sanitised = [];
   for (const [key, value] of entries) {
     if (typeof value === "string") {
-      sanitised.push([key, truncate(redact(value).slice(0, MAX_METADATA_VALUE_LENGTH))]);
+      sanitised.push([
+        key,
+        truncate(redactDiagnosticText(value).slice(0, MAX_METADATA_VALUE_LENGTH))
+      ]);
     } else if (value === null || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
       sanitised.push([key, value]);
     }
@@ -1409,8 +1488,8 @@ function admitUnderRateLimit(source, now) {
   }
   if (now - window.windowStartedAt >= RATE_LIMIT_WINDOW_MS) {
     if (window.windowDroppedCount > 0) {
-      console.error(
-        `[runner-activity-telemetry] rate cap reached: dropped ${window.windowDroppedCount} ${window.windowDroppedCount === 1 ? "entry" : "entries"} in the last ${RATE_LIMIT_WINDOW_MS / 1e3}s (cap ${RATE_LIMIT_MAX_EVENTS}/min) for source "${source}"`
+      reportTelemetryDiagnostic(
+        `Runner activity telemetry rate cap reached: dropped ${window.windowDroppedCount} ${window.windowDroppedCount === 1 ? "entry" : "entries"} in the last ${RATE_LIMIT_WINDOW_MS / 1e3}s (limit ${RATE_LIMIT_MAX_EVENTS}/min); those entries were not sent for source "${source}"`
       );
     }
     window.windowStartedAt = now;
@@ -1420,8 +1499,8 @@ function admitUnderRateLimit(source, now) {
   if (window.windowCount >= RATE_LIMIT_MAX_EVENTS) {
     window.windowDroppedCount++;
     if (window.windowDroppedCount === 1) {
-      console.error(
-        `[runner-activity-telemetry] rate cap reached (${RATE_LIMIT_MAX_EVENTS} per ${RATE_LIMIT_WINDOW_MS / 1e3}s) \u2014 dropping further entries this window for source "${source}"`
+      reportTelemetryDiagnostic(
+        `Runner activity telemetry rate cap reached (${RATE_LIMIT_MAX_EVENTS} entries per ${RATE_LIMIT_WINDOW_MS / 1e3}s limit; further entries were not sent for source "${source}"`
       );
     }
     return false;
@@ -1436,7 +1515,7 @@ function forwardRunnerActivity(entry, context) {
     if (!context.agentId || !context.authHeader) return;
     if (!admitUnderRateLimit(source, Date.now())) return;
     const rawMessage = entry.error ?? entry.message ?? "";
-    const message = truncate(redact(rawMessage));
+    const message = truncate(redactDiagnosticText(rawMessage));
     logEvent(TelemetryEventTypes.RUNNER_ACTIVITY, {
       severity: SEVERITY_BY_LEVEL[entry.level],
       message,
@@ -1444,8 +1523,8 @@ function forwardRunnerActivity(entry, context) {
       agentId: context.agentId
     });
   } catch (err) {
-    console.error(
-      `[runner-activity-telemetry] failed to forward runner activity: ${err instanceof Error ? err.message : String(err)}`
+    reportTelemetryDiagnostic(
+      `Runner activity telemetry failed to forward runner activity: ${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
@@ -1735,8 +1814,46 @@ async function waitForOpenCode2Health(port, password, timeoutMs = 3e4) {
 
 // src/lib/http-timeout.ts
 var REQUEST_TIMEOUT_MS = 6e4;
+var RequestTimeoutError = class extends Error {
+  constructor(operation, timeoutMs, elapsedMs) {
+    super(`${operation} timed out after ${elapsedMs}ms (limit ${timeoutMs}ms)`);
+    this.operation = operation;
+    this.timeoutMs = timeoutMs;
+    this.elapsedMs = elapsedMs;
+    this.name = "TimeoutError";
+  }
+};
+function describeRequestOperation(input, init) {
+  const method = (init?.method ?? input.method ?? "GET").toUpperCase();
+  const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+  let path;
+  try {
+    path = new URL(rawUrl).pathname;
+  } catch (error2) {
+    if (!(error2 instanceof TypeError)) throw error2;
+    path = rawUrl.split(/[?#]/, 1)[0];
+  }
+  const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const prefixedIdentifier = /^[a-z]+_[A-Za-z0-9_-]{10,}$/;
+  const maskedPath = path.split("/").map((segment) => uuid.test(segment) || prefixedIdentifier.test(segment) ? ":id" : segment).join("/");
+  return `${method} ${maskedPath}`;
+}
 function withRequestTimeout(fetchImpl, timeoutMs) {
-  return ((input, init) => fetchImpl(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+  return (async (input, init) => {
+    const startedAt = Date.now();
+    try {
+      return await fetchImpl(input, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+    } catch (error2) {
+      if (error2?.name === "TimeoutError") {
+        throw new RequestTimeoutError(
+          describeRequestOperation(input, init),
+          timeoutMs,
+          Date.now() - startedAt
+        );
+      }
+      throw error2;
+    }
+  });
 }
 
 // src/lib/opencode/client.ts
@@ -3397,16 +3514,17 @@ function hasPrimaryHeaders(headers) {
   ].some((name) => headers.has(name));
 }
 async function getOpenAiUsage(port, client) {
+  const openCodeVersion = client?.version ?? "v1";
   const credentials2 = readOpenCodeChatGptCredentials();
   if (!credentials2) {
     throw new OpenAiUsageError(
-      "No ChatGPT login found. Connect a ChatGPT account to this runner, or run `opencode auth login`.",
+      openCodeVersion === "v2" ? "OpenAI usage reporting is not available on OpenCode V2 because V2 keeps a connected ChatGPT login in a store Evident cannot read." : "No ChatGPT login found. Connect a ChatGPT account to this runner, or run `opencode auth login`.",
       "no_credentials"
     );
   }
   if (credentials2.expiresAt < Date.now()) {
     throw new OpenAiUsageError(
-      "ChatGPT credentials have expired. Run `opencode auth login` to refresh them.",
+      openCodeVersion === "v2" ? "The delivered ChatGPT login has expired. OpenCode V2 cannot be given a replacement by file; connect the account again from the runner's page in Evident." : "ChatGPT credentials have expired. Run `opencode auth login` to refresh them.",
       "credentials_expired"
     );
   }
@@ -5392,6 +5510,8 @@ var StreamForwarder = class {
           if (done) break;
           const chunk = Buffer.from(value);
           for (let i = 0; i < chunk.length; i += MAX_FRAME_BYTES) {
+            await stream.pausePromise;
+            if (ac.signal.aborted) break;
             const slice = chunk.subarray(i, i + MAX_FRAME_BYTES);
             if (this.binaryFramesSupported) {
               if (this.ws.readyState === WebSocket.OPEN) {
@@ -5434,6 +5554,7 @@ function classifyUpgradeRejection(headers) {
 }
 var MAX_RECONNECT_DELAY = 3e4;
 var BASE_RECONNECT_DELAY = 500;
+var RELAY_SILENCE_TIMEOUT_MS = 9e4;
 function getReconnectDelay(attempt) {
   const exponentialDelay = BASE_RECONNECT_DELAY * Math.pow(2, attempt);
   const jitter = Math.random() * 1e3;
@@ -5505,10 +5626,27 @@ function connectTunnel(options) {
       ws.close();
       reject(new Error("Connection timeout"));
     }, 3e4);
+    let relaySilenceTimeout;
+    let relaySilenceTimedOut = false;
+    const clearRelaySilenceTimeout = () => {
+      if (relaySilenceTimeout === void 0) return;
+      clearTimeout(relaySilenceTimeout);
+      relaySilenceTimeout = void 0;
+    };
+    const armRelaySilenceTimeout = () => {
+      clearRelaySilenceTimeout();
+      relaySilenceTimeout = setTimeout(() => {
+        relaySilenceTimeout = void 0;
+        relaySilenceTimedOut = true;
+        ws.terminate();
+      }, RELAY_SILENCE_TIMEOUT_MS);
+      relaySilenceTimeout.unref?.();
+    };
     let upgradeRejection = null;
     let upgradeRejectionReason = null;
     ws.on("unexpected-response", (_req, res) => {
       clearTimeout(connectionTimeout);
+      clearRelaySilenceTimeout();
       const reason = classifyUpgradeRejection(res.headers);
       upgradeRejectionReason = reason;
       const chunks = [];
@@ -5538,6 +5676,7 @@ function connectTunnel(options) {
       onInfo?.("WebSocket connection established");
     });
     ws.on("message", (data, isBinary) => {
+      if (relaySilenceTimeout !== void 0) armRelaySilenceTimeout();
       if (isBinary) {
         try {
           const frame = decodeBinaryBodyFrame(toUint8Array(data));
@@ -5571,6 +5710,7 @@ function connectTunnel(options) {
       switch (message.type) {
         case "connected": {
           clearTimeout(connectionTimeout);
+          armRelaySilenceTimeout();
           forwarder.setBinaryFramesSupported(message.binary_frames === true);
           const connectedAgentId = message.agent_id ?? agentId;
           onConnected?.(connectedAgentId);
@@ -5595,6 +5735,7 @@ function connectTunnel(options) {
     });
     ws.on("error", (error2) => {
       clearTimeout(connectionTimeout);
+      clearRelaySilenceTimeout();
       const detail = upgradeRejection ?? describeSocketError(error2, url);
       if (upgradeRejectionReason === "do_code_updated") {
         onWarning?.("Relay redeployed \u2014 reconnecting");
@@ -5606,7 +5747,8 @@ function connectTunnel(options) {
       );
     });
     ws.on("close", (code, reason) => {
-      const reasonStr = reason.toString() || upgradeRejection || (code === 1006 ? "abnormal closure" : "No reason provided");
+      clearRelaySilenceTimeout();
+      const reasonStr = (relaySilenceTimedOut ? "no relay heartbeat for 90s \u2014 reconnecting" : void 0) || reason.toString() || upgradeRejection || (code === 1006 ? "abnormal closure" : "No reason provided");
       forwarder.abortAll();
       onDisconnected?.(code, reasonStr);
     });
@@ -5614,9 +5756,10 @@ function connectTunnel(options) {
 }
 
 // src/lib/tunnel/runner-connection.ts
-var RunnerConnection = class {
+var RunnerConnection = class _RunnerConnection {
   opts;
   sleep;
+  now;
   connection = null;
   resolvedAgentId;
   /** True while a (re)connect loop is in flight. */
@@ -5625,10 +5768,17 @@ var RunnerConnection = class {
   reconnectPromise = null;
   /** 1-based count of the current reconnect attempt streak. */
   reconnectAttempt = 0;
+  generation = 0;
+  disconnectedAtMs = null;
+  static RELAY_RECONNECT_CLOSE_REASONS = /* @__PURE__ */ new Set([
+    "No pong received",
+    "Orphaned socket"
+  ]);
   constructor(opts) {
     this.opts = opts;
     this.resolvedAgentId = opts.agentId;
     this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.now = opts.now ?? Date.now;
   }
   get agentId() {
     return this.resolvedAgentId;
@@ -5664,14 +5814,24 @@ var RunnerConnection = class {
           port: this.opts.port,
           openCodePassword: this.opts.openCodePassword,
           onConnected: (agentId) => {
+            const attempt = this.reconnectAttempt + 1;
             this.reconnectAttempt = 0;
             this.reconnecting = false;
             this.resolvedAgentId = agentId;
-            events.onConnected(agentId, isReconnect);
+            this.generation++;
+            const downtimeMs = this.disconnectedAtMs === null ? null : this.now() - this.disconnectedAtMs;
+            this.disconnectedAtMs = null;
+            events.onConnected(agentId, isReconnect, {
+              generation: this.generation,
+              attempt,
+              downtimeMs
+            });
           },
           onDisconnected: (code, reason) => {
-            events.onDisconnected(code, reason);
-            if (this.opts.isRunning() && code !== 1e3 && !this.reconnecting) {
+            this.disconnectedAtMs = this.now();
+            events.onDisconnected(code, reason, { generation: this.generation });
+            const relayRequestedReconnect = code === 1e3 && _RunnerConnection.RELAY_RECONNECT_CLOSE_REASONS.has(reason);
+            if (this.opts.isRunning() && (code !== 1e3 || relayRequestedReconnect) && !this.reconnecting) {
               this.reconnectPromise = this.connectWithRetry(true).catch((err) => {
                 events.onError?.(`Reconnection failed: ${err.message}`);
               });
@@ -12147,6 +12307,7 @@ function createCredentialSync({
 
 // src/commands/run.ts
 var MAX_ACTIVITY_LOG_ENTRIES = 10;
+var MAX_DISCONNECT_REASON_LENGTH = 200;
 var CHANNEL_POLL_INTERVAL_MS = Number(process.env.EVIDENT_CHANNEL_POLL_INTERVAL_MS) || 2e3;
 var CHANNEL_STUCK_QUEUED_MS = Number(process.env.EVIDENT_STUCK_QUEUED_MS) || void 0;
 var SHUTDOWN_DRAIN_TIMEOUT_MS = Number(process.env.EVIDENT_SHUTDOWN_DRAIN_MS) || 25e3;
@@ -12365,7 +12526,9 @@ function displayStatus(state) {
   const opencode = state.opencodeConnected ? chalk7.green(`opencode: :${state.port}`) : chalk7.red(`opencode: :${state.port} (down)`);
   const messages = state.messageCount > 0 ? chalk7.dim(` \xB7 ${state.messageCount} processed`) : "";
   const last = state.activityLog[state.activityLog.length - 1];
-  const detail = last ? chalk7.dim(` \xB7 ${last.type === "error" ? last.error ?? "" : last.message ?? ""}`) : "";
+  const detail = last ? chalk7.dim(
+    ` \xB7 ${last.timestamp.toISOString()} ${last.type === "error" ? last.error ?? "" : last.message ?? ""}`
+  ) : "";
   const agent = state.agentName ?? state.agentId;
   console.log(
     `${chalk7.bold("Evident")} ${chalk7.dim(agent)}  ${tunnel}  ${opencode}${messages}${detail}`
@@ -12384,7 +12547,7 @@ function reportOpenCodeV2CredentialImport(state, result) {
     logActivity(state, {
       type: "info",
       level: "warn",
-      message: `OpenCode V2 saved login(s) for ${integrationIds} on this machine, but OpenCode V2 will not use them. See #2251 for importing existing logins.`
+      message: `OpenCode V2 saved login(s) for ${integrationIds} on this machine, but OpenCode V2 will not use them. Connect the provider again from the runner's page in Evident; no shell on this machine is needed.`
     });
   }
   if (result.imported.length === 0 && result.unsupported.length === 0 && result.failed.length === 0) {
@@ -13280,6 +13443,7 @@ async function run(options) {
     authHeader: ""
   };
   setTelemetryAuthProvider(() => ({ authHeader: state.authHeader, agentId: state.agentId }));
+  setTelemetryDiagnosticsReporter((message) => log2(state, message, "warn"));
   if (options.credentialSyncMarker) {
     state.credentialSync = createCredentialSync({
       markerPath: options.credentialSyncMarker,
@@ -13465,13 +13629,18 @@ async function run(options) {
       if (githubTokenPopulated) await configureGitHubAccess(credentialContext);
     }
     state.credentialSync?.arm();
-    state.stopOpenCodeLogTail = tailOpenCodeLogFile(
+    const openCodeActivityForwarder = createOpenCodeActivityForwarder(() => ({
+      agentId: state.agentId,
+      authHeader: state.authHeader
+    }));
+    const openCodeLogTail = tailOpenCodeLogFile(
       resolveOpenCodeLogPath(homedir7(), process.env),
-      createOpenCodeActivityForwarder(() => ({
-        agentId: state.agentId,
-        authHeader: state.authHeader
-      }))
-    ).stop;
+      openCodeActivityForwarder
+    );
+    state.stopOpenCodeLogTail = () => {
+      openCodeActivityForwarder.flush();
+      openCodeLogTail.stop();
+    };
     let sessionDbVerifyFatal = false;
     if (!options.restoreSessionDb) {
       log2(state, "Skipping session-DB restore: --restore-session-db was not passed", "debug");
@@ -13780,12 +13949,13 @@ async function run(options) {
       openCodePassword: state.opencodePassword,
       isRunning: () => state.running,
       events: {
-        onConnected: (agentId, isReconnect) => {
+        onConnected: (agentId, isReconnect, transition) => {
           state.connected = true;
           state.agentId = agentId;
+          const connectionMessage = isReconnect ? `Tunnel reconnected (runner: ${agentId}, generation: ${transition.generation}, attempt: ${transition.attempt}, offline for ${transition.downtimeMs}ms)` : `Tunnel connected (runner: ${agentId}, generation: ${transition.generation})`;
           logActivity(state, {
             type: "info",
-            message: `Tunnel ${isReconnect ? "reconnected" : "connected"} (runner: ${agentId})`
+            message: connectionMessage
           });
           if (options.tunnelReadyFile) {
             const marker = writeTunnelReadyMarker(options.tunnelReadyFile, agentId);
@@ -13806,7 +13976,12 @@ async function run(options) {
               version: state.opencodeVersion,
               major: state.opencodeApiVersion,
               connected: state.opencodeConnected
-            })
+            }),
+            connection_generation: transition.generation,
+            ...isReconnect && transition.downtimeMs !== null ? {
+              reconnect_attempt: transition.attempt,
+              downtime_ms: transition.downtimeMs
+            } : {}
           });
           if (!isReconnect) tunnelSpinner?.succeed("Tunnel connected");
           if (state.interactive) displayStatus(state);
@@ -13828,13 +14003,18 @@ async function run(options) {
             if (state.interactive) displayStatus(state);
           });
         },
-        onDisconnected: (code, reason) => {
+        onDisconnected: (code, reason, transition) => {
           state.connected = false;
+          const safeReason = redactDiagnosticText(reason).slice(0, MAX_DISCONNECT_REASON_LENGTH);
           logActivity(state, {
             type: "info",
-            message: `Tunnel disconnected (code: ${code}, reason: ${reason})`
+            message: `Tunnel disconnected (generation: ${transition.generation}, code: ${code}, reason: ${safeReason})`
+          });
+          emitAgentDisconnected(state.agentId, {
+            code,
+            reason: safeReason,
+            connection_generation: transition.generation
           });
-          emitAgentDisconnected(state.agentId, { code, reason });
           if (state.interactive) displayStatus(state);
         },
         onError: (error2) => {
@@ -13934,7 +14114,7 @@ async function run(options) {
       },
       report: (usage) => reportOpenAiUsage(state.agentId, state.authHeader, usage),
       isLocalCredentialProblem: isLocalCredentialProblem2,
-      forcedOnHint: "connect a ChatGPT account to this runner, or run `opencode auth login`",
+      forcedOnHint: state.opencodeApiVersion === "v2" ? "OpenCode V2 keeps its connected ChatGPT login in a store Evident cannot read" : "connect a ChatGPT account to this runner, or run `opencode auth login`",
       firstDelayMs: firstReportDelayMs,
       nextDelayMs: usageReportDelayMs,
       failureLogLevel: usageReportFailureLogLevel
@@ -13977,7 +14157,7 @@ async function run(options) {
 }
 
 // src/index.ts
-var { version } = createRequire2(import.meta.url)("../package.json");
+var version = getCliVersion();
 var program = new Command();
 program.name("evident").description("Run OpenCode locally and connect it to Evident").version(version).option(
   "--endpoint <url>",