@evident-ai/cli 3.0.1-dev.ec55c96 → 3.0.1-dev.edba747

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/commands/login.ts
@@ -470,6 +471,12 @@ import chalk6 from "chalk";
 import ora3 from "ora";
 import { select as select3 } from "@inquirer/prompts";
 
+// ../../packages/types/src/opencode/index.ts
+function opencodeMessageIdFor(queuedMessageId) {
+  const sanitized = queuedMessageId.replace(/[^a-zA-Z0-9]/g, "_");
+  return `msg_${sanitized}`;
+}
+
 // ../../packages/types/src/telemetry/index.ts
 var TelemetryEventTypes = {
   // Agent activity events (shown in web UI activity log)
@@ -484,8 +491,34 @@ var TelemetryEventTypes = {
 var MAX_FRAME_BYTES = 256 * 1024;
 var TUNNEL_DRAIN_PING_PATH = "/__evident/drain";
 
+// ../../packages/types/src/logging/index.ts
+var CORRELATION_ID_HEADER = "x-evident-correlation-id";
+function log(level, event, fields) {
+  const method = level === "debug" ? "log" : level;
+  try {
+    console[method]("[evident]", JSON.stringify({ level, event, ...fields }));
+  } catch (err) {
+    console.error(
+      "[evident] log_serialize_failed",
+      event,
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+function stripQuery(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    const q = url.indexOf("?");
+    return q === -1 ? url : url.slice(0, q);
+  }
+}
+
 // src/lib/telemetry.ts
-var CLI_VERSION = process.env.npm_package_version || "unknown";
+var CLI_VERSION = (true ? "3.0.0" : void 0) ?? process.env.npm_package_version ?? "unknown";
+function getCliVersion() {
+  return CLI_VERSION;
+}
 var eventBuffer = [];
 var flushTimeout = null;
 var isShuttingDown = false;
@@ -684,6 +717,19 @@ 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(version2) {
+  if (!version2) return false;
+  return QUEUE_VALIDATED_OPENCODE_VERSIONS.includes(version2);
+}
+function buildOpenCodeVersionWarning(version2) {
+  if (isQueueValidatedVersion(version2)) return null;
+  const detected = version2 ? `v${version2}` : "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];
@@ -996,23 +1042,37 @@ function roleOf(m) {
 }
 function completedOf(m) {
   if (!m || typeof m !== "object") return void 0;
-  return m.info?.time?.completed;
+  return m.info?.time?.completed ?? m.time?.completed;
 }
-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 createdOf(m) {
+  if (!m || typeof m !== "object") return void 0;
+  return m.info?.time?.created ?? m.time?.created;
 }
-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;
+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;
+}
+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 finishOf(m) {
+  if (!m || typeof m !== "object") return void 0;
+  if (typeof m.finish === "string") return m.finish;
+  const infoFinish = m.info?.finish;
+  return typeof infoFinish === "string" ? infoFinish : void 0;
+}
+function errorOf(m) {
+  if (!m || typeof m !== "object") return void 0;
+  return m.info?.error ?? m.error;
+}
+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`);
@@ -1031,8 +1091,9 @@ async function createOpenCodeSession(port, directory) {
   const data = await response.json();
   return data.id;
 }
-async function sendMessageToOpenCode(port, sessionId, content, options, hooks, maxWaitMs = 10 * 60 * 1e3) {
+async function sendPromptAsync(port, sessionId, content, options, messageId) {
   const body = {
+    messageID: messageId,
     parts: [{ type: "text", text: content }]
   };
   if (options?.agent) {
@@ -1047,79 +1108,111 @@ async function sendMessageToOpenCode(port, sessionId, content, options, hooks, m
       };
     }
   }
-  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 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 findLastAssistantReplyFor(messages, userMessageId) {
+  if (!messages || messages.length === 0) return null;
+  let lastCorrelated = null;
+  let lastNonErrored = null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (roleOf(m) !== "assistant" || parentIdOf(m) !== userMessageId) continue;
+    if (lastCorrelated === null) lastCorrelated = m;
+    if (errorOf(m) == null) {
+      lastNonErrored = m;
+      break;
+    }
+  }
+  if (lastCorrelated) return lastNonErrored ?? lastCorrelated;
+  const userIndex = messages.findIndex((m) => idOf(m) === userMessageId);
+  if (userIndex === -1) return null;
+  let last = null;
+  let lastOk = null;
+  for (let i = userIndex + 1; i < messages.length; i++) {
+    const role = roleOf(messages[i]);
+    if (role === "user") break;
+    if (role === "assistant") {
+      last = messages[i];
+      if (errorOf(messages[i]) == null) lastOk = messages[i];
+    }
+  }
+  return lastOk ?? last;
+}
+function messageRunState(messages, userMessageId) {
+  if (!messages || messages.length === 0) return "unknown";
+  const hasUser = messages.some((m) => idOf(m) === userMessageId);
+  const reply = findLastAssistantReplyFor(messages, userMessageId);
+  if (!hasUser) {
+    if (!reply) return "unknown";
+  }
+  if (!reply) return "queued";
+  if (isAssistantInFlight(reply)) return "running";
+  return errorOf(reply) != null ? "failed" : "done";
+}
+function messageError(messages, userMessageId) {
+  const reply = findLastAssistantReplyFor(messages, userMessageId);
+  const error2 = errorOf(reply);
+  if (error2 == null) return null;
+  if (typeof error2 === "string") return error2;
+  if (typeof error2 === "object") {
+    const e = error2;
+    const dataMessage = e.data?.message;
+    if (typeof dataMessage === "string") return dataMessage;
+    if (typeof e.message === "string") return e.message;
+  }
+  return "The agent run failed.";
+}
+function hasRunningAssistantExcept(messages, exceptUserMessageId) {
+  if (!messages || messages.length === 0) return false;
+  return messages.some(
+    (m) => roleOf(m) === "assistant" && parentIdOf(m) !== exceptUserMessageId && isAssistantInFlight(m)
+  );
+}
+function isSessionSettled(messages, now, settleMs) {
+  if (!messages || messages.length === 0) return true;
+  let newestAssistantCreated = null;
+  for (const m of messages) {
+    if (roleOf(m) !== "assistant") continue;
+    if (isAssistantInFlight(m)) return false;
+    const created = createdOf(m);
+    if (typeof created === "number" && (newestAssistantCreated === null || created > newestAssistantCreated)) {
+      newestAssistantCreated = created;
     }
-  };
-  const [result] = await Promise.all([sendMessage(), pollInteractive()]);
-  return result;
+  }
+  if (newestAssistantCreated === null) return true;
+  return now - newestAssistantCreated >= settleMs;
+}
+function opencodeMessageIdFor2(queuedMessageId) {
+  return opencodeMessageIdFor(queuedMessageId);
+}
+var NATIVE_ID_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function nativeOpencodeMessageId() {
+  let id = "msg_";
+  for (let i = 0; i < 24; i++) {
+    id += NATIVE_ID_ALPHABET[Math.floor(Math.random() * NATIVE_ID_ALPHABET.length)];
+  }
+  return id;
 }
 
 // src/lib/tunnel/connection.ts
@@ -1190,12 +1283,20 @@ var StreamForwarder = class {
   }
   async handleOpen(frame) {
     const { sid, method, path, headers, has_body } = frame;
+    const correlationId = headers?.[CORRELATION_ID_HEADER];
+    const startedAt = Date.now();
     if (path === TUNNEL_DRAIN_PING_PATH) {
       this.callbacks.onDrainPing?.();
       this.send({ type: "head", sid, status: 204, headers: {} });
       this.send({ type: "res_end", sid });
       return;
     }
+    log("info", "agent_request", {
+      correlation_id: correlationId,
+      sid,
+      method,
+      path: stripQuery(path)
+    });
     const ac = new AbortController();
     let bodyPromise;
     let pushBody;
@@ -1242,6 +1343,12 @@ var StreamForwarder = class {
       if (!STRIP_RES.has(key.toLowerCase())) resHeaders[key] = value;
     });
     this.send({ type: "head", sid, status: upstream.status, headers: resHeaders });
+    log("info", "agent_response", {
+      correlation_id: correlationId,
+      sid,
+      status: upstream.status,
+      duration_ms: Date.now() - startedAt
+    });
     this.callbacks.onHead?.(sid, upstream.status);
     try {
       if (upstream.body) {
@@ -1498,6 +1605,12 @@ 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,
@@ -1505,12 +1618,24 @@ 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 DEFAULT_STUCK_QUEUED_REDRIVE_MAX = 3;
+var DEFAULT_SETTLE_MS = 3500;
 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);
@@ -1531,15 +1656,63 @@ var ChannelDriver = class {
   sleep;
   pausedPollIntervalMs;
   pausedMaxWaitMs;
+  dispatchConfirmMs;
+  stuckQueuedMs;
+  stuckQueuedRedriveMax;
+  settleMs;
+  now;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
   /**
-   * 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.
+   * 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.
    */
   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();
+  /**
+   * 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
@@ -1562,6 +1735,11 @@ 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.stuckQueuedMs = config2.stuckQueuedMs ?? DEFAULT_STUCK_QUEUED_MS;
+    this.stuckQueuedRedriveMax = config2.stuckQueuedRedriveMax ?? DEFAULT_STUCK_QUEUED_REDRIVE_MAX;
+    this.settleMs = config2.settleMs ?? DEFAULT_SETTLE_MS;
+    this.now = config2.now ?? (() => Date.now());
   }
   /** The IPv4-loopback base URL for the local `opencode serve`. */
   get opencodeBase() {
@@ -1571,16 +1749,16 @@ var ChannelDriver = class {
   // Public API
   // -------------------------------------------------------------------------
   /**
-   * Drain all pending channel conversations once: poll → process → callback.
+   * Drain all pending channel conversations once: poll → dispatch → register.
    * 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 processed.
+   * @returns the number of messages NEWLY dispatched to opencode's native queue.
    */
   async drainPending() {
     if (this.draining) return 0;
     this.draining = true;
-    let processed = 0;
+    let dispatched = 0;
     try {
       const conversations = await this.getPendingConversations();
       if (conversations.length > 0) {
@@ -1591,95 +1769,106 @@ var ChannelDriver = class {
         });
       }
       for (const conv of conversations) {
-        processed += await this.processConversation(conv);
+        dispatched += await this.processConversation(conv);
       }
+      await this.readoptProcessing();
     } finally {
       this.draining = false;
     }
-    return processed;
+    return dispatched;
   }
   /**
-   * Await all outstanding paused-session watchers (WI-2-CLI).
+   * 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;
+  }
+  /**
+   * Await all outstanding per-session watchers (WI-3).
    *
-   * 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.
+   * 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.
    */
   async flushPausedWatchers() {
-    await Promise.all([...this.watchers.values()]);
+    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;
+    }
   }
   // -------------------------------------------------------------------------
-  // Conversation processing
+  // Conversation processing (WI-3 — async dispatch)
   // -------------------------------------------------------------------------
+  /**
+   * 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 processed = 0;
+    let dispatched = 0;
+    let skippedAlreadyDispatched = 0;
     for (const message of messages) {
-      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
-        });
+      if (this.dispatched.has(message.id)) {
+        skippedAlreadyDispatched += 1;
         continue;
       }
+      const opencodeMessageId = opencodeMessageIdFor2(message.id);
+      const options = {
+        agent: message.opencode_agent ?? void 0,
+        model: message.opencode_model ?? void 0
+      };
       try {
         this.log({
           level: "info",
-          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`,
+          message: `Dispatching message ${message.id.slice(0, 8)} to OpenCode native queue (session ${sessionId.slice(0, 8)})`,
           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)} failed: ${err instanceof Error ? err.message : String(err)}`,
+          message: `Message ${message.id.slice(0, 8)} dispatch 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;
+      void this.postSignal(conv.id, message.id, "dispatched");
     }
-    return processed;
+    if (messages.length > 0 && dispatched === 0 && skippedAlreadyDispatched === messages.length) {
+      this.log({
+        level: "error",
+        message: `Conversation ${conv.id.slice(0, 8)} has ${messages.length} pending message(s) but ALL are already marked dispatched locally (in-flight set: ${this.dispatched.size}) \u2014 none sent to OpenCode this tick. If this repeats, a message may be stuck acknowledged-but-never-dispatched (its watcher never settled).`,
+        conversation_id: conv.id
+      });
+    }
+    this.ensureWatcherRunning(sessionId);
+    return dispatched;
   }
   async ensureSession(conv) {
     const cached = this.sessions.get(conv.id);
@@ -1711,111 +1900,974 @@ var ChannelDriver = class {
     }
     return this.opencodeDirectory;
   }
