@evident-ai/cli 3.0.1-dev.28a3007 → 3.0.1-dev.3be0a8d

package/dist/index.js

@@ -684,19 +684,6 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
   return { healthy: false, error: "Timeout waiting for OpenCode to be healthy" };
 }
 
-// src/lib/opencode/opencode-version-gate.ts
-var QUEUE_VALIDATED_OPENCODE_VERSIONS = ["1.17.11"];
-function isQueueValidatedVersion(version) {
-  if (!version) return false;
-  return QUEUE_VALIDATED_OPENCODE_VERSIONS.includes(version);
-}
-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.`;
-}
-
 // src/lib/opencode/process.ts
 import { execSync, spawn } from "child_process";
 var OPENCODE_PORT_RANGE = [4096, 4097, 4098, 4099, 4100];
@@ -1011,17 +998,21 @@ function completedOf(m) {
   if (!m || typeof m !== "object") return void 0;
   return m.info?.time?.completed;
 }
-function idOf(m) {
-  if (!m || typeof m !== "object") return void 0;
-  if (typeof m.id === "string") return m.id;
-  const infoId = m.info?.id;
-  return typeof infoId === "string" ? infoId : void 0;
+async function getSessionMessages(port, sessionId) {
+  try {
+    const res = await fetch(`${opencodeBase(port)}/session/${sessionId}/message`);
+    if (!res.ok) return null;
+    const body = await res.json();
+    return Array.isArray(body) ? body : null;
+  } catch {
+    return null;
+  }
 }
-function parentIdOf(m) {
-  if (!m || typeof m !== "object") return void 0;
-  if (typeof m.parentID === "string") return m.parentID;
-  const infoParent = m.info?.parentID;
-  return typeof infoParent === "string" ? infoParent : void 0;
+function isTurnComplete(messages) {
+  if (!messages || messages.length === 0) return false;
+  const last = messages[messages.length - 1];
+  if (roleOf(last) !== "assistant") return false;
+  return completedOf(last) != null;
 }
 async function createOpenCodeSession(port, directory) {
   const url = new URL(`${opencodeBase(port)}/session`);
@@ -1040,9 +1031,8 @@ async function createOpenCodeSession(port, directory) {
   const data = await response.json();
   return data.id;
 }
-async function sendPromptAsync(port, sessionId, content, options, messageId) {
+async function sendMessageToOpenCode(port, sessionId, content, options, hooks, maxWaitMs = 10 * 60 * 1e3) {
   const body = {
-    messageID: messageId,
     parts: [{ type: "text", text: content }]
   };
   if (options?.agent) {
@@ -1057,42 +1047,79 @@ async function sendPromptAsync(port, sessionId, content, options, messageId) {
       };
     }
   }
-  const res = await fetch(`${opencodeBase(port)}/session/${sessionId}/prompt_async`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  if (res.status < 200 || res.status >= 300) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`OpenCode prompt_async failed: HTTP ${res.status}${text ? `: ${text}` : ""}`);
-  }
-}
-function findAssistantReplyAfter(messages, userMessageId) {
-  if (!messages || messages.length === 0) return null;
-  const byParent = messages.find(
-    (m) => roleOf(m) === "assistant" && parentIdOf(m) === userMessageId
-  );
-  if (byParent) return byParent;
-  const userIndex = messages.findIndex((m) => idOf(m) === userMessageId);
-  if (userIndex === -1) return null;
-  for (let i = userIndex + 1; i < messages.length; i++) {
-    if (roleOf(messages[i]) === "assistant") return messages[i];
-  }
-  return null;
-}
-function messageRunState(messages, userMessageId) {
-  if (!messages || messages.length === 0) return "unknown";
-  const hasUser = messages.some((m) => idOf(m) === userMessageId);
-  const reply = findAssistantReplyAfter(messages, userMessageId);
-  if (!hasUser) {
-    if (!reply) return "unknown";
-  }
-  if (!reply) return "queued";
-  return completedOf(reply) != null ? "done" : "running";
-}
-function opencodeMessageIdFor(queuedMessageId) {
-  const sanitized = queuedMessageId.replace(/[^a-zA-Z0-9]/g, "_");
-  return `msg_${sanitized}`;
+  let pollDone = false;
+  const reportedQuestions = /* @__PURE__ */ new Set();
+  const reportedPermissions = /* @__PURE__ */ new Set();
+  const pollInteractive = async () => {
+    while (!pollDone) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      if (pollDone) break;
+      if (hooks?.onQuestion) {
+        try {
+          const res = await fetch(`${opencodeBase(port)}/question`);
+          if (res.ok) {
+            const questions = await res.json();
+            for (const q of questions) {
+              if (q.sessionID === sessionId && !reportedQuestions.has(q.id)) {
+                reportedQuestions.add(q.id);
+                await hooks.onQuestion(q);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (hooks?.onPermission) {
+        try {
+          const res = await fetch(`${opencodeBase(port)}/permission`);
+          if (res.ok) {
+            const permissions = await res.json();
+            for (const p of permissions) {
+              if (p.sessionID === sessionId && !reportedPermissions.has(p.id)) {
+                reportedPermissions.add(p.id);
+                await hooks.onPermission(p);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  };
+  const sendMessage = async () => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), maxWaitMs);
+    try {
+      const res = await fetch(`${opencodeBase(port)}/session/${sessionId}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`OpenCode message failed: HTTP ${res.status}${text ? `: ${text}` : ""}`);
+      }
+      const sessionRes = await fetch(`${opencodeBase(port)}/session/${sessionId}`).catch(
+        () => null
+      );
+      const session = sessionRes?.ok ? await sessionRes.json() : null;
+      const reportedInteraction = reportedQuestions.size > 0 || reportedPermissions.size > 0;
+      const turnComplete = isTurnComplete(await getSessionMessages(port, sessionId));
+      const awaitingInteraction = reportedInteraction && !turnComplete;
+      return { title: session?.title, awaitingInteraction };
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error("Message processing timed out");
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+      pollDone = true;
+    }
+  };
+  const [result] = await Promise.all([sendMessage(), pollInteractive()]);
+  return result;
 }
 
 // src/lib/tunnel/connection.ts
