@evident-ai/cli 3.0.1-dev.d06ae3c → 3.0.1-dev.dcef26e

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/commands/login.ts
@@ -716,13 +715,13 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
 
 // src/lib/opencode/opencode-version-gate.ts
 var QUEUE_VALIDATED_OPENCODE_VERSIONS = ["1.17.11"];
-function isQueueValidatedVersion(version2) {
-  if (!version2) return false;
-  return QUEUE_VALIDATED_OPENCODE_VERSIONS.includes(version2);
+function isQueueValidatedVersion(version) {
+  if (!version) return false;
+  return QUEUE_VALIDATED_OPENCODE_VERSIONS.includes(version);
 }
-function buildOpenCodeVersionWarning(version2) {
-  if (isQueueValidatedVersion(version2)) return null;
-  const detected = version2 ? `v${version2}` : "unknown";
+function buildOpenCodeVersionWarning(version) {
+  if (isQueueValidatedVersion(version)) return null;
+  const detected = version ? `v${version}` : "unknown";
   const validated = QUEUE_VALIDATED_OPENCODE_VERSIONS.map((v) => `v${v}`).join(", ");
   return `Warning: opencode ${detected} is not a queue-validated version (validated: ${validated}). Native message queuing \u2014 which channel (Slack/WhatsApp) message handling relies on \u2014 is unverified on this version; queued/follow-up messages may behave unexpectedly. Continuing anyway. Bumping the validated set requires re-running the queue validation.`;
 }
@@ -1059,10 +1058,6 @@ function finishOf(m) {
   const infoFinish = m.info?.finish;
   return typeof infoFinish === "string" ? infoFinish : void 0;
 }
-function isAssistantInFlight(m) {
-  if (completedOf(m) == null) return true;
-  return finishOf(m) === "tool-calls";
-}
 async function createOpenCodeSession(port, directory) {
   const url = new URL(`${opencodeBase(port)}/session`);
   if (directory && directory.trim()) {
@@ -1144,13 +1139,9 @@ function messageRunState(messages, userMessageId) {
     if (!reply) return "unknown";
   }
   if (!reply) return "queued";
-  return isAssistantInFlight(reply) ? "running" : "done";
-}
-function hasRunningAssistantExcept(messages, exceptUserMessageId) {
-  if (!messages || messages.length === 0) return false;
-  return messages.some(
-    (m) => roleOf(m) === "assistant" && parentIdOf(m) !== exceptUserMessageId && isAssistantInFlight(m)
-  );
+  if (completedOf(reply) == null) return "running";
+  if (finishOf(reply) === "tool-calls") return "running";
+  return "done";
 }
 function opencodeMessageIdFor2(queuedMessageId) {
   return opencodeMessageIdFor(queuedMessageId);
@@ -1560,7 +1551,6 @@ var DEFAULT_RETRY_POLICY = {
 var DEFAULT_PAUSED_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_PAUSED_MAX_WAIT_MS = 10 * 60 * 1e3;
 var DEFAULT_DISPATCH_CONFIRM_MS = 6e3;
-var DEFAULT_STUCK_QUEUED_MS = 6e4;
 var ChannelAuthError = class extends Error {
   constructor(message) {
     super(message);
@@ -1596,7 +1586,6 @@ var ChannelDriver = class {
   pausedPollIntervalMs;
   pausedMaxWaitMs;
   dispatchConfirmMs;
-  stuckQueuedMs;
   now;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
@@ -1616,40 +1605,6 @@ var ChannelDriver = class {
    * a steady-state-poll re-dispatch will not double-run the message.
    */
   dispatched = /* @__PURE__ */ new Set();
-  /**
-   * Re-adopted (ADR-0046) Evident message ids currently tracked by a watcher.
-   * Used only to distinguish a RE-ADOPTED give-up from a normal-dispatch give-up
-   * so the former can be parked in `dontRedispatch` (Bug 2). A row is added when
-   * it is re-adopted and removed when its watcher settles or it is observed off
-   * the processing list.
-   */
-  readopted = /* @__PURE__ */ new Set();
-  /**
-   * "Don't re-DISPATCH / re-attach this orphan again" (Bug 2/5). Set when a
-   * re-adopted running/orphan row's watcher hit its `processed_at`-anchored
-   * deadline (or an orphan whose window already elapsed): the still-`processing`
-   * server row would otherwise be re-adopted (and re-dispatched) on EVERY ~2s
-   * drain until the 15-min cron resets it — spamming new turns.
-   *
-   * CRITICAL (Bugbot #202): this suppresses ONLY the dispatch/re-attach paths, it
-   * does NOT suppress DONE delivery. A row parked here whose reply later COMPLETES
-   * in opencode must still be delivered via `markDone` on the next drain — so
-   * `readoptOne` computes `state` FIRST and this set is checked only on the
-   * non-done path. It is cleared once the row leaves the processing list (cron
-   * reset → it drains normally as `pending`), so it can never leak.
-   */
-  dontRedispatch = /* @__PURE__ */ new Set();
-  /**
-   * "markDone for this row is TERMINALLY undeliverable" (Bug 4). Set ONLY when a
-   * re-adopted DONE row's `markDone` returned a terminal 4xx (a status that will
-   * never succeed). Checked at the TOP of the `done` branch so we do NOT re-attempt
-   * that markDone every ~2s drain while the row stays `processing`. A TRANSIENT
-   * markDone failure must NOT land here (it must still retry next drain). Separate
-   * from `dontRedispatch` because the two concerns are independent: a row can need
-   * "stop re-dispatching" without "stop delivering", and vice versa. Cleared once
-   * the row leaves the processing list, exactly like `dontRedispatch`.
-   */
-  doneUndeliverable = /* @__PURE__ */ new Set();
   /**
    * Cache of the opencode root directory (from `GET /path`). Resolved lazily on
    * first session creation so drain-created sessions are rooted at the project
@@ -1673,7 +1628,6 @@ var ChannelDriver = class {
     this.pausedPollIntervalMs = config2.pausedPollIntervalMs ?? DEFAULT_PAUSED_POLL_INTERVAL_MS;
     this.pausedMaxWaitMs = config2.pausedMaxWaitMs ?? DEFAULT_PAUSED_MAX_WAIT_MS;
     this.dispatchConfirmMs = config2.dispatchConfirmMs ?? DEFAULT_DISPATCH_CONFIRM_MS;
-    this.stuckQueuedMs = config2.stuckQueuedMs ?? DEFAULT_STUCK_QUEUED_MS;
     this.now = config2.now ?? (() => Date.now());
   }
   /** The IPv4-loopback base URL for the local `opencode serve`. */
@@ -1706,7 +1660,6 @@ var ChannelDriver = class {
       for (const conv of conversations) {
         dispatched += await this.processConversation(conv);
       }
-      await this.readoptProcessing();
     } finally {
       this.draining = false;
     }
@@ -1793,7 +1746,6 @@ var ChannelDriver = class {
       this.dispatched.add(message.id);
       this.registerInFlight(conv, sessionId, message, opencodeMessageId);
       dispatched += 1;
-      void this.postSignal(conv.id, message.id, "dispatched");
     }
     if (messages.length > 0 && dispatched === 0 && skippedAlreadyDispatched === messages.length) {
       this.log({
@@ -1859,54 +1811,7 @@ var ChannelDriver = class {
       dispatchedAt: now,
       deadline: now + this.pausedMaxWaitMs,
       started: false,
-      done: false,
-      stuckReported: false
-    });
-  }
-  /**
-   * 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`: a row already `processing` for e.g. 5 min must give up ~5 min from now
-   * (10 min after `processed_at`), not 10 min from now — otherwise its deadline
-   * lands ~15 min after `processed_at`, coinciding with the cron reset →
-   * double-drive race. `dispatchedAt` stays `now` (only the appear-guard uses it).
-   *
-   * `evidentMessageId` addresses the SERVER row (for markProcessing/markDone);
-   * `opencodeMessageId` is the id the watcher polls for a reply — for the orphan
-   * fresh-run path these differ (a fresh opencode id under the same server row).
-   *
-   * `started` is set true so the watcher does NOT re-`markProcessing` a row the
-   * server already flipped to `processing`; the running/done transitions still
-   * fire from the watcher's normal branches.
-   */
-  registerReadopted(conv, sessionId, message, opencodeMessageId, processedAtMs) {
-    let watcher = this.watchers.get(sessionId);
-    if (!watcher) {
-      watcher = {
-        conv,
-        inFlight: /* @__PURE__ */ new Map(),
-        loop: null,
-        reportedQuestions: /* @__PURE__ */ new Set(),
-        reportedPermissions: /* @__PURE__ */ new Set()
-      };
-      this.watchers.set(sessionId, watcher);
-    }
-    watcher.inFlight.set(message.id, {
-      evidentMessageId: message.id,
-      opencodeMessageId,
-      message,
-      dispatchedAt: this.now(),
-      deadline: processedAtMs + this.pausedMaxWaitMs,
-      // The server row is ALREADY `processing`; do not re-fire markProcessing.
-      started: true,
-      done: false,
-      // Not yet reported stuck-queued. The once-guard (`stuckReported`) applies,
-      // AND the stuck-queued observer now INCLUDES re-adopted queued wedges: it
-      // gates on `state === 'queued'` (turn produced no reply), not on `started`,
-      // so a re-adopted row left wedged in `queued` still emits the signal once
-      // (queued-followup-redrive, #210).
-      stuckReported: false
+      done: false
     });
   }
   /**
@@ -1972,7 +1877,6 @@ var ChannelDriver = class {
           conversation_id: watcher.conv.id
         });
         for (const evidentMessageId of [...watcher.inFlight.keys()]) {
-          this.readopted.delete(evidentMessageId);
           this.removeInFlight(watcher, evidentMessageId);
         }
         return;
@@ -2067,12 +1971,6 @@ var ChannelDriver = class {
         await this.redispatchInFlight(sessionId, inFlight);
       }
     }
-    if (state === "queued" && !inFlight.stuckReported && this.now() - inFlight.dispatchedAt >= this.stuckQueuedMs && !hasRunningAssistantExcept(messages, inFlight.opencodeMessageId)) {
-      inFlight.stuckReported = true;
-      void this.postSignal(conv.id, inFlight.evidentMessageId, "stuck_queued", {
-        stuck_for_ms: this.now() - inFlight.dispatchedAt
-      });
-    }
     if (this.now() >= inFlight.deadline) {
       this.log({
         level: "info",
@@ -2116,310 +2014,12 @@ var ChannelDriver = class {
     }
     inFlight.dispatchedAt = this.now();
   }
-  // -------------------------------------------------------------------------
-  // Restart recovery: re-adopt `processing` messages (ADR-0046, WI-3/4/5)
-  // -------------------------------------------------------------------------
-  /**
-   * Re-adopt this agent's `processing` messages on drain (ADR-0046 Decision §1).
-   *
-   * The pending drain only re-drives `pending` rows; a message already flipped to
-   * `processing` before the runner died is watched by nobody until the 15-min
-   * cron resets it. Here we fetch those rows, and per row resolve its correlated
-   * reply against opencode's OWN session store — completing, re-attaching, or
-   * (for an orphan) forcing a genuine fresh run. Runs on EVERY drain tick, so it
-   * is idempotent per message (Invariant 2): a row a watcher already tracks is
-   * skipped in `readoptOne` — one driver, no double-drive.
-   *
-   * Only `ChannelAuthError` propagates (to `drainPending`, like the pending
-   * path); every other early return LOGS a reason with context — no silent drop.
-   */
-  async readoptProcessing() {
-    const rows = await this.getProcessingMessages();
-    if (this.dontRedispatch.size > 0 || this.doneUndeliverable.size > 0) {
-      const stillProcessing = new Set(rows.map((r) => r.id));
-      for (const id of [...this.dontRedispatch, ...this.doneUndeliverable]) {
-        if (!stillProcessing.has(id)) {
-          const cleared = this.dontRedispatch.delete(id);
-          const clearedUndeliverable = this.doneUndeliverable.delete(id);
-          if (cleared || clearedUndeliverable) {
-            this.log({
-              level: "info",
-              message: `Re-adopt: message ${id.slice(0, 8)} left the processing list (cron reset) \u2014 cleared gave-up marker`,
-              message_id: id
-            });
-          }
-        }
-      }
-    }
-    if (rows.length === 0) return;
-    const bySession = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      if (!row.opencode_session_id) {
-        this.log({
-          level: "error",
-          message: `Cannot re-adopt processing message ${row.id.slice(0, 8)} \u2014 no opencode session id; leaving for the cron safety net`,
-          conversation_id: row.conversation_id,
-          message_id: row.id
-        });
-        continue;
-      }
-      const list = bySession.get(row.opencode_session_id) ?? [];
-      list.push(row);
-      bySession.set(row.opencode_session_id, list);
-    }
-    for (const [sessionId, sessionRows] of bySession) {
-      let messages;
-      try {
-        const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
-        if (!res.ok) {
-          this.log({
-            level: "error",
-            message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned HTTP ${res.status} \u2014 skipping this session this tick`
-          });
-          continue;
-        }
-        const body = await res.json();
-        if (!Array.isArray(body)) {
-          this.log({
-            level: "error",
-            message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned a non-array message body \u2014 skipping this session this tick`
-          });
-          continue;
-        }
-        messages = body;
-      } catch (err) {
-        this.log({
-          level: "error",
-          message: `Re-adopt: failed to poll session ${sessionId.slice(0, 8)} (will retry next drain): ${err instanceof Error ? err.message : String(err)}`
-        });
-        continue;
-      }
-      for (const row of sessionRows) {
-        await this.readoptOne(sessionId, row, messages);
-      }
-    }
-  }
-  /**
-   * Re-adopt ONE `processing` row against the tick's session message snapshot
-   * (ADR-0046 Decision §1/§2). Idempotent: skips a row already being driven.
-   *
-   * Branches on `messageRunState(messages, opencodeMessageIdFor(row.id))`:
-   *   - `done`             → `markDone` now (guarded like the watcher's done branch);
-   *   - `running`/`queued` → re-attach a watcher via `registerReadopted` (no re-dispatch);
-   *   - `unknown`          → re-dispatch the STABLE id + attach a watcher (orphan).
-   *
-   * Only `ChannelAuthError` propagates.
-   */
-  async readoptOne(sessionId, row, messages) {
-    if (this.isTracked(sessionId, row.id)) {
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} already tracked in-flight \u2014 skipping (owned by the watcher loop)`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      return;
-    }
-    const ocId = opencodeMessageIdFor2(row.id);
-    const state = messageRunState(messages, ocId);
-    if (state === "done") {
-      if (this.doneUndeliverable.has(row.id)) {
-        this.log({
-          level: "info",
-          message: `Re-adopt: message ${row.id.slice(0, 8)} markDone is terminally undeliverable \u2014 left to the cron; skipping until it leaves processing`,
-          conversation_id: row.conversation_id,
-          message_id: row.id
-        });
-        return;
-      }
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} completed while unwatched \u2014 marking done`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      try {
-        await this.markDone(row.conversation_id, row.id, sessionId);
-      } catch (err) {
-        if (err instanceof ChannelAuthError) throw err;
-        if (err instanceof ChannelTerminalError) {
-          this.doneUndeliverable.add(row.id);
-          this.log({
-            level: "error",
-            message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 parking until it leaves processing; leaving for the cron safety net: ${err.message}`,
-            conversation_id: row.conversation_id,
-            message_id: row.id
-          });
-          return;
-        }
-        this.log({
-          level: "error",
-          message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (will retry next drain): ${err instanceof Error ? err.message : String(err)}`,
-          conversation_id: row.conversation_id,
-          message_id: row.id
-        });
-        return;
-      }
-      this.dontRedispatch.delete(row.id);
-      return;
-    }
-    if (this.dontRedispatch.has(row.id)) {
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} already gave up \u2014 left to the cron; skipping until it leaves processing`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      return;
-    }
-    if (state === "running" || state === "queued") {
-      const conv = this.convForRow(sessionId, row);
-      const message = this.queuedMessageForRow(row);
-      this.registerReadopted(conv, sessionId, message, ocId, this.processedAtMs(row));
-      this.dispatched.add(row.id);
-      this.readopted.add(row.id);
-      this.ensureWatcherRunning(sessionId);
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} ${state} \u2014 re-attached watcher (stable id, no re-dispatch)`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      return;
-    }
-    await this.forceReadoptRun(sessionId, row);
-  }
-  /**
-   * Re-dispatch an orphaned (`unknown`) `processing` row (ADR-0046 Decision §2).
-   *
-   * The stable-id user message is absent from the session, so we (re-)dispatch with
-   * the STABLE id (`opencodeMessageIdFor(row.id)`) — NOT a divergent per-attempt id.
-   * This is what keeps the reply correlatable: the server's completion
-   * notification looks for the reply under the stable id, so the fresh turn's reply
-   * (which hangs off the stable id) is found and delivered. The residual
-   * duplicate-incomplete-turn semantics (ADR §2, `.harness/restart-recovery-orphan-finding.md`)
-   * are unchanged and, for an ABSENT id, cannot bite — there is no existing turn
-   * to swallow the duplicate.
-   *
-   * `evidentMessageId = row.id` addresses the SERVER row; the stable
-   * `opencodeMessageId` is what the watcher polls. Deadline anchored to
-   * `processed_at` (Invariant 1).
-   */
-  async forceReadoptRun(sessionId, row) {
-    const ocId = opencodeMessageIdFor2(row.id);
-    if (this.processedAtMs(row) + this.pausedMaxWaitMs <= this.now()) {
-      this.dontRedispatch.add(row.id);
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} orphaned but its re-adopt window has already elapsed \u2014 not dispatching an unwatchable turn; parking until it leaves processing (cron will reset it)`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      return;
-    }
-    const options = {
-      agent: row.opencode_agent ?? void 0,
-      model: row.opencode_model ?? void 0
-    };
-    this.log({
-      level: "info",
-      message: `Re-adopt: message ${row.id.slice(0, 8)} orphaned (user message absent) \u2014 re-dispatching with the stable id`,
-      conversation_id: row.conversation_id,
-      message_id: row.id
-    });
-    try {
-      await sendPromptAsync(this.port, sessionId, row.content, options, ocId);
-    } catch (err) {
-      if (err instanceof ChannelAuthError) throw err;
-      this.log({
-        level: "error",
-        message: `Re-adopt: re-dispatch failed for message ${row.id.slice(0, 8)} (will retry next drain): ${err instanceof Error ? err.message : String(err)}`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      return;
-    }
-    const conv = this.convForRow(sessionId, row);
-    const message = this.queuedMessageForRow(row);
-    this.registerReadopted(conv, sessionId, message, ocId, this.processedAtMs(row));
-    this.dispatched.add(row.id);
-    this.readopted.add(row.id);
-    this.ensureWatcherRunning(sessionId);
-  }
-  /**
-   * True if `evidentMessageId` is already being driven — either in the
-   * authoritative `dispatched` set or a live watcher's in-flight set for this
-   * session (Invariant 2, WI-5). Either signal means a watcher owns the row.
-   */
-  isTracked(sessionId, evidentMessageId) {
-    if (this.dispatched.has(evidentMessageId)) return true;
-    const watcher = this.watchers.get(sessionId);
-    return watcher?.inFlight.has(evidentMessageId) ?? false;
-  }
-  /**
-   * Parse a re-adopt row's `processed_at` (ISO string) to epoch ms for the
-   * deadline anchor (Invariant 1). The endpoint guarantees `processed_at` is set
-   * for `processing` rows, but if it is somehow null/unparseable fall back to
-   * `now` (defensive) AND log — a fallback means the anchor is weaker than
-   * intended, which is worth surfacing.
-   */
-  processedAtMs(row) {
-    const parsed = row.processed_at ? Date.parse(row.processed_at) : NaN;
-    if (!Number.isNaN(parsed)) return parsed;
-    this.log({
-      level: "error",
-      message: `Re-adopt: message ${row.id.slice(0, 8)} has null/unparseable processed_at (${String(row.processed_at)}) \u2014 anchoring deadline to now (defensive)`,
-      conversation_id: row.conversation_id,
-      message_id: row.id
-    });
-    return this.now();
-  }
-  /** Build the `PendingConversation` shape the watcher needs from a re-adopt row. */
-  convForRow(sessionId, row) {
-    return {
-      id: row.conversation_id,
-      agent_id: this.agentId,
-      opencode_session_id: sessionId,
-      pending_message_count: 0,
-      oldest_pending_at: row.processed_at
-    };
-  }
-  /** Build the `QueuedMessage` shape the watcher/re-dispatch needs from a re-adopt row. */
-  queuedMessageForRow(row) {
-    return {
-      id: row.id,
-      content: row.content,
-      status: "processing",
-      opencode_agent: row.opencode_agent,
-      opencode_model: row.opencode_model,
-      source_message_id: row.source_message_id,
-      slack_user_id: row.slack_user_id
-    };
-  }
   /**
    * Remove a message from the in-flight set AND the authoritative dispatched
    * set. Once the in-flight set empties, the watcher loop's `while` guard exits
    * and its `.finally` removes the session entry from `this.watchers`.
-   *
-   * Bug 2: if a RE-ADOPTED message is removed WITHOUT having completed
-   * (`!inFlight.done` — i.e. a give-up: deadline reached, or markDone left to the
-   * cron), park it in `dontRedispatch` so the next drain does NOT re-adopt (and
-   * re-dispatch) the still-`processing` row every ~2s until the 15-min cron. A
-   * re-adopted message that completed (`done`) needs no marker — it's leaving
-   * `processing`. This suppresses only re-dispatch: if its reply later completes,
-   * the done branch still delivers it (Bugbot #202).
    */
   removeInFlight(watcher, evidentMessageId) {
-    const inFlight = watcher.inFlight.get(evidentMessageId);
-    if (this.readopted.delete(evidentMessageId) && inFlight && !inFlight.done) {
-      this.dontRedispatch.add(evidentMessageId);
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${evidentMessageId.slice(0, 8)} gave up \u2014 parking until it leaves the processing list (cron reset)`,
-        conversation_id: watcher.conv.id,
-        message_id: evidentMessageId
-      });
-    }
     watcher.inFlight.delete(evidentMessageId);
     this.dispatched.delete(evidentMessageId);
   }
@@ -2563,35 +2163,6 @@ var ChannelDriver = class {
     }
     return await res.json();
   }
-  /**
-   * Fetch this agent's `processing` messages for re-adoption (ADR-0046, WI-1).
-   * The pending path (`getPendingConversations`/`getPendingMessages`) only
-   * surfaces `pending` rows, so a message already `processing` when the runner
-   * died is invisible to it — this dedicated endpoint returns exactly those rows
-   * with the fields the re-adopt path needs (`processed_at`,
-   * `opencode_session_id`, routing).
-   *
-   * Response is an OBJECT WRAPPER `{ messages: [...] }` (snake_case) — NOT a bare
-   * array. Propagates `ChannelAuthError` on 401/403; throws a plain `Error` on
-   * other non-ok so `drainPending`'s try/finally leaves `draining` false and the
-   * next tick retries.
-   */
-  async getProcessingMessages() {
-    const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/conversations/processing`,
-      { headers: { Authorization: this.getAuthHeader() } }
-    );
-    this.assertAuth(res, "fetching processing messages");
-    if (!res.ok) {
-      throw new Error(`Failed to get processing messages: HTTP ${res.status}`);
-    }
-    const data = await res.json();
-    let messages = data.messages ?? [];
-    if (this.conversationFilter) {
-      messages = messages.filter((m) => m.conversation_id === this.conversationFilter);
-    }
-    return messages;
-  }
   /**
    * EXISTING combinedAuth route — now fired by the watcher on queued→running
    * (Task 3.3), NOT at dispatch/claim time. `{status:'processing',
@@ -2686,42 +2257,6 @@ var ChannelDriver = class {
       )
     );
   }
-  /**
-   * Best-effort, SINGLE-ATTEMPT runner→server telemetry ping
-   * (queued-followup-redrive). `POST .../messages/:id/signal {signal, ...extra}`
-   * — the server records it via `log()` (no DB write, no notification). This is
-   * fire-and-forget: it MUST NEVER throw into the drain or the watcher tick, and
-   * MUST NOT use `callWithRetry` (a telemetry ping must not block the sequential
-   * watcher tick — one attempt is enough). A failure is SWALLOWED but LOGGED with
-   * context (no silent catch, per development-workflow).
-   */
-  async postSignal(conversationId, messageId, signal, extra) {
-    try {
-      const res = await this.fetchImpl(
-        `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}/signal`,
-        {
-          method: "POST",
-          headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
-          body: JSON.stringify({ signal, ...extra })
-        }
-      );
-      if (!res.ok) {
-        this.log({
-          level: "error",
-          message: `Signal '${signal}' for message ${messageId.slice(0, 8)} returned HTTP ${res.status} (telemetry-only, ignored)`,
-          conversation_id: conversationId,
-          message_id: messageId
-        });
-      }
-    } catch (err) {
-      this.log({
-        level: "error",
-        message: `Signal '${signal}' for message ${messageId.slice(0, 8)} failed (telemetry-only, ignored): ${err instanceof Error ? err.message : String(err)}`,
-        conversation_id: conversationId,
-        message_id: messageId
-      });
-    }
-  }
   async persistSession(conversationId, sessionId) {
     const res = await this.fetchImpl(
       `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}`,
@@ -3150,7 +2685,6 @@ async function handleAuthError(state, error2) {
 }
 async function driveChannels(state, driver) {
   let idlePolls = 0;
-  let lastSeenProxiedActivityAt = state.lastProxiedActivityAt;
   while (state.running) {
     if (state.connection?.reconnecting && state.connection.reconnectPromise) {
       logActivity(state, { type: "info", message: "Waiting for tunnel reconnection..." });
@@ -3160,9 +2694,7 @@ async function driveChannels(state, driver) {
     try {
       const processed = await driver.drainPending();
       state.messageCount += processed;
-      const proxiedActivity = state.lastProxiedActivityAt !== lastSeenProxiedActivityAt;
-      lastSeenProxiedActivityAt = state.lastProxiedActivityAt;
-      if (processed > 0 || driver.hasInFlightWatchers() || proxiedActivity) {
+      if (processed > 0 || driver.hasInFlightWatchers()) {
         idlePolls = 0;
         if (processed > 0 && state.interactive) displayStatus(state);
       } else if (state.idleTimeout !== null) {
@@ -3237,7 +2769,6 @@ async function run(options) {
     running: true,
     activityLog: [],
     messageCount: 0,
-    lastProxiedActivityAt: null,
     authHeader: ""
   };
   if (state.idleTimeout === null && (process.env.GITHUB_ACTIONS || process.env.CI)) {
@@ -3354,8 +2885,8 @@ async function run(options) {
       state.opencodeProcess = oc.process;
       state.opencodeVersion = oc.version;
       state.opencodeConnected = oc.process !== null || oc.version !== null;
-      const version2 = state.opencodeVersion ? ` (v${state.opencodeVersion})` : "";
-      ocSpinner?.succeed(`OpenCode running on port ${state.port}${version2}`);
+      const version = state.opencodeVersion ? ` (v${state.opencodeVersion})` : "";
+      ocSpinner?.succeed(`OpenCode running on port ${state.port}${version}`);
       const versionWarning = buildOpenCodeVersionWarning(state.opencodeVersion);
       if (versionWarning) {
         log2(state, versionWarning, false);
@@ -3427,14 +2958,9 @@ async function run(options) {
           logActivity(state, { type: "error", error: error2 });
           if (state.interactive) displayStatus(state);
         },
-        // Web traffic is proxied transparently; note opencode is live and stamp
-        // proxied activity so the idle loop treats interactive proxy use as work.
-        // Fires per forwarded response head (incl. every SSE open) and excludes
-        // the internal drain-ping, so an actively-used proxy keeps the timer
-        // fresh while a lone idle SSE with no follow-up requests still ages out.
+        // Web traffic is proxied transparently; only note opencode is live.
         onResponse: () => {
           state.opencodeConnected = true;
-          state.lastProxiedActivityAt = Date.now();
         },
         // A channel message was queued and the api-worker pinged us over the
         // tunnel to drain immediately instead of waiting for the next poll tick.
@@ -3507,9 +3033,8 @@ async function run(options) {
 }
 
 // src/index.ts
-var { version } = createRequire(import.meta.url)("../package.json");
 var program = new Command();
-program.name("evident").description("Run OpenCode locally and connect it to Evident").version(version).option(
+program.name("evident").description("Run OpenCode locally and connect it to Evident").version("0.1.0").option(
   "--endpoint <url>",
   "Evident API base URL (default: production; e.g. http://localhost:3001)"
 ).option("--tunnel <url>", "Tunnel WebSocket URL (default: production; e.g. ws://localhost:8787)").hook("preAction", (thisCommand) => {