+  // -------------------------------------------------------------------------
+  // Per-session watcher (WI-3)
+  // -------------------------------------------------------------------------
+  /** 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,
+      stuckReported: false,
+      redriveAttempts: 0,
+      lastRedriveAt: null,
+      redriveOpencodeMessageId: null,
+      attemptedOpencodeMessageIds: [opencodeMessageId]
+    });
+  }
   /**
-   * Local reconcile: re-query `GET /session/:id/message` and check whether the
-   * last assistant message is message-level complete (`isTurnComplete`).
+   * 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).
    *
-   * 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.
+   * `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, redriveOpencodeMessageId = null) {
+    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). A re-adopted `queued` wedge is ALSO
+      // re-driven by the same path (ADR-0046 §c deferred the live-session redrive
+      // to here) — `redriveAttempts` starts fresh so it gets the full budget.
+      stuckReported: false,
+      redriveAttempts: 0,
+      lastRedriveAt: null,
+      redriveOpencodeMessageId,
+      attemptedOpencodeMessageIds: [opencodeMessageId]
+    });
+  }
+  /**
+   * 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.
+   */
+  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);
+      }
+    });
+    watcher.loop = loop;
+  }
+  /**
+   * 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.
    */
-  async confirmCompletion(sessionId) {
+  async runWatcherLoop(sessionId, watcher) {
     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)) {
+      while (watcher.inFlight.size > 0) {
+        await this.sleep(this.pausedPollIntervalMs);
+        let messages = null;
+        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;
+          }
+        } 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.readopted.delete(evidentMessageId);
+          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" || state === "failed") && !inFlight.started) {
+      let claimed;
+      try {
+        claimed = await this.markProcessing(
+          conv.id,
+          inFlight.evidentMessageId,
+          sessionId,
+          inFlight.redriveOpencodeMessageId
+        );
+      } 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: `Session ${sessionId.slice(0, 8)} messages do not yet show a completed assistant turn on reconcile \u2014 delivering anyway`
+          message: `Message ${inFlight.evidentMessageId.slice(0, 8)} already marked processing \u2014 continuing`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
         });
       }