@@ -1471,12 +1498,6 @@ var RunnerConnection = class {
 };
 
 // src/lib/channels/driver.ts
-function messageIdOf(m) {
-  if (!m || typeof m !== "object") return void 0;
-  if (typeof m.id === "string") return m.id;
-  const infoId = m.info?.id;
-  return typeof infoId === "string" ? infoId : void 0;
-}
 var DEFAULT_RETRY_POLICY = {
   maxAttempts: 6,
   baseDelayMs: 500,
@@ -1484,21 +1505,12 @@ 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 ChannelAuthError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "ChannelAuthError";
   }
 };
-var ChannelTerminalError = class extends Error {
-  status;
-  constructor(message, status) {
-    super(message);
-    this.name = "ChannelTerminalError";
-    this.status = status;
-  }
-};
 function backoffDelay(attempt, policy) {
   const exp = policy.baseDelayMs * Math.pow(2, attempt);
   const capped = Math.min(policy.maxDelayMs, exp);
@@ -1519,26 +1531,15 @@ var ChannelDriver = class {
   sleep;
   pausedPollIntervalMs;
   pausedMaxWaitMs;
-  dispatchConfirmMs;
-  now;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
   /**
-   * Per-SESSION watchers (WI-3), keyed by opencode sessionId. Single-flight per
-   * session: one polling loop services all of that session's in-flight messages.
-   * A session entry exists while it has any in-flight (dispatched-but-not-done)
-   * message; it is removed once its in-flight set empties.
+   * Outstanding paused-session watchers, keyed by `message.id` (WI-2-CLI).
+   * Single-flight per message: while a watcher is live for a message we never
+   * start a second one. The message stays `processing` for the watcher's lifetime
+   * so the `?status=pending` drain cannot double-claim it.
    */
   watchers = /* @__PURE__ */ new Map();
-  /**
-   * AUTHORITATIVE local dedup (WI-3): Evident message ids that have been
-   * dispatched and are still in-flight. A message in this set is never
-   * re-`prompt_async`-ed by a subsequent poll tick while it is queued/running.
-   * Backed by a stable minted opencode `messageID` whose duplicate re-enqueue is
-   * idempotent on opencode (PoC fact 9) — so even if this set is lost on restart,
-   * a steady-state-poll re-dispatch will not double-run the message.
-   */
-  dispatched = /* @__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
@@ -1561,8 +1562,6 @@ var ChannelDriver = class {
     this.sleep = config2.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     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.now = config2.now ?? (() => Date.now());
   }
   /** The IPv4-loopback base URL for the local `opencode serve`. */
   get opencodeBase() {
@@ -1572,16 +1571,16 @@ var ChannelDriver = class {
   // Public API
   // -------------------------------------------------------------------------
   /**
-   * Drain all pending channel conversations once: poll → dispatch → register.
+   * Drain all pending channel conversations once: poll → process → callback.
    * Called on tunnel `connected` (WI-CHAN-4) and on each poll tick by `run.ts`.
    * Re-entrant calls while a drain is in flight are skipped (return 0).
    *
-   * @returns the number of messages NEWLY dispatched to opencode's native queue.
+   * @returns the number of messages processed.
    */
   async drainPending() {
     if (this.draining) return 0;
     this.draining = true;
-    let dispatched = 0;
+    let processed = 0;
     try {
       const conversations = await this.getPendingConversations();
       if (conversations.length > 0) {
@@ -1592,95 +1591,95 @@ var ChannelDriver = class {
         });
       }
       for (const conv of conversations) {
-        dispatched += await this.processConversation(conv);
+        processed += await this.processConversation(conv);
       }
     } finally {
       this.draining = false;
     }
-    return dispatched;
-  }
-  /**
-   * True while any per-session watcher has a non-empty in-flight dispatched set
-   * (Task 3.7). `run.ts` treats this as NON-idle so `--idle-timeout` cannot exit
-   * the process while a dispatched message is still queued/running — which would
-   * kill the turn and orphan its reply.
-   */
-  hasInFlightWatchers() {
-    for (const watcher of this.watchers.values()) {
-      if (watcher.inFlight.size > 0) return true;
-    }
-    return false;
+    return processed;
   }
   /**
-   * Await all outstanding per-session watchers (WI-3).
+   * Await all outstanding paused-session watchers (WI-2-CLI).
    *
-   * In production the watcher loops are deliberately started-not-awaited so the
-   * drain loop never blocks on them and process exit is not held up (the cron
-   * recovers any abandoned ones). This helper exists primarily for deterministic
-   * tests that need to observe a watcher's effect (the `processing`/`done` PATCH
-   * or its giving up) after a non-blocking `drainPending`. Watcher loops never
-   * reject, so this resolves.
+   * In production the watchers are deliberately started-not-awaited so the drain
+   * loop never blocks on them and process exit is not held up (the cron recovers
+   * any abandoned ones). This helper exists primarily for deterministic tests
+   * that need to observe the watcher's effect (the `done` PATCH or its giving up)
+   * after a non-blocking `drainPending`. Watchers never reject, so this resolves.
    */
   async flushPausedWatchers() {
-    while (true) {
-      const loops = [...this.watchers.values()].map((w) => w.loop).filter((l) => l != null);
-      if (loops.length === 0) return;
-      await Promise.all(loops);
-      const stillLive = [...this.watchers.values()].some((w) => w.loop != null);
-      if (!stillLive) return;
-    }
+    await Promise.all([...this.watchers.values()]);
   }
   // -------------------------------------------------------------------------
-  // Conversation processing (WI-3 — async dispatch)
+  // Conversation processing
   // -------------------------------------------------------------------------
-  /**
-   * Dispatch each pending message for a conversation to opencode's native queue
-   * via `prompt_async` (Task 3.2) and register it with the conversation's
-   * per-session watcher. Does NOT block on the turn and does NOT call
-   * `markProcessing` here — that fires from the watcher on running-start.
-   *
-   * @returns the count of messages NEWLY dispatched (not already in-flight).
-   */
   async processConversation(conv) {
     const sessionId = await this.ensureSession(conv);
     const messages = await this.getPendingMessages(conv.id);
-    let dispatched = 0;
+    let processed = 0;
     for (const message of messages) {
-      if (this.dispatched.has(message.id)) {
+      const claimed = await this.markProcessing(conv.id, message.id, sessionId);
+      if (!claimed) {
+        this.log({
+          level: "info",
+          message: `Message ${message.id.slice(0, 8)} already claimed \u2014 skipping`,
+          conversation_id: conv.id,
+          message_id: message.id
+        });
         continue;
       }
-      const opencodeMessageId = opencodeMessageIdFor(message.id);
-      const options = {
-        agent: message.opencode_agent ?? void 0,
-        model: message.opencode_model ?? void 0
-      };
       try {
         this.log({
           level: "info",
-          message: `Dispatching message ${message.id.slice(0, 8)} to OpenCode native queue (session ${sessionId.slice(0, 8)})`,
+          message: `Sending queued message ${message.id.slice(0, 8)} to OpenCode (session ${sessionId.slice(0, 8)})`,
+          conversation_id: conv.id,
+          message_id: message.id
+        });
+        const result = await sendMessageToOpenCode(
+          this.port,
+          sessionId,
+          message.content,
+          {
+            agent: message.opencode_agent ?? void 0,
+            model: message.opencode_model ?? void 0
+          },
+          {
+            onQuestion: (question) => this.reportInteraction(conv.id, "question", question),
+            onPermission: (permission) => this.reportInteraction(conv.id, "permission", permission)
+          }
+        );
+        if (result.awaitingInteraction) {
+          this.log({
+            level: "info",
+            message: `Message ${message.id.slice(0, 8)} paused awaiting interaction \u2014 watching session for completion`,
+            conversation_id: conv.id,
+            message_id: message.id
+          });
+          this.startPausedWatcher(conv, message, sessionId);
+          continue;
+        }
+        await this.confirmCompletion(sessionId);
+        await this.markDone(conv.id, message.id, sessionId);
+        processed += 1;
+        this.log({
+          level: "info",
+          message: `Message ${message.id.slice(0, 8)} processed`,
           conversation_id: conv.id,
           message_id: message.id
         });
-        await sendPromptAsync(this.port, sessionId, message.content, options, opencodeMessageId);
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
-        this.dispatched.delete(message.id);
         await this.markFailed(conv.id, message.id).catch(() => {
         });
         this.log({
           level: "error",
-          message: `Message ${message.id.slice(0, 8)} dispatch failed: ${err instanceof Error ? err.message : String(err)}`,
+          message: `Message ${message.id.slice(0, 8)} failed: ${err instanceof Error ? err.message : String(err)}`,
           conversation_id: conv.id,
           message_id: message.id
         });
-        continue;
       }
-      this.dispatched.add(message.id);
-      this.registerInFlight(conv, sessionId, message, opencodeMessageId);
-      dispatched += 1;
     }
-    this.ensureWatcherRunning(sessionId);
-    return dispatched;
+    return processed;
   }
   async ensureSession(conv) {
     const cached = this.sessions.get(conv.id);
@@ -1712,349 +1711,111 @@ var ChannelDriver = class {
     }
     return this.opencodeDirectory;
   }
+  /**
+   * Local reconcile: re-query `GET /session/:id/message` and check whether the
+   * last assistant message is message-level complete (`isTurnComplete`).
+   *
+   * This is a PURE OBSERVABILITY probe on the normal (non-paused) path: the
+   * blocking POST already returned, and `markDone` causes the server to re-fetch
+   * the messages itself (via `extractTextFromMessages`) when delivering the
+   * reply — so this round-trip never gates delivery. We keep it only to surface a
+   * truthful diagnostic when opencode hasn't yet recorded a completed assistant
+   * turn at reconcile time, then proceed to `markDone` regardless. Uses the
+   * injected `fetchImpl` and reuses only the pure `isTurnComplete` predicate.
+   */
+  async confirmCompletion(sessionId) {
+    try {
+      const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
+      if (!res.ok) return;
+      const body = await res.json();
+      const messages = Array.isArray(body) ? body : null;
+      if (!isTurnComplete(messages)) {
+        this.log({
+          level: "info",
+          message: `Session ${sessionId.slice(0, 8)} messages do not yet show a completed assistant turn on reconcile \u2014 delivering anyway`
+        });
+      }
+    } catch {
+    }
+  }
   // -------------------------------------------------------------------------
-  // Per-session watcher (WI-3)
+  // Paused-session watcher (WI-2-CLI)
   // -------------------------------------------------------------------------
-  /** Register a freshly-dispatched message with its session's watcher state. */
-  registerInFlight(conv, sessionId, message, opencodeMessageId) {
-    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);
-    }
-    const now = this.now();
-    watcher.inFlight.set(message.id, {
-      evidentMessageId: message.id,
-      opencodeMessageId,
-      message,
-      dispatchedAt: now,
-      deadline: now + this.pausedMaxWaitMs,
-      started: false,
-      done: false
-    });
-  }
   /**
-   * Start (but do NOT await) the per-session watcher loop if it has in-flight
-   * work and is not already running. Single-flight per session. The loop is
-   * 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.
+   * Start (but do NOT await) a watcher that resumes a paused turn to completion.
+   *
+   * Single-flight per message: if a watcher is already live for this message we
+   * skip. The returned watcher promise is tracked in `this.watchers` and removed
+   * when it settles; it never rejects (the body is fully guarded), so a failed
+   * poll/markDone can never crash the run loop — the cron stays as the safety net.
    */
-  ensureWatcherRunning(sessionId) {
-    const watcher = this.watchers.get(sessionId);
-    if (!watcher) return;
-    if (watcher.loop) return;
-    if (watcher.inFlight.size === 0) {
-      this.watchers.delete(sessionId);
-      return;
-    }
-    const loop = this.runWatcherLoop(sessionId, watcher).finally(() => {
-      watcher.loop = null;
-      if (watcher.inFlight.size === 0) {
-        this.watchers.delete(sessionId);
-      }
+  startPausedWatcher(conv, message, sessionId) {
+    if (this.watchers.has(message.id)) return;
+    const watcher = this.watchPausedSession(conv, message, sessionId).finally(() => {
+      this.watchers.delete(message.id);
     });
-    watcher.loop = loop;
+    this.watchers.set(message.id, watcher);
   }
   /**
-   * The per-session polling loop (WI-3). Once per tick it:
-   *   1. polls `GET /session/:id/message` once and, per in-flight message,
-   *      computes `messageRunState` and fires markProcessing (queued→running) /
-   *      markDone (done) exactly once per transition;
-   *   2. applies the idle-path re-dispatch guard (a dispatched message that never
-   *      APPEARS → re-dispatch — D1 obligation 2);
-   *   3. polls `/question` + `/permission` (scoped to the session) and surfaces
-   *      NEW ones via `reportInteraction`, carrying the PAUSED message's own
-   *      `source_message_id`;
-   *   4. drops messages that completed or timed out from the in-flight set.
-   * Exits when the in-flight set empties. Never throws.
+   * Poll `GET /session/:id/message` until the SAME paused turn is message-level
+   * complete — the last message is an ASSISTANT message whose
+   * `info.time.completed` is set (the user answered the question/permission in
+   * opencode web and opencode finished the turn) — then complete it via the
+   * EXISTING `markDone` PATCH — NO re-send of the original message. The server
+   * re-fetches the assistant messages on completion, so the watcher does not
+   * pass any reply text.
+   *
+   * Fetch seam: the poll uses the injected `this.fetchImpl` (preserving the
+   * tests' injection) and reuses only the pure `isTurnComplete` predicate from
+   * `session.ts` — we do NOT call `getSessionMessages` (which uses the global
+   * `fetch`) here.
+   *
+   * Bounded by `pausedMaxWaitMs` (default 10 min, strictly < the 15-min cron
+   * reset): on timeout we STOP and leave the message `processing` so the cron
+   * remains the last-resort safety net. The whole body is wrapped so any
+   * poll/markDone failure is logged and swallowed — a watcher MUST NEVER throw
+   * out of the run loop.
    */
-  async runWatcherLoop(sessionId, watcher) {
+  async watchPausedSession(conv, message, sessionId) {
+    const deadline = Date.now() + this.pausedMaxWaitMs;
     try {
-      while (watcher.inFlight.size > 0) {
+      while (Date.now() < deadline) {
         await this.sleep(this.pausedPollIntervalMs);
-        let messages = null;
+        let completed = false;
         try {
           const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
           if (res.ok) {
             const body = await res.json();
-            messages = Array.isArray(body) ? body : null;
+            const messages = Array.isArray(body) ? body : null;
+            completed = isTurnComplete(messages);
           }
         } catch {
           continue;
         }
-        for (const inFlight of [...watcher.inFlight.values()]) {
-          await this.serviceInFlightMessage(sessionId, watcher, inFlight, messages);
-        }
-        await this.pollInteractions(sessionId, watcher, messages);
-      }
-    } catch (err) {
-      if (err instanceof ChannelAuthError) {
-        this.log({
-          level: "error",
-          message: `Session watcher aborted on auth failure for session ${sessionId.slice(0, 8)} \u2014 clearing in-flight state for re-drive after re-auth: ${err.message}`,
-          conversation_id: watcher.conv.id
-        });
-        for (const evidentMessageId of [...watcher.inFlight.keys()]) {
-          this.removeInFlight(watcher, evidentMessageId);
-        }
-        return;
-      }
-      this.log({
-        level: "error",
-        message: `Session watcher failed for session ${sessionId.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`,
-        conversation_id: watcher.conv.id
-      });
-    }
-  }
-  /**
-   * Drive ONE in-flight message's lifecycle from the tick's message snapshot.
-   * Fires markProcessing on queued→running and markDone on done (each once),
-   * applies the idle-path re-dispatch guard, and removes the message from the
-   * in-flight set on completion or timeout.
-   */
-  async serviceInFlightMessage(sessionId, watcher, inFlight, messages) {
-    const conv = watcher.conv;
-    const state = messageRunState(messages, inFlight.opencodeMessageId);
-    if ((state === "running" || state === "done") && !inFlight.started) {
-      let claimed;
-      try {
-        claimed = await this.markProcessing(conv.id, inFlight.evidentMessageId, sessionId);
-      } catch (err) {
-        if (err instanceof ChannelAuthError) throw err;
-        this.log({
-          level: "error",
-          message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} processing (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
-          conversation_id: conv.id,
-          message_id: inFlight.evidentMessageId
-        });
-        return;
-      }
-      inFlight.started = true;
-      if (!claimed) {
-        this.log({
-          level: "info",
-          message: `Message ${inFlight.evidentMessageId.slice(0, 8)} already marked processing \u2014 continuing`,
-          conversation_id: conv.id,
-          message_id: inFlight.evidentMessageId
-        });
-      }
-    }
-    if (state === "done") {
-      if (!inFlight.done) {
+        if (!completed) continue;
         this.log({
           level: "info",
-          message: `Message ${inFlight.evidentMessageId.slice(0, 8)} completed \u2014 marking done`,
+          message: `Paused session ${sessionId.slice(0, 8)} completed \u2014 marking message ${message.id.slice(0, 8)} done`,
           conversation_id: conv.id,
-          message_id: inFlight.evidentMessageId
+          message_id: message.id
         });
-        try {
-          await this.markDone(conv.id, inFlight.evidentMessageId, sessionId);
-        } catch (err) {
-          if (err instanceof ChannelAuthError) throw err;
-          if (err instanceof ChannelTerminalError) {
-            this.log({
-              level: "error",
-              message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 leaving for the cron safety net: ${err.message}`,
-              conversation_id: conv.id,
-              message_id: inFlight.evidentMessageId
-            });
-            this.removeInFlight(watcher, inFlight.evidentMessageId);
-            return;
-          }
-          if (this.now() >= inFlight.deadline) {
-            this.log({
-              level: "error",
-              message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done within the watch window \u2014 leaving for the cron safety net: ${err instanceof Error ? err.message : String(err)}`,
-              conversation_id: conv.id,
-              message_id: inFlight.evidentMessageId
-            });
-            this.removeInFlight(watcher, inFlight.evidentMessageId);
-            return;
-          }
-          this.log({
-            level: "error",
-            message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
-            conversation_id: conv.id,
-            message_id: inFlight.evidentMessageId
-          });
-          return;
-        }
-        inFlight.done = true;
-      }
-      this.removeInFlight(watcher, inFlight.evidentMessageId);
-      return;
-    }
-    if (state === "unknown") {
-      if (this.now() - inFlight.dispatchedAt >= this.dispatchConfirmMs) {
-        await this.redispatchInFlight(sessionId, inFlight);
+        await this.markDone(conv.id, message.id, sessionId);
+        return;
       }
-    }
-    if (this.now() >= inFlight.deadline) {
       this.log({
         level: "info",
-        message: `Message ${inFlight.evidentMessageId.slice(0, 8)} did not complete within the watch window \u2014 leaving for the cron safety net`,
+        message: `Paused session ${sessionId.slice(0, 8)} did not complete within the watch window \u2014 leaving message ${message.id.slice(0, 8)} for the cron safety net`,
         conversation_id: conv.id,
-        message_id: inFlight.evidentMessageId
+        message_id: message.id
       });
-      this.removeInFlight(watcher, inFlight.evidentMessageId);
-    }
-  }
-  /**
-   * Re-dispatch a message whose user row never appeared (idle-path guard). Safe:
-   * opencode treats a duplicate caller-supplied `messageID` as idempotent (PoC
-   * fact 9) — one user message + one reply even if the original DID land. Resets
-   * the dispatch timestamp so the guard doesn't immediately fire again.
-   */
-  async redispatchInFlight(sessionId, inFlight) {
-    const options = {
-      agent: inFlight.message.opencode_agent ?? void 0,
-      model: inFlight.message.opencode_model ?? void 0
-    };
-    this.log({
-      level: "info",
-      message: `Message ${inFlight.evidentMessageId.slice(0, 8)} not observed after dispatch \u2014 re-dispatching (idle-path guard)`,
-      message_id: inFlight.evidentMessageId
-    });
-    try {
-      await sendPromptAsync(
-        this.port,
-        sessionId,
-        inFlight.message.content,
-        options,
-        inFlight.opencodeMessageId
-      );
     } catch (err) {
       this.log({
         level: "error",
-        message: `Re-dispatch failed for message ${inFlight.evidentMessageId.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`,
-        message_id: inFlight.evidentMessageId
-      });
-    }
-    inFlight.dispatchedAt = this.now();
-  }
-  /**
-   * 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`.
-   */
-  removeInFlight(watcher, evidentMessageId) {
-    watcher.inFlight.delete(evidentMessageId);
-    this.dispatched.delete(evidentMessageId);
-  }
-  /**
-   * Poll `/question` + `/permission` (scoped to the session) and surface NEW ones
-   * via `reportInteraction` (Task 3.5), carrying the PAUSED message's own
-   * `source_message_id` so the server @mentions the correct person under
-   * concurrency. Dedups by interaction id across ticks (reused per-session sets).
-   *
-   * The interaction is attributed to the in-flight message it paused on. opencode
-   * stamps a `messageID` on a permission (and `tool.messageID` on a question) =
-   * the assistant message id, whose `parentID` is the user message id — but the
-   * simplest robust attribution here is: the single in-flight message that is
-   * RUNNING (not done) is the one that paused. With one running message that is
-   * unambiguous; with several we prefer an explicit messageID match, else the
-   * oldest running message.
-   */
-  async pollInteractions(sessionId, watcher, messages) {
-    let questions = [];
-    try {
-      const res = await this.fetchImpl(`${this.opencodeBase}/question`);
-      if (res.ok) {
-        const body = await res.json();
-        questions = Array.isArray(body) ? body : [];
-      }
-    } catch {
-    }
-    for (const q of questions) {
-      if (q.sessionID !== sessionId) continue;
-      if (watcher.reportedQuestions.has(q.id)) continue;
-      const paused = this.attributeInteraction(watcher, q.tool?.messageID, messages);
-      const reported = await this.reportInteraction(
-        watcher.conv.id,
-        "question",
-        q,
-        paused?.message.source_message_id ?? void 0
-      );
-      if (reported) watcher.reportedQuestions.add(q.id);
-    }
-    let permissions = [];
-    try {
-      const res = await this.fetchImpl(`${this.opencodeBase}/permission`);
-      if (res.ok) {
-        const body = await res.json();
-        permissions = Array.isArray(body) ? body : [];
-      }
-    } catch {
-    }
-    for (const p of permissions) {
-      if (p.sessionID !== sessionId) continue;
-      if (watcher.reportedPermissions.has(p.id)) continue;
-      const paused = this.attributeInteraction(watcher, p.messageID, messages);
-      const reported = await this.reportInteraction(
-        watcher.conv.id,
-        "permission",
-        p,
-        paused?.message.source_message_id ?? void 0
-      );
-      if (reported) watcher.reportedPermissions.add(p.id);
-    }
-  }
-  /**
-   * Attribute a surfaced interaction to the in-flight message it paused on (M-1).
-   *
-   * The interaction carries `interactionMessageId` — the ASSISTANT message id
-   * that raised it (a question's `tool.messageID` / a permission's `messageID`).
-   * That assistant message is the reply to ONE of our minted user messages
-   * (correlated by `parentID`, GATE-B). So when we have the tick's message
-   * snapshot, we resolve each running in-flight message's correlated assistant
-   * reply (`findAssistantReplyAfter`) and match its id against
-   * `interactionMessageId` — giving an EXACT attribution even with several
-   * messages in flight concurrently in one session.
-   *
-   * We fall back to the oldest running message ONLY when no exact match is
-   * possible (the id is absent, the snapshot is missing, or the reply has not yet
-   * been correlated). With a single running message either path is exact. Never
-   * throws.
-   *
-   * Attribution must NOT depend on our own `started` PATCH flag: opencode can
-   * START a turn AND raise a question/permission BEFORE our next tick fires
-   * `markProcessing` (which sets `started`). Relying on `started` would leave the
-   * running set empty in that window and let the server fall back to "newest
-   * processing/pending" — possibly @mentioning a FOLLOW-UP author rather than the
-   * person whose active turn actually paused. So we derive "running" from the
-   * tick's `messages` snapshot via `messageRunState` instead.
-   */
-  attributeInteraction(watcher, interactionMessageId, messages) {
-    const inFlight = [...watcher.inFlight.values()].filter((m) => !m.done);
-    if (inFlight.length === 0) return void 0;
-    if (interactionMessageId && messages) {
-      const exact = inFlight.find((m) => {
-        const reply = findAssistantReplyAfter(messages, m.opencodeMessageId);
-        return reply != null && messageIdOf(reply) === interactionMessageId;
+        message: `Paused-session watcher failed for message ${message.id.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: conv.id,
+        message_id: message.id
       });
-      if (exact) return exact;
-    }
-    const byOldest = (a, b) => a.dispatchedAt - b.dispatchedAt;
-    if (messages) {
-      const runningPerSnapshot = inFlight.filter(
-        (m) => messageRunState(messages, m.opencodeMessageId) === "running"
-      );
-      if (runningPerSnapshot.length > 0) {
-        return runningPerSnapshot.sort(byOldest)[0];
-      }
     }
-    const startedRunning = inFlight.filter((m) => m.started);
-    if (startedRunning.length > 0) {
-      return startedRunning.sort(byOldest)[0];
-    }
-    return inFlight.sort(byOldest)[0];
   }
   // -------------------------------------------------------------------------
   // Evident API calls (combinedAuth thread routes)
@@ -2088,86 +1849,39 @@ var ChannelDriver = class {
     }
     return await res.json();
   }
-  /**
-   * EXISTING combinedAuth route — now fired by the watcher on queued→running
-   * (Task 3.3), NOT at dispatch/claim time. `{status:'processing',
-   * opencode_session_id}` → `notifyMessageStarted` (hourglass→runner swap +
-   * deep-linked "View in Evident" notice).
-   *
-   * Return/throw contract (consumed by the watcher's swap-to-running guard):
-   *   - returns `true`  → the server transitioned the row to processing;
-   *   - returns `false` → the server gave a DEFINITIVE "already-processing"
-   *                       answer (a non-retryable, non-auth status — e.g. a
-   *                       conflict because a duplicate already transitioned it),
-   *                       so the caller treats it as already-started and does NOT
-   *                       retry;
-   *   - throws `ChannelAuthError` on 401/403 (terminal auth failure);
-   *   - throws on a TRANSIENT failure (retryable 5xx/429 status, or a
-   *     network-level error from `fetch`) — i.e. NO definitive server response —
-   *     so the caller leaves the message un-started and retries the swap on the
-   *     next tick.
-   * A single attempt (no internal retry): the watcher's per-tick loop is the
-   * retry vehicle for the swap-to-running.
-   */
   async markProcessing(conversationId, messageId, sessionId) {
     const res = await this.fetchImpl(
       `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
       {
         method: "PATCH",
         headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
+        // Include the opencode session id so the server can deep-link the
+        // "View in Evident" notice straight to the conversation (the session
+        // already exists by now — ensureSession runs before claiming).
         body: JSON.stringify({ status: "processing", opencode_session_id: sessionId })
       }
     );
     this.assertAuth(res, "marking message as processing");
-    if (res.ok) return true;
-    if (isRetryableStatus(res.status)) {
-      throw new Error(`marking message as processing: HTTP ${res.status}`);
-    }
-    return false;
+    return res.ok;
   }
   /**
-   * EXISTING combinedAuth completion route — idempotent (WI-CHAN-2). `PATCH
-   * .../messages/:id {status:'done', opencode_session_id}`. The server's
+   * EXISTING combinedAuth completion route — idempotent + retried (WI-CHAN-2).
+   * `PATCH .../messages/:id {status:'done', opencode_session_id}`. The server's
    * `queued_conversation_messages.status`/`processed_at` gate makes a re-call
-   * for an already-`done` message a no-op (no double Slack post). Fired by the
-   * watcher on per-message completion (Task 3.4) — no `confirmCompletion`
-   * round-trip (we already observed completion via the message list).
-   *
-   * SINGLE ATTEMPT (no in-call `callWithRetry` backoff). The per-session watcher
-   * services its in-flight messages SEQUENTIALLY within a tick
-   * (`runWatcherLoop` → `serviceInFlightMessage`), so a long multi-attempt
-   * backoff here would BLOCK sibling messages in the SAME session/tick: while
-   * message A's done PATCH burned its internal retries, message B could not be
-   * swapped to running even though opencode had already started it. Instead this
-   * does ONE PATCH and surfaces the SAME outcome contract the watcher's markDone
-   * handler already relies on, leaning on the per-tick retry across ticks
-   * (bounded by `inFlight.deadline`) rather than an in-call retry:
-   *   - resolves (`void`)            → the server transitioned the row to done
-   *                                    (or idempotently confirmed already-done);
-   *   - throws `ChannelAuthError`    → 401/403 (terminal auth failure → loop
-   *                                    cleanup, Finding 1);
-   *   - throws `ChannelTerminalError`→ non-retryable, non-auth 4xx (will never
-   *                                    succeed → straight to the cron, Finding 4);
-   *   - throws a plain `Error`       → TRANSIENT 5xx/429 or a network-level error
-   *                                    (no definitive server response → the
-   *                                    watcher retries next tick within the
-   *                                    deadline, Finding 4).
+   * for an already-`done` message a no-op (no double Slack post).
    */
   async markDone(conversationId, messageId, sessionId) {
-    const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
-      {
-        method: "PATCH",
-        headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
-        body: JSON.stringify({ status: "done", opencode_session_id: sessionId })
-      }
+    await this.callWithRetry(
+      "marking message as done",
+      () => this.fetchImpl(
+        `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
+        {
+          method: "PATCH",
+          headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
+          body: JSON.stringify({ status: "done", opencode_session_id: sessionId })
+        }
+      )
     );
-    this.assertAuth(res, "marking message as done");
-    if (res.ok) return;
-    if (isRetryableStatus(res.status)) {
-      throw new Error(`marking message as done: HTTP ${res.status}`);
-    }
-    throw new ChannelTerminalError(`marking message as done: HTTP ${res.status}`, res.status);
   }
   async markFailed(conversationId, messageId) {
     await this.callWithRetry(
@@ -2195,17 +1909,10 @@ var ChannelDriver = class {
   }
   /**
    * EXISTING combinedAuth interaction route (WI-CHAN-3) — idempotent + retried.
-   * `POST .../interactive-event {type, data, source_message_id?}`. The server
-   * persists the interaction and posts a link to the proxied opencode-web
-   * conversation, @mentioning the user who triggered THIS message's turn.
-   *
-   * WI-3 / WI-4 contract: `source_message_id` is the PAUSED message's own Slack
-   * ts (`message.source_message_id`). The server resolves the @mention from that
-   * message's user FIRST (falling back to the old "newest processing" precedence
-   * only when absent), so the correct person is mentioned under concurrency. It
-   * is OPTIONAL for back-compat with older clients / legacy rows.
+   * `POST .../interactive-event {type, data}`. The server persists the
+   * interaction and posts a link to the proxied opencode-web conversation.
    */
-  async reportInteraction(conversationId, type, data, sourceMessageId) {
+  async reportInteraction(conversationId, type, data) {
     try {
       await this.callWithRetry(
         "reporting interactive event",
@@ -2214,9 +1921,7 @@ var ChannelDriver = class {
           {
             method: "POST",
             headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
-            body: JSON.stringify(
-              sourceMessageId ? { type, data, source_message_id: sourceMessageId } : { type, data }
-            )
+            body: JSON.stringify({ type, data })
           }
         )
       );
@@ -2225,7 +1930,6 @@ var ChannelDriver = class {
         message: `${type} surfaced to channel (id: ${data.id.slice(0, 8)})`,
         conversation_id: conversationId
       });
-      return true;
     } catch (err) {
       if (err instanceof ChannelAuthError) throw err;
       this.log({
@@ -2233,7 +1937,6 @@ var ChannelDriver = class {
         message: `Failed to surface ${type}: ${err instanceof Error ? err.message : String(err)}`,
         conversation_id: conversationId
       });
-      return false;
     }
   }
   // -------------------------------------------------------------------------
@@ -2272,9 +1975,8 @@ var ChannelDriver = class {
           await this.sleep(backoffDelay(attempt, this.retry));
           continue;
         }
-        break;
       }
-      throw new ChannelTerminalError(`${context}: HTTP ${res.status}`, res.status);
+      throw new Error(`${context}: HTTP ${res.status}`);
     }
     throw lastError instanceof Error ? lastError : new Error(`${context}: exhausted retries`);
   }
@@ -2619,9 +2321,9 @@ async function driveChannels(state, driver) {
     try {
       const processed = await driver.drainPending();
       state.messageCount += processed;
-      if (processed > 0 || driver.hasInFlightWatchers()) {
+      if (processed > 0) {
         idlePolls = 0;
-        if (processed > 0 && state.interactive) displayStatus(state);
+        if (state.interactive) displayStatus(state);
       } else if (state.idleTimeout !== null) {
         idlePolls++;
         if (idlePolls === 1) {
@@ -2812,13 +2514,6 @@ async function run(options) {
       state.opencodeConnected = oc.process !== null || oc.version !== null;
       const version = state.opencodeVersion ? ` (v${state.opencodeVersion})` : "";
       ocSpinner?.succeed(`OpenCode running on port ${state.port}${version}`);
-      const versionWarning = buildOpenCodeVersionWarning(state.opencodeVersion);
-      if (versionWarning) {
-        log(state, versionWarning, false);
-        if (state.interactive && !state.json) {
-          logActivity(state, { type: "info", message: versionWarning });
-        }
-      }
     } catch (error2) {
       ocSpinner?.fail(error2.message);
       throw error2;