@evident-ai/cli 3.0.1-dev.a748d55 → 3.0.1-dev.a7dab7b

package/dist/index.js

@@ -471,12 +471,6 @@ 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)
@@ -515,7 +509,10 @@ function stripQuery(url) {
 }
 
 // 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;
@@ -715,7 +712,7 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
 }
 
 // src/lib/opencode/opencode-version-gate.ts
-var QUEUE_VALIDATED_OPENCODE_VERSIONS = ["1.17.11"];
+var QUEUE_VALIDATED_OPENCODE_VERSIONS = ["1.17.11", "1.18.3"];
 function isQueueValidatedVersion(version2) {
   if (!version2) return false;
   return QUEUE_VALIDATED_OPENCODE_VERSIONS.includes(version2);
@@ -1071,6 +1068,16 @@ function isAssistantInFlight(m) {
   if (completedOf(m) == null) return true;
   return finishOf(m) === "tool-calls";
 }
+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;
+  }
+}
 async function createOpenCodeSession(port, directory) {
   const url = new URL(`${opencodeBase(port)}/session`);
   if (directory && directory.trim()) {
@@ -1088,9 +1095,16 @@ async function createOpenCodeSession(port, directory) {
   const data = await response.json();
   return data.id;
 }
-async function sendPromptAsync(port, sessionId, content, options, messageId) {
+function messageText(m) {
+  if (!m || !Array.isArray(m.parts)) return "";
+  return m.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+}
+async function sendPromptAsync(port, sessionId, content, options) {
+  const before = await getSessionMessages(port, sessionId);
+  const knownUserIds = new Set(
+    (before ?? []).filter((m) => roleOf(m) === "user").map((m) => idOf(m)).filter((id) => typeof id === "string")
+  );
   const body = {
-    messageID: messageId,
     parts: [{ type: "text", text: content }]
   };
   if (options?.agent) {
@@ -1114,6 +1128,29 @@ async function sendPromptAsync(port, sessionId, content, options, messageId) {
     const text = await res.text().catch(() => "");
     throw new Error(`OpenCode prompt_async failed: HTTP ${res.status}${text ? `: ${text}` : ""}`);
   }
+  const READ_BACK_ATTEMPTS = 5;
+  const READ_BACK_DELAY_MS = 150;
+  for (let attempt = 0; attempt < READ_BACK_ATTEMPTS; attempt++) {
+    const after = await getSessionMessages(port, sessionId);
+    if (after) {
+      let best = null;
+      for (const m of after) {
+        if (roleOf(m) !== "user") continue;
+        const id = idOf(m);
+        if (typeof id !== "string" || knownUserIds.has(id)) continue;
+        if (messageText(m) !== content) continue;
+        const created = createdOf(m) ?? 0;
+        if (best === null || created > best.created) {
+          best = { id, created };
+        }
+      }
+      if (best) return best.id;
+    }
+    if (attempt < READ_BACK_ATTEMPTS - 1) {
+      await new Promise((resolve) => setTimeout(resolve, READ_BACK_DELAY_MS));
+    }
+  }
+  return null;
 }
 function findAssistantReplyAfter(messages, userMessageId) {
   if (!messages || messages.length === 0) return null;
@@ -1186,31 +1223,6 @@ function hasRunningAssistantExcept(messages, exceptUserMessageId) {
     (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;
-    }
-  }
-  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
 import WebSocket2 from "ws";
@@ -1288,12 +1300,14 @@ var StreamForwarder = class {
       this.send({ type: "res_end", sid });
       return;
     }
-    log("info", "agent_request", {
-      correlation_id: correlationId,
-      sid,
-      method,
-      path: stripQuery(path)
-    });
+    if (process.env.DEBUG) {
+      log("debug", "agent_request", {
+        correlation_id: correlationId,
+        sid,
+        method,
+        path: stripQuery(path)
+      });
+    }
     const ac = new AbortController();
     let bodyPromise;
     let pushBody;
@@ -1340,12 +1354,14 @@ 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
-    });
+    if (process.env.DEBUG) {
+      log("debug", "agent_response", {
+        correlation_id: correlationId,
+        sid,
+        status: upstream.status,
+        duration_ms: Date.now() - startedAt
+      });
+    }
     this.callbacks.onHead?.(sid, upstream.status);
     try {
       if (upstream.body) {
@@ -1615,10 +1631,7 @@ 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);
@@ -1653,13 +1666,18 @@ var ChannelDriver = class {
   sleep;
   pausedPollIntervalMs;
   pausedMaxWaitMs;
-  dispatchConfirmMs;
   stuckQueuedMs;
-  stuckQueuedRedriveMax;
-  settleMs;
   now;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
+  /**
+   * Per-opencode-session dispatch lock (Task 2.1a). `sendPromptAsync` is no
+   * longer idempotent (no caller-supplied `messageID`), and its read-back picks
+   * "the one new user row" — which is only unambiguous if no OTHER dispatch into
+   * the SAME session interleaves its snapshot→POST→read-back. This map chains each
+   * session's dispatches so they run serially; distinct sessions stay concurrent.
+   */
+  sessionDispatchLocks = /* @__PURE__ */ new Map();
   /**
    * Per-SESSION watchers (WI-3), keyed by opencode sessionId. Single-flight per
    * session: one polling loop services all of that session's in-flight messages.
@@ -1710,6 +1728,20 @@ var ChannelDriver = class {
    * the row leaves the processing list, exactly like `dontRedispatch`.
    */
   doneUndeliverable = /* @__PURE__ */ new Set();
+  /**
+   * "A null-id re-adopt re-dispatch is in flight, awaiting its read-back" (WI-5
+   * Task 5.4, High-2). Since we no longer send a caller-supplied id, a re-dispatch
+   * is NOT idempotent: if `forceReadoptRun` dispatches on tick N but the read-back +
+   * persist hasn't landed before tick N+1 re-reads the still-null
+   * `row.opencode_message_id`, tick N+1 would dispatch AGAIN → duplicate user turns.
+   * A row is added here right before its `sendPromptAsync` and `forceReadoptRun`
+   * short-circuits while it is present, so a null-id row is re-dispatched AT MOST
+   * ONCE per outstanding read-back. Cleared on a SUCCESSFUL dispatch+read-back (the
+   * row is then tracked in `dispatched`, so `readoptOne`'s early skip prevents
+   * re-entry) OR on a failed/unresolved dispatch (the message is genuinely un-sent,
+   * so the NEXT tick may retry exactly once more).
+   */
+  awaitingReadopt = /* @__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
@@ -1732,10 +1764,7 @@ 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`. */
@@ -1826,11 +1855,11 @@ var ChannelDriver = class {
         skippedAlreadyDispatched += 1;
         continue;
       }
-      const opencodeMessageId = opencodeMessageIdFor2(message.id);
       const options = {
         agent: message.opencode_agent ?? void 0,
         model: message.opencode_model ?? void 0
       };
+      let opencodeMessageId;
       try {
         this.log({
           level: "info",
@@ -1838,7 +1867,10 @@ var ChannelDriver = class {
           conversation_id: conv.id,
           message_id: message.id
         });
-        await sendPromptAsync(this.port, sessionId, message.content, options, opencodeMessageId);
+        opencodeMessageId = await this.dispatchLocked(
+          sessionId,
+          () => sendPromptAsync(this.port, sessionId, message.content, options)
+        );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         this.dispatched.delete(message.id);
@@ -1852,6 +1884,15 @@ var ChannelDriver = class {
         });
         continue;
       }
+      if (opencodeMessageId === null) {
+        this.log({
+          level: "error",
+          message: `Message ${message.id.slice(0, 8)} dispatched but its opencode id could not be read back \u2014 leaving un-tracked to retry next tick`,
+          conversation_id: conv.id,
+          message_id: message.id
+        });
+        continue;
+      }
       this.dispatched.add(message.id);
       this.registerInFlight(conv, sessionId, message, opencodeMessageId);
       dispatched += 1;
@@ -1900,6 +1941,25 @@ var ChannelDriver = class {
   // -------------------------------------------------------------------------
   // Per-session watcher (WI-3)
   // -------------------------------------------------------------------------
+  /**
+   * Run one dispatch (`sendPromptAsync` snapshot→POST→read-back) serialized per
+   * opencode session (Task 2.1a), so two dispatches into the SAME session can
+   * never interleave and mis-correlate their read-backs. Distinct sessions run
+   * concurrently. The chained tail intentionally ignores the prior result/error
+   * (each dispatch reports its own outcome to its caller).
+   */
+  dispatchLocked(sessionId, fn) {
+    const prior = this.sessionDispatchLocks.get(sessionId) ?? Promise.resolve();
+    const run2 = prior.then(fn, fn);
+    this.sessionDispatchLocks.set(
+      sessionId,
+      run2.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+    return run2;
+  }
   /** Register a freshly-dispatched message with its session's watcher state. */
   registerInFlight(conv, sessionId, message, opencodeMessageId) {
     let watcher = this.watchers.get(sessionId);
@@ -1922,11 +1982,7 @@ var ChannelDriver = class {
       deadline: now + this.pausedMaxWaitMs,
       started: false,
       done: false,
-      stuckReported: false,
-      redriveAttempts: 0,
-      lastRedriveAt: null,
-      redriveOpencodeMessageId: null,
-      attemptedOpencodeMessageIds: [opencodeMessageId]
+      stuckReported: false
     });
   }
   /**
@@ -1946,7 +2002,7 @@ var ChannelDriver = class {
    * 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) {
+  registerReadopted(conv, sessionId, message, opencodeMessageId, processedAtMs) {
     let watcher = this.watchers.get(sessionId);
     if (!watcher) {
       watcher = {
@@ -1968,17 +2024,11 @@ var ChannelDriver = class {
       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]
+      // AND the stuck-queued observer 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
+      // (#210/#220 observability).
+      stuckReported: false
     });
   }
   /**
@@ -2072,7 +2122,7 @@ var ChannelDriver = class {
           conv.id,
           inFlight.evidentMessageId,
           sessionId,
-          inFlight.redriveOpencodeMessageId
+          inFlight.opencodeMessageId
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
@@ -2107,7 +2157,7 @@ var ChannelDriver = class {
             conv.id,
             inFlight.evidentMessageId,
             sessionId,
-            inFlight.redriveOpencodeMessageId
+            inFlight.opencodeMessageId
           );
         } catch (err) {
           if (err instanceof ChannelAuthError) throw err;
@@ -2190,25 +2240,13 @@ var ChannelDriver = class {
       this.removeInFlight(watcher, inFlight.evidentMessageId);
       return;
     }
-    if (state === "unknown") {
-      if (this.now() - inFlight.dispatchedAt >= this.dispatchConfirmMs) {
-        await this.redispatchInFlight(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 (state === "queued" && pastStuckBound && sessionIdle && !inFlight.stuckReported) {
+      inFlight.stuckReported = true;
+      void this.postSignal(conv.id, inFlight.evidentMessageId, "stuck_queued", {
+        stuck_for_ms: this.now() - inFlight.dispatchedAt
+      });
     }
     if (this.now() >= inFlight.deadline) {
       this.log({
@@ -2217,184 +2255,11 @@ var ChannelDriver = class {
         conversation_id: conv.id,
         message_id: inFlight.evidentMessageId
       });
-      this.removeInFlight(watcher, inFlight.evidentMessageId);
-    }
-  }
-  /**
-   * Re-dispatch a message whose user row never appeared (idle-path guard). Safe:
-   * opencode treats a duplicate caller-supplied `messageID` as idempotent (PoC
-   * fact 9) — one user message + one reply even if the original DID land. Resets
-   * the dispatch timestamp so the guard doesn't immediately fire again.
-   */
-  async redispatchInFlight(sessionId, inFlight) {
-    const options = {
-      agent: inFlight.message.opencode_agent ?? void 0,
-      model: inFlight.message.opencode_model ?? void 0
-    };
-    this.log({
-      level: "info",
-      message: `Message ${inFlight.evidentMessageId.slice(0, 8)} not observed after dispatch \u2014 re-dispatching (idle-path guard)`,
-      message_id: inFlight.evidentMessageId
-    });
-    try {
-      await sendPromptAsync(
-        this.port,
-        sessionId,
-        inFlight.message.content,
-        options,
-        inFlight.opencodeMessageId
-      );
-    } catch (err) {
-      this.log({
-        level: "error",
-        message: `Re-dispatch failed for message ${inFlight.evidentMessageId.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`,
-        message_id: inFlight.evidentMessageId
-      });
-    }
-    inFlight.dispatchedAt = this.now();
-  }
-  /**
-   * 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).
-   *
-   * 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.
-   *
-   * 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 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 {
-      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
+      void this.postSignal(conv.id, inFlight.evidentMessageId, "gave_up", {
+        watched_for_ms: this.now() - inFlight.dispatchedAt
       });
       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)
@@ -2483,19 +2348,17 @@ var ChannelDriver = class {
    * 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):
+   * Branches on `messageRunState(messages, row.opencode_message_id)` — the
+   * opencode-assigned user-message id persisted on the first `processing` PATCH
+   * (#218). A row with a NULL stored id (dispatched but the read-back never landed
+   * before the restart) has no id to correlate → treated as an orphan and
+   * re-dispatched (at most once, see `forceReadoptRun`):
    *   - `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).
+   *                          tracking the stored id so the reply correlates by it;
+   *   - `unknown`/null id  → re-dispatch (opencode assigns a fresh id) + attach a watcher.
    *
    * Only `ChannelAuthError` propagates.
    */
@@ -2509,10 +2372,8 @@ var ChannelDriver = class {
       });
       return;
     }
-    const stableId = opencodeMessageIdFor2(row.id);
-    const nativeRedriveId = row.opencode_message_id;
-    const ocId = nativeRedriveId ?? stableId;
-    const state = messageRunState(messages, ocId);
+    const ocId = row.opencode_message_id;
+    const state = messageRunState(messages, ocId ?? "");
     if (state === "done") {
       if (this.doneUndeliverable.has(row.id)) {
         this.log({
@@ -2530,7 +2391,7 @@ var ChannelDriver = class {
         message_id: row.id
       });
       try {
-        await this.markDone(row.conversation_id, row.id, sessionId, nativeRedriveId);
+        await this.markDone(row.conversation_id, row.id, sessionId, ocId);
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         if (err instanceof ChannelTerminalError) {
@@ -2555,7 +2416,7 @@ var ChannelDriver = class {
       return;
     }
     if (state === "failed") {
-      const error2 = messageError(messages, ocId) ?? void 0;
+      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)"}`,
@@ -2596,23 +2457,16 @@ var ChannelDriver = class {
       });
       return;
     }
-    if (state === "running" || state === "queued") {
+    if ((state === "running" || state === "queued") && ocId) {
       const conv = this.convForRow(sessionId, row);
       const message = this.queuedMessageForRow(row);
-      this.registerReadopted(
-        conv,
-        sessionId,
-        message,
-        ocId,
-        this.processedAtMs(row),
-        nativeRedriveId
-      );
+      this.registerReadopted(conv, sessionId, message, ocId, this.processedAtMs(row));
       this.dispatched.add(row.id);
       this.readopted.add(row.id);
       this.ensureWatcherRunning(sessionId);
       this.log({
         level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} ${state} \u2014 re-attached watcher (${nativeRedriveId ? "native re-drive id" : "stable id"}, no re-dispatch)`,
+        message: `Re-adopt: message ${row.id.slice(0, 8)} ${state} \u2014 re-attached watcher (stored id, no re-dispatch)`,
         conversation_id: row.conversation_id,
         message_id: row.id
       });
@@ -2621,23 +2475,36 @@ var ChannelDriver = class {
     await this.forceReadoptRun(sessionId, row);
   }
   /**
-   * Re-dispatch an orphaned (`unknown`) `processing` row (ADR-0046 Decision §2).
+   * Re-dispatch an orphaned (`unknown`/null-id) `processing` row (ADR-0046 §2).
+   *
+   * #218/WI-5: the row's user message is absent (never kept, or a null stored id),
+   * so we re-`prompt_async` WITHOUT a caller id (opencode assigns a monotonic one),
+   * read it back, and register the watcher under the assigned id so the reply
+   * correlates server-side.
    *
-   * 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.
+   * ⚠️ AT-MOST-ONCE (High-2): dispatch is no longer idempotent (no caller-supplied
+   * id). Without a guard, if this dispatches on tick N but the read-back+persist
+   * hasn't landed before tick N+1 re-reads the still-null `opencode_message_id`,
+   * tick N+1 would dispatch AGAIN → duplicate user turns. The `awaitingReadopt`
+   * latch makes a null-id row re-dispatched AT MOST ONCE per outstanding read-back:
+   * short-circuit while the row is latched; clear it on a successful dispatch (the
+   * row is then tracked in `dispatched`, so `readoptOne`'s early skip prevents
+   * re-entry) OR on a failed/unresolved dispatch (genuinely un-sent → the next tick
+   * may retry exactly once more).
    *
-   * `evidentMessageId = row.id` addresses the SERVER row; the stable
-   * `opencodeMessageId` is what the watcher polls. Deadline anchored to
+   * `evidentMessageId = row.id` addresses the SERVER row. Deadline anchored to
    * `processed_at` (Invariant 1).
    */
   async forceReadoptRun(sessionId, row) {
-    const ocId = opencodeMessageIdFor2(row.id);
+    if (this.awaitingReadopt.has(row.id)) {
+      this.log({
+        level: "info",
+        message: `Re-adopt: message ${row.id.slice(0, 8)} already has a re-dispatch awaiting read-back \u2014 skipping (at most once)`,
+        conversation_id: row.conversation_id,
+        message_id: row.id
+      });
+      return;
+    }
     if (this.processedAtMs(row) + this.pausedMaxWaitMs <= this.now()) {
       this.dontRedispatch.add(row.id);
       this.log({
@@ -2654,13 +2521,19 @@ var ChannelDriver = class {
     };
     this.log({
       level: "info",
-      message: `Re-adopt: message ${row.id.slice(0, 8)} orphaned (user message absent) \u2014 re-dispatching with the stable id`,
+      message: `Re-adopt: message ${row.id.slice(0, 8)} orphaned (user message absent) \u2014 re-dispatching (opencode assigns a fresh id)`,
       conversation_id: row.conversation_id,
       message_id: row.id
     });
+    this.awaitingReadopt.add(row.id);
+    let ocId;
     try {
-      await sendPromptAsync(this.port, sessionId, row.content, options, ocId);
+      ocId = await this.dispatchLocked(
+        sessionId,
+        () => sendPromptAsync(this.port, sessionId, row.content, options)
+      );
     } catch (err) {
+      this.awaitingReadopt.delete(row.id);
       if (err instanceof ChannelAuthError) throw err;
       this.log({
         level: "error",
@@ -2670,11 +2543,22 @@ var ChannelDriver = class {
       });
       return;
     }
+    if (ocId === null) {
+      this.awaitingReadopt.delete(row.id);
+      this.log({
+        level: "error",
+        message: `Re-adopt: message ${row.id.slice(0, 8)} re-dispatched but its opencode id could not be read back \u2014 leaving un-tracked to retry next drain`,
+        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.awaitingReadopt.delete(row.id);
     this.ensureWatcherRunning(sessionId);
   }
   /**
@@ -3387,7 +3271,6 @@ async function getAgentInfo(agentId, authHeader) {
 var MAX_ACTIVITY_LOG_ENTRIES = 10;
 var CHANNEL_POLL_INTERVAL_MS = Number(process.env.EVIDENT_CHANNEL_POLL_INTERVAL_MS) || 2e3;
 var CHANNEL_STUCK_QUEUED_MS = Number(process.env.EVIDENT_STUCK_QUEUED_MS) || void 0;
-var CHANNEL_SETTLE_MS = Number(process.env.EVIDENT_SETTLE_MS) || void 0;
 function log2(state, message, isError = false) {
   if (state.json) {
     console.log(
@@ -3726,7 +3609,6 @@ async function run(options) {
       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,
@@ -3746,7 +3628,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) => {