-    } catch {
+    }
+    if (state === "done") {
+      if (!inFlight.done) {
+        this.log({
+          level: "info",
+          message: `Message ${inFlight.evidentMessageId.slice(0, 8)} completed \u2014 marking done`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        try {
+          await this.markDone(
+            conv.id,
+            inFlight.evidentMessageId,
+            sessionId,
+            inFlight.redriveOpencodeMessageId
+          );
+        } 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 === "failed") {
+      if (!inFlight.done) {
+        const error2 = messageError(messages, inFlight.opencodeMessageId) ?? void 0;
+        this.log({
+          level: "error",
+          message: `Message ${inFlight.evidentMessageId.slice(0, 8)} errored \u2014 marking failed: ${error2 ?? "(no error text)"}`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        try {
+          await this.markFailed(conv.id, inFlight.evidentMessageId, sessionId, error2);
+        } 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)} failed (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)} failed 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)} failed (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(conv.id, sessionId, inFlight);
+      }
+    }
+    const pastStuckBound = this.now() - inFlight.dispatchedAt >= this.stuckQueuedMs;
+    const sessionIdle = state === "queued" && !hasRunningAssistantExcept(messages, inFlight.opencodeMessageId);
+    if (state === "queued" && pastStuckBound && sessionIdle) {
+      if (!inFlight.stuckReported) {
+        inFlight.stuckReported = true;
+        void this.postSignal(conv.id, inFlight.evidentMessageId, "stuck_queued", {
+          stuck_for_ms: this.now() - inFlight.dispatchedAt
+        });
+      }
+      const dueForRedrive = inFlight.lastRedriveAt == null || this.now() - inFlight.lastRedriveAt >= this.stuckQueuedMs;
+      if (dueForRedrive && isSessionSettled(messages, this.now(), this.settleMs)) {
+        const removed = await this.redriveStuckQueued(sessionId, watcher, inFlight, messages);
+        if (removed) 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`,
+        conversation_id: conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      void this.postSignal(conv.id, inFlight.evidentMessageId, "gave_up", {
+        watched_for_ms: this.now() - inFlight.dispatchedAt
+      });
+      this.removeInFlight(watcher, inFlight.evidentMessageId);
     }
   }
-  // -------------------------------------------------------------------------
-  // Paused-session watcher (WI-2-CLI)
-  // -------------------------------------------------------------------------
   /**
-   * 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.
+   * 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.
    */
-  startPausedWatcher(conv, message, sessionId) {
-    if (this.watchers.has(message.id)) return;
-    const watcher = this.watchPausedSession(conv, message, sessionId).finally(() => {
-      this.watchers.delete(message.id);
+  async redispatchInFlight(conversationId, 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
     });
-    this.watchers.set(message.id, watcher);
+    void this.postSignal(conversationId, inFlight.evidentMessageId, "redispatched");
+    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();
   }
   /**
-   * 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.
+   * RE-DRIVE a stuck-`queued` follow-up so opencode actually runs it
+   * (queued-followup-redrive; the fix for the 2026-07-18 dev incident).
+   *
+   * The wedge: a follow-up `prompt_async`'d mid-turn / in the post-turn settling
+   * window is orphaned — its user message persists but the turn never runs
+   * (`messageRunState === 'queued'`). Proven against real opencode 1.18.3 by an
+   * isolated, interleaved experiment (`.harness/followup-send-mechanism-finding.md`):
+   * the un-sticking variable is the `messageID` FORMAT. A follow-up carrying the
+   * runner's CUSTOM underscore id (`msg_<sanitized-uuid>`) is NEVER picked up mid-
+   * turn (0/24 trials); the SAME follow-up carrying a NATIVE-format id
+   * (`msg_`+24 base62) runs once the prior turn settles (~50% locally, reliably on
+   * dev). `parts[].id` and `agent`/`model` were proven IRRELEVANT.
+   *
+   * So we re-`prompt_async` into the SAME opencode session (opencode-web does
+   * exactly this and it works — UPDATE 2 in the investigation doc), preserving the
+   * conversation's history/continuity: we do NOT create a fresh session and we do
+   * NOT overwrite the conversation's `opencode_session_id`. Only the opencode
+   * user-message id changes — to a fresh native id per attempt (opencode's
+   * caller-supplied id dedup is global+permanent, so each attempt needs a never-
+   * seen id).
    *
-   * 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.
+   * Reply correlation is PRESERVED: the native id is random and NOT re-derivable
+   * from the row id, so the runner carries it to the server (on markProcessing/
+   * markDone via `redriveOpencodeMessageId`), which persists it on the row and
+   * correlates the reply by THAT id (`conversation-notification.ts`). A normal,
+   * never-re-driven message still correlates by the derived stable id — unchanged.
+   *
+   * Bounded to `stuckQueuedRedriveMax` attempts. On exhaustion the row is marked
+   * FAILED (existing channel failure affordance) so the user is TOLD it could not
+   * be answered rather than left silent, and it is removed from the in-flight set.
+   *
+   * @returns true if the message LEFT this watcher's in-flight set (gave up +
+   *   marked failed) — the caller then stops servicing it this tick. Returns false
+   *   when the follow-up stays in THIS watcher (re-driven in place, or the re-drive
+   *   send failed and the next window retries).
+   */
+  async redriveStuckQueued(sessionId, watcher, inFlight, messages) {
+    if (await this.deliverIfAnyAttemptCompleted(sessionId, watcher, inFlight, messages)) {
+      return true;
+    }
+    if (inFlight.redriveAttempts >= this.stuckQueuedRedriveMax) {
+      this.log({
+        level: "error",
+        message: `Message ${inFlight.evidentMessageId.slice(0, 8)} stuck queued after ${inFlight.redriveAttempts} re-drive attempt(s) \u2014 marking failed`,
+        conversation_id: watcher.conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      try {
+        await this.markFailed(watcher.conv.id, inFlight.evidentMessageId);
+      } catch (err) {
+        if (err instanceof ChannelAuthError) throw err;
+        this.log({
+          level: "error",
+          message: `Failed to mark stuck message ${inFlight.evidentMessageId.slice(0, 8)} failed (leaving for the cron safety net): ${err instanceof Error ? err.message : String(err)}`,
+          conversation_id: watcher.conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+      }
+      this.removeInFlight(watcher, inFlight.evidentMessageId);
+      return true;
+    }
+    inFlight.redriveAttempts += 1;
+    inFlight.lastRedriveAt = this.now();
+    this.log({
+      level: "info",
+      message: `Message ${inFlight.evidentMessageId.slice(0, 8)} stuck queued on an idle session \u2014 re-driving into the SAME session with a native id (attempt ${inFlight.redriveAttempts}/${this.stuckQueuedRedriveMax})`,
+      conversation_id: watcher.conv.id,
+      message_id: inFlight.evidentMessageId
+    });
+    void this.postSignal(watcher.conv.id, inFlight.evidentMessageId, "redriven", {
+      redrive_attempt: inFlight.redriveAttempts
+    });
+    const options = {
+      agent: inFlight.message.opencode_agent ?? void 0,
+      model: inFlight.message.opencode_model ?? void 0
+    };
+    const nativeId = nativeOpencodeMessageId();
+    try {
+      await sendPromptAsync(this.port, sessionId, inFlight.message.content, options, nativeId);
+    } catch (err) {
+      if (err instanceof ChannelAuthError) throw err;
+      inFlight.redriveAttempts -= 1;
+      this.log({
+        level: "error",
+        message: `Re-drive failed for stuck message ${inFlight.evidentMessageId.slice(0, 8)} (will retry next window): ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: watcher.conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      return false;
+    }
+    inFlight.opencodeMessageId = nativeId;
+    inFlight.redriveOpencodeMessageId = nativeId;
+    inFlight.attemptedOpencodeMessageIds.push(nativeId);
+    inFlight.started = false;
+    return false;
+  }
+  /**
+   * Finding 2 (Bugbot #217): scan EVERY opencode id this stuck message has been
+   * driven under (`attemptedOpencodeMessageIds`) for a COMPLETED correlated reply
+   * in the tick's snapshot; if one is found, markDone off THAT id (so the reply an
+   * earlier re-drive attempt eventually produced is delivered) instead of
+   * re-driving again or marking failed. Idempotent + guarded like the watcher's
+   * done branch. `@returns` true when the message left the in-flight set (delivered
+   * or terminally-undeliverable) — the caller then stops servicing it this tick.
    *
-   * 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.
+   * The LATEST id is normally handled by `serviceInFlightMessage`'s own `done`
+   * branch; this covers the ids a re-drive OVERWROTE, which that branch no longer
+   * polls. `messageRunState === 'done'` means a completed, non-errored correlated
+   * reply exists for that id.
    */
-  async watchPausedSession(conv, message, sessionId) {
-    const deadline = Date.now() + this.pausedMaxWaitMs;
+  async deliverIfAnyAttemptCompleted(sessionId, watcher, inFlight, messages) {
+    const completedId = inFlight.attemptedOpencodeMessageIds.find(
+      (id) => messageRunState(messages, id) === "done"
+    );
+    if (!completedId) return false;
+    if (inFlight.done) {
+      this.removeInFlight(watcher, inFlight.evidentMessageId);
+      return true;
+    }
+    this.log({
+      level: "info",
+      message: `Message ${inFlight.evidentMessageId.slice(0, 8)} completed under an earlier re-drive attempt's id \u2014 marking done (not re-driving/failing)`,
+      conversation_id: watcher.conv.id,
+      message_id: inFlight.evidentMessageId
+    });
     try {
-      while (Date.now() < deadline) {
-        await this.sleep(this.pausedPollIntervalMs);
-        let completed = false;
-        try {
-          const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
-          if (res.ok) {
-            const body = await res.json();
-            const messages = Array.isArray(body) ? body : null;
-            completed = isTurnComplete(messages);
+      await this.markDone(watcher.conv.id, inFlight.evidentMessageId, sessionId, completedId);
+    } catch (err) {
+      if (err instanceof ChannelAuthError) throw err;
+      this.log({
+        level: "error",
+        message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done off an earlier re-drive attempt (leaving for the cron safety net): ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: watcher.conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      this.removeInFlight(watcher, inFlight.evidentMessageId);
+      return true;
+    }
+    inFlight.done = true;
+    this.removeInFlight(watcher, inFlight.evidentMessageId);
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // 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
+            });
           }
-        } catch {
+        }
+      }
+    }
+    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;
         }
-        if (!completed) 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, effectiveId)`, where `effectiveId` is
+   * the NATIVE id a prior lifetime's re-drive ran this row under
+   * (`row.opencode_message_id`) if present, else the STABLE derived id
+   * (`opencodeMessageIdFor(row.id)`). Consulting the native id is what makes a
+   * re-driven row that ALREADY ran/completed resolve correctly on restart instead
+   * of looking `queued` under the (never-run) stable id and being re-driven AGAIN
+   * (Bugbot #217 Finding 3 — the duplicate-turn bug):
+   *   - `done`             → `markDone` now (guarded like the watcher's done branch);
+   *   - `failed`           → `markFailed` with the surfaced error (issue #182), so an
+   *                          errored turn is reported failed on restart, NOT re-dispatched;
+   *   - `running`/`queued` → re-attach a watcher via `registerReadopted` (no re-dispatch),
+   *                          tracking the effective id so the reply correlates by it;
+   *   - `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 stableId = opencodeMessageIdFor2(row.id);
+    const nativeRedriveId = row.opencode_message_id;
+    const ocId = nativeRedriveId ?? stableId;
+    const state = messageRunState(messages, ocId);
+    if (state === "done") {
+      if (this.doneUndeliverable.has(row.id)) {
         this.log({
           level: "info",
-          message: `Paused session ${sessionId.slice(0, 8)} completed \u2014 marking message ${message.id.slice(0, 8)} done`,
-          conversation_id: conv.id,
-          message_id: message.id
+          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
         });
-        await this.markDone(conv.id, message.id, sessionId);
         return;
       }
       this.log({
         level: "info",
-        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: message.id
+        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, nativeRedriveId);
+      } 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 (state === "failed") {
+      const error2 = messageError(messages, ocId) ?? void 0;
+      this.log({
+        level: "error",
+        message: `Re-adopt: message ${row.id.slice(0, 8)} errored while unwatched \u2014 marking failed: ${error2 ?? "(no error text)"}`,
+        conversation_id: row.conversation_id,
+        message_id: row.id
+      });
+      try {
+        await this.markFailed(row.conversation_id, row.id, sessionId, error2);
+      } 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)} failed (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)} failed (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),
+        nativeRedriveId
+      );
+      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 (${nativeRedriveId ? "native re-drive id" : "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: `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
+        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);
+  }
+  /**
+   * 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;
+      });
+      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)
@@ -1849,52 +2901,182 @@ var ChannelDriver = class {
     }
     return await res.json();
   }
-  async markProcessing(conversationId, messageId, sessionId) {
+  /**
+   * 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',
+   * 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, opencodeMessageId) {
     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 })
+        body: JSON.stringify({
+          status: "processing",
+          opencode_session_id: sessionId,
+          ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {}
+        })
       }
     );
     this.assertAuth(res, "marking message as processing");
-    return res.ok;
+    if (res.ok) return true;
+    if (isRetryableStatus(res.status)) {
+      throw new Error(`marking message as processing: HTTP ${res.status}`);
+    }
+    return false;
   }
   /**
-   * EXISTING combinedAuth completion route — idempotent + retried (WI-CHAN-2).
-   * `PATCH .../messages/:id {status:'done', opencode_session_id}`. The server's
+   * EXISTING combinedAuth completion route — idempotent (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).
+   * 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).
+   */
+  async markDone(conversationId, messageId, sessionId, opencodeMessageId) {
+    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,
+          ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {}
+        })
+      }
+    );
+    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);
+  }
+  /**
+   * Mark a message `failed`. `sessionId` / `error` are threaded to the API ONLY
+   * when provided (issue #182): a bare `markFailed(conv, msg)` sends
+   * `{status:'failed'}` unchanged (the dispatch-failure path), while an errored
+   * OpenCode turn sends `{status:'failed', opencode_session_id, error}` so the
+   * failure reason reaches the channel.
    */
-  async markDone(conversationId, messageId, sessionId) {
+  async markFailed(conversationId, messageId, sessionId, error2) {
+    const body = { status: "failed" };
+    if (sessionId !== void 0) body.opencode_session_id = sessionId;
+    if (error2 !== void 0) body.error = error2;
     await this.callWithRetry(
-      "marking message as done",
+      "marking message as failed",
       () => 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 })
+          body: JSON.stringify(body)
         }
       )
     );
   }
-  async markFailed(conversationId, messageId) {
-    await this.callWithRetry(
-      "marking message as failed",
-      () => this.fetchImpl(
-        `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
+  /**
+   * 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: "PATCH",
+          method: "POST",
           headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
-          body: JSON.stringify({ status: "failed" })
+          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(
@@ -1909,10 +3091,17 @@ var ChannelDriver = class {
   }
   /**
    * EXISTING combinedAuth interaction route (WI-CHAN-3) — idempotent + retried.
-   * `POST .../interactive-event {type, data}`. The server persists the
-   * interaction and posts a link to the proxied opencode-web conversation.
+   * `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.
    */
-  async reportInteraction(conversationId, type, data) {
+  async reportInteraction(conversationId, type, data, sourceMessageId) {
     try {
       await this.callWithRetry(
         "reporting interactive event",
@@ -1921,7 +3110,9 @@ var ChannelDriver = class {
           {
             method: "POST",
             headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
-            body: JSON.stringify({ type, data })
+            body: JSON.stringify(
+              sourceMessageId ? { type, data, source_message_id: sourceMessageId } : { type, data }
+            )
           }
         )
       );
@@ -1930,6 +3121,7 @@ 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({
@@ -1937,6 +3129,7 @@ var ChannelDriver = class {
         message: `Failed to surface ${type}: ${err instanceof Error ? err.message : String(err)}`,
         conversation_id: conversationId
       });
+      return false;
     }
   }
   // -------------------------------------------------------------------------
@@ -1975,8 +3168,9 @@ var ChannelDriver = class {
           await this.sleep(backoffDelay(attempt, this.retry));
           continue;
         }
+        break;
       }
-      throw new Error(`${context}: HTTP ${res.status}`);
+      throw new ChannelTerminalError(`${context}: HTTP ${res.status}`, res.status);
     }
     throw lastError instanceof Error ? lastError : new Error(`${context}: exhausted retries`);
   }
@@ -2199,7 +3393,9 @@ async function getAgentInfo(agentId, authHeader) {
 // src/commands/run.ts
 var MAX_ACTIVITY_LOG_ENTRIES = 10;
 var CHANNEL_POLL_INTERVAL_MS = Number(process.env.EVIDENT_CHANNEL_POLL_INTERVAL_MS) || 2e3;
-function log(state, message, isError = false) {
+var CHANNEL_STUCK_QUEUED_MS = Number(process.env.EVIDENT_STUCK_QUEUED_MS) || void 0;
+var CHANNEL_SETTLE_MS = Number(process.env.EVIDENT_SETTLE_MS) || void 0;
+function log2(state, message, isError = false) {
   if (state.json) {
     console.log(
       JSON.stringify({
@@ -2224,9 +3420,9 @@ function logActivity(state, entry) {
   }
   if (!state.interactive) {
     if (entry.type === "error") {
-      log(state, entry.error ?? "Unknown error", true);
+      log2(state, entry.error ?? "Unknown error", true);
     } else if (entry.type === "info" && entry.message) {
-      log(state, entry.message);
+      log2(state, entry.message);
     }
   }
 }
@@ -2312,6 +3508,7 @@ 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..." });
@@ -2321,9 +3518,11 @@ async function driveChannels(state, driver) {
     try {
       const processed = await driver.drainPending();
       state.messageCount += processed;
-      if (processed > 0) {
+      const proxiedActivity = state.lastProxiedActivityAt !== lastSeenProxiedActivityAt;
+      lastSeenProxiedActivityAt = state.lastProxiedActivityAt;
+      if (processed > 0 || driver.hasInFlightWatchers() || proxiedActivity) {
         idlePolls = 0;
-        if (state.interactive) displayStatus(state);
+        if (processed > 0 && state.interactive) displayStatus(state);
       } else if (state.idleTimeout !== null) {
         idlePolls++;
         if (idlePolls === 1) {
@@ -2373,7 +3572,7 @@ async function cleanup(state) {
       logActivity(state, { type: "info", message: "Stopped OpenCode process" });
       displayStatus(state);
     } else {
-      log(state, "Stopped OpenCode process");
+      log2(state, "Stopped OpenCode process");
     }
     state.opencodeProcess = null;
   }
@@ -2396,10 +3595,11 @@ async function run(options) {
     running: true,
     activityLog: [],
     messageCount: 0,
+    lastProxiedActivityAt: null,
     authHeader: ""
   };
   if (state.idleTimeout === null && (process.env.GITHUB_ACTIONS || process.env.CI)) {
-    log(
+    log2(
       state,
       "Warning: No --idle-timeout set in CI environment. The runner will poll indefinitely until the job times out. Consider adding --idle-timeout 30 to avoid wasting runner minutes.",
       false
@@ -2410,7 +3610,7 @@ async function run(options) {
       logActivity(state, { type: "info", message: "Shutting down..." });
       displayStatus(state);
     } else {
-      log(state, "Shutting down...");
+      log2(state, "Shutting down...");
     }
     await cleanup(state);
     await shutdownTelemetry();
@@ -2443,7 +3643,7 @@ async function run(options) {
         const resolved = await resolveAgentIdFromKey(state.authHeader);
         if (resolved.agent_id) {
           state.agentId = resolved.agent_id;
-          log(state, `Resolved agent ID from key: ${state.agentId}`);
+          log2(state, `Resolved agent ID from key: ${state.agentId}`);
           if (state.interactive && !state.json) {
             logActivity(state, {
               type: "info",
@@ -2506,14 +3706,21 @@ async function run(options) {
         port: state.port,
         interactive: state.interactive,
         agentId: state.agentId,
-        log: (message) => log(state, message)
+        log: (message) => log2(state, message)
       });
       state.port = oc.port;
       state.opencodeProcess = oc.process;
       state.opencodeVersion = oc.version;
       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 version2 = state.opencodeVersion ? ` (v${state.opencodeVersion})` : "";
+      ocSpinner?.succeed(`OpenCode running on port ${state.port}${version2}`);
+      const versionWarning = buildOpenCodeVersionWarning(state.opencodeVersion);
+      if (versionWarning) {
+        log2(state, versionWarning, false);
+        if (state.interactive && !state.json) {
+          logActivity(state, { type: "info", message: versionWarning });
+        }
+      }
     } catch (error2) {
       ocSpinner?.fail(error2.message);
       throw error2;
@@ -2525,6 +3732,8 @@ async function run(options) {
       apiUrl: getApiUrlConfig(),
       getAuthHeader: () => state.authHeader,
       conversationFilter: state.conversationFilter,
+      stuckQueuedMs: CHANNEL_STUCK_QUEUED_MS,
+      settleMs: CHANNEL_SETTLE_MS,
       log: (entry) => logActivity(state, {
         type: entry.level === "error" ? "error" : "info",
         message: entry.message,
@@ -2544,7 +3753,11 @@ async function run(options) {
             type: "info",
             message: `Tunnel ${isReconnect ? "reconnected" : "connected"} (agent: ${agentId})`
           });
-          emitAgentConnected(state.agentId, { port: state.port });
+          emitAgentConnected(state.agentId, {
+            port: state.port,
+            cli_version: getCliVersion(),
+            opencode_version: state.opencodeVersion
+          });
           if (!isReconnect) tunnelSpinner?.succeed("Tunnel connected");
           if (state.interactive) displayStatus(state);
           channelDriver.drainPending().then((processed) => {
@@ -2578,9 +3791,14 @@ async function run(options) {
           logActivity(state, { type: "error", error: error2 });
           if (state.interactive) displayStatus(state);
         },
-        // Web traffic is proxied transparently; only note opencode is live.
+        // 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.
         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.
@@ -2619,7 +3837,7 @@ async function run(options) {
       throw error2;
     }
     if (!interactive || state.json) {
-      log(state, "Driving channel messages...");
+      log2(state, "Driving channel messages...");
     }
     await driveChannels(state, channelDriver);
     await cleanup(state);
@@ -2631,7 +3849,7 @@ async function run(options) {
         })
       );
     } else if (!interactive) {
-      log(state, `Completed. Processed ${state.messageCount} message(s).`);
+      log2(state, `Completed. Processed ${state.messageCount} message(s).`);
     }
     await shutdownTelemetry();
     process.exit(0);
@@ -2653,8 +3871,9 @@ 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("0.1.0").option(
+program.name("evident").description("Run OpenCode locally and connect it to Evident").version(version).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) => {