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

package/dist/index.js

@@ -285,14 +285,14 @@ function blank() {
   console.log();
 }
 function waitForEnter(prompt = "Press Enter to continue...") {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     process.stdout.write(chalk.dim(prompt));
     const handler = () => {
       process.stdin.removeListener("data", handler);
       process.stdin.setRawMode?.(false);
       process.stdin.pause();
       console.log();
-      resolve2();
+      resolve();
     };
     if (process.stdin.isTTY) {
       process.stdin.setRawMode?.(true);
@@ -302,7 +302,7 @@ function waitForEnter(prompt = "Press Enter to continue...") {
   });
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/commands/login.ts
@@ -376,19 +376,19 @@ async function tokenLogin() {
   console.log("Visit your Evident dashboard to generate a CLI token.");
   blank();
   process.stdout.write("Paste token: ");
-  const token = await new Promise((resolve2) => {
+  const token = await new Promise((resolve) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve2(data.trim());
+      resolve(data.trim());
     });
     if (process.stdin.isTTY) {
       process.stdin.once("data", (chunk) => {
         process.stdin.pause();
-        resolve2(chunk.toString().trim());
+        resolve(chunk.toString().trim());
       });
       process.stdin.resume();
     }
@@ -471,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)
@@ -706,13 +712,13 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
     if (health.healthy) {
       return health;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
   }
   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", "1.18.3"];
+var QUEUE_VALIDATED_OPENCODE_VERSIONS = ["1.17.11"];
 function isQueueValidatedVersion(version2) {
   if (!version2) return false;
   return QUEUE_VALIDATED_OPENCODE_VERSIONS.includes(version2);
@@ -1068,58 +1074,6 @@ 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;
-  }
-}
-function sessionLastActivityMs(session) {
-  const candidates = [
-    session.time?.updated,
-    session.time?.created,
-    session.time_updated,
-    session.time_created,
-    session.updated,
-    session.created
-  ];
-  for (const c of candidates) {
-    if (typeof c === "number" && Number.isFinite(c)) return c;
-  }
-  return null;
-}
-async function listSessions(port) {
-  try {
-    const res = await fetch(`${opencodeBase(port)}/session`);
-    if (!res.ok) return null;
-    const body = await res.json();
-    return Array.isArray(body) ? body : null;
-  } catch {
-    return null;
-  }
-}
-async function deleteSession(port, id) {
-  try {
-    const res = await fetch(`${opencodeBase(port)}/session/${id}`, { method: "DELETE" });
-    return res.status >= 200 && res.status < 300;
-  } catch {
-    return false;
-  }
-}
-async function sessionExists(port, id) {
-  try {
-    const res = await fetch(`${opencodeBase(port)}/session/${id}`);
-    if (res.status >= 200 && res.status < 300) return true;
-    if (res.status === 404) return false;
-    return null;
-  } catch {
-    return null;
-  }
-}
 async function createOpenCodeSession(port, directory) {
   const url = new URL(`${opencodeBase(port)}/session`);
   if (directory && directory.trim()) {
@@ -1137,16 +1091,9 @@ async function createOpenCodeSession(port, directory) {
   const data = await response.json();
   return data.id;
 }
-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")
-  );
+async function sendPromptAsync(port, sessionId, content, options, messageId) {
   const body = {
+    messageID: messageId,
     parts: [{ type: "text", text: content }]
   };
   if (options?.agent) {
@@ -1170,29 +1117,6 @@ async function sendPromptAsync(port, sessionId, content, options) {
     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((resolve2) => setTimeout(resolve2, READ_BACK_DELAY_MS));
-    }
-  }
-  return null;
 }
 function findAssistantReplyAfter(messages, userMessageId) {
   if (!messages || messages.length === 0) return null;
@@ -1265,109 +1189,30 @@ function hasRunningAssistantExcept(messages, exceptUserMessageId) {
     (m) => roleOf(m) === "assistant" && parentIdOf(m) !== exceptUserMessageId && isAssistantInFlight(m)
   );
 }
-
-// src/lib/opencode/session-cleanup.ts
-var DURATION_UNIT_MS = {
-  s: 1e3,
-  m: 60 * 1e3,
-  h: 60 * 60 * 1e3,
-  d: 24 * 60 * 60 * 1e3
-};
-function parseDurationMs(input) {
-  const trimmed = input.trim();
-  const match = /^(\d+)([smhd])$/.exec(trimmed);
-  if (!match) {
-    throw new Error(
-      `Invalid duration "${input}": expected <number><unit> where unit is one of s, m, h, d (e.g. "7d", "24h", "30m", "90s").`
-    );
-  }
-  const value = Number(match[1]);
-  if (value <= 0) {
-    throw new Error(`Invalid duration "${input}": must be a positive value.`);
-  }
-  return value * DURATION_UNIT_MS[match[2]];
-}
-function selectSessionsToDelete(sessions, opts) {
-  const { maxAgeMs, maxCount, nowMs, protectedIds } = opts;
-  if (maxAgeMs === void 0 && maxCount === void 0) return [];
-  const ageEligible = (s) => {
-    if (maxAgeMs === void 0) return false;
-    if (s.lastActivityMs === null) return true;
-    return nowMs - s.lastActivityMs > maxAgeMs;
-  };
-  const countEligibleIds = /* @__PURE__ */ new Set();
-  if (maxCount !== void 0) {
-    const byActivityDesc = [...sessions].sort(
-      (a, b) => (b.lastActivityMs ?? -Infinity) - (a.lastActivityMs ?? -Infinity)
-    );
-    for (const s of byActivityDesc.slice(maxCount)) {
-      countEligibleIds.add(s.id);
-    }
-  }
-  const toDelete = [];
-  for (const s of sessions) {
-    if (protectedIds.has(s.id)) continue;
-    if (ageEligible(s) || countEligibleIds.has(s.id)) {
-      toDelete.push(s.id);
+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;
     }
   }
-  return toDelete;
+  if (newestAssistantCreated === null) return true;
+  return now - newestAssistantCreated >= settleMs;
 }
-var DEFAULT_INTERVAL = "1h";
-function resolve(flag, envValue, fallback) {
-  return flag ?? envValue ?? fallback;
+function opencodeMessageIdFor2(queuedMessageId) {
+  return opencodeMessageIdFor(queuedMessageId);
 }
-function parseMaxCount(input) {
-  const trimmed = input.trim();
-  if (!/^\d+$/.test(trimmed)) {
-    throw new Error(`Invalid max-count "${input}": expected a positive integer.`);
+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)];
   }
-  const value = Number(trimmed);
-  if (value <= 0) {
-    throw new Error(`Invalid max-count "${input}": must be greater than 0.`);
-  }
-  return value;
-}
-function resolveSessionCleanupConfig(flags, env = process.env) {
-  const warnings = [];
-  const maxAgeRaw = resolve(flags.maxAge, env.EVIDENT_SESSION_CLEANUP_MAX_AGE);
-  const maxCountRaw = resolve(flags.maxCount, env.EVIDENT_SESSION_CLEANUP_MAX_COUNT);
-  const intervalRaw = resolve(
-    flags.interval,
-    env.EVIDENT_SESSION_CLEANUP_INTERVAL,
-    DEFAULT_INTERVAL
-  );
-  let maxAgeMs;
-  if (maxAgeRaw !== void 0) {
-    try {
-      maxAgeMs = parseDurationMs(maxAgeRaw);
-    } catch (err) {
-      warnings.push(
-        `Ignoring invalid --session-cleanup-max-age: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  let maxCount;
-  if (maxCountRaw !== void 0) {
-    try {
-      maxCount = parseMaxCount(maxCountRaw);
-    } catch (err) {
-      warnings.push(
-        `Ignoring invalid --session-cleanup-max-count: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  let intervalMs;
-  try {
-    intervalMs = parseDurationMs(intervalRaw ?? DEFAULT_INTERVAL);
-  } catch (err) {
-    warnings.push(
-      `Ignoring invalid --session-cleanup-interval, using default ${DEFAULT_INTERVAL}: ${err instanceof Error ? err.message : String(err)}`
-    );
-    intervalMs = parseDurationMs(DEFAULT_INTERVAL);
-  }
-  const enabled = maxAgeMs !== void 0 || maxCount !== void 0;
-  return { enabled, maxAgeMs, maxCount, intervalMs, warnings };
+  return id;
 }
 
 // src/lib/tunnel/connection.ts
@@ -1446,26 +1291,24 @@ var StreamForwarder = class {
       this.send({ type: "res_end", sid });
       return;
     }
-    if (process.env.DEBUG) {
-      log("debug", "agent_request", {
-        correlation_id: correlationId,
-        sid,
-        method,
-        path: stripQuery(path)
-      });
-    }
+    log("info", "agent_request", {
+      correlation_id: correlationId,
+      sid,
+      method,
+      path: stripQuery(path)
+    });
     const ac = new AbortController();
     let bodyPromise;
     let pushBody;
     let endBody;
     if (has_body) {
       const chunks = [];
-      bodyPromise = new Promise((resolve2) => {
+      bodyPromise = new Promise((resolve) => {
         pushBody = (buf) => {
           chunks.push(buf);
         };
         endBody = () => {
-          resolve2(Buffer.concat(chunks));
+          resolve(Buffer.concat(chunks));
         };
       });
     }
@@ -1500,14 +1343,12 @@ var StreamForwarder = class {
       if (!STRIP_RES.has(key.toLowerCase())) resHeaders[key] = value;
     });
     this.send({ type: "head", sid, status: upstream.status, headers: resHeaders });
-    if (process.env.DEBUG) {
-      log("debug", "agent_response", {
-        correlation_id: correlationId,
-        sid,
-        status: upstream.status,
-        duration_ms: Date.now() - startedAt
-      });
-    }
+    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) {
@@ -1583,7 +1424,7 @@ function connectTunnel(options) {
   } = options;
   const tunnelUrl = getTunnelUrlConfig();
   const url = `${tunnelUrl}/tunnel/${agentId}/connect`;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const ws = new WebSocket2(url, {
       headers: {
         Authorization: authHeader
@@ -1648,7 +1489,7 @@ function connectTunnel(options) {
           clearTimeout(connectionTimeout);
           const connectedAgentId = message.agent_id ?? agentId;
           onConnected?.(connectedAgentId);
-          resolve2({
+          resolve({
             ws,
             close: () => ws.close(1e3, "CLI shutdown")
           });
@@ -1777,7 +1618,10 @@ 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);
@@ -1812,18 +1656,13 @@ 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.
@@ -1874,20 +1713,6 @@ 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
@@ -1895,33 +1720,8 @@ var ChannelDriver = class {
    * not yet resolved; `null` = resolved-but-unavailable (don't keep retrying).
    */
   opencodeDirectory = void 0;
-  /**
-   * Cache of opencode `sessionId → parentID` (its parent session, or `null` when
-   * the session is a root with no parent). Sub-agents spawned via the `task` tool
-   * run in CHILD sessions whose `parentID` chains up to the Evident-created
-   * (watched) session; we resolve this once per session so a child-session
-   * question/permission can be attributed to the watched session's subtree
-   * (`sessionBelongsTo`) instead of being dropped by an exact-id filter. A missing
-   * entry = not yet resolved; `null` = resolved root (stop walking).
-   */
-  sessionParents = /* @__PURE__ */ new Map();
   /** Serialises drains so a reconnect during a drain doesn't double-process. */
   draining = false;
-  /**
-   * The currently-executing `drainPending()` promise, or null when idle. Lets a
-   * graceful shutdown (`waitForInFlight`) await an in-progress drain so a turn it
-   * is about to dispatch is not missed by the `hasInFlightWatchers()` check (a
-   * drain that entered before `stop()` still registers its watcher).
-   */
-  activeDrain = null;
-  /**
-   * Set by `stop()` on graceful shutdown. Once stopped, `drainPending` no longer
-   * dispatches NEW work (it returns 0 immediately) — but the per-session watcher
-   * loops already running keep going so in-flight turns can finish and deliver
-   * their reply. `run.ts` awaits `waitForInFlight()` before it closes the tunnel
-   * and stops opencode.
-   */
-  stopped = false;
   constructor(config2) {
     this.agentId = config2.agentId;
     this.port = config2.port;
@@ -1935,7 +1735,10 @@ 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`. */
@@ -1953,21 +1756,8 @@ var ChannelDriver = class {
    * @returns the number of messages NEWLY dispatched to opencode's native queue.
    */
   async drainPending() {
-    if (this.stopped) return 0;
     if (this.draining) return 0;
     this.draining = true;
-    const run2 = this.runDrain();
-    this.activeDrain = run2.then(
-      () => {
-        this.activeDrain = null;
-      },
-      () => {
-        this.activeDrain = null;
-      }
-    );
-    return run2;
-  }
-  async runDrain() {
     let dispatched = 0;
     try {
       const conversations = await this.getPendingConversations();
@@ -1979,7 +1769,6 @@ var ChannelDriver = class {
         });
       }
       for (const conv of conversations) {
-        if (this.stopped) break;
         dispatched += await this.processConversation(conv);
       }
       await this.readoptProcessing();
@@ -2000,73 +1789,6 @@ var ChannelDriver = class {
     }
     return false;
   }
-  /**
-   * OpenCode session ids the session-cleanup sweep (issue #190) must NOT delete:
-   * exactly those with a live (dispatched-but-not-done / paused) turn, i.e. a
-   * `watchers` entry whose `inFlight` set is non-empty — the same predicate
-   * `hasInFlightWatchers()` uses, lifted to return the ids.
-   *
-   * Deliberately does NOT include `this.sessions` (the permanent, never-pruned
-   * conversation→session cache). Protecting every bound-but-idle session there
-   * would shield nearly every session and defeat cleanup — AND it is unnecessary:
-   * `ensureSession` is self-healing (it recreates a session whose id no longer
-   * exists), so deleting an idle bound session is harmless — the conversation's
-   * next turn transparently rebinds a fresh one. The only thing worth protecting
-   * is a session with a turn ACTIVELY in flight right now: tearing that down
-   * mid-turn would strand the running `prompt_async`. Idle sessions are fair game.
-   */
-  protectedSessionIds() {
-    const ids = /* @__PURE__ */ new Set();
-    for (const [sessionId, watcher] of this.watchers) {
-      if (watcher.inFlight.size > 0) ids.add(sessionId);
-    }
-    return ids;
-  }
-  /**
-   * Begin a graceful stop: stop accepting NEW channel work. Idempotent. After
-   * this, `drainPending()` is a no-op (returns 0), so no new message is dispatched
-   * — but the watcher loops already tracking in-flight turns keep running, so a
-   * turn that has finished (or is about to) still fires `markDone` and delivers
-   * its reply. Pair with `waitForInFlight()` to bound how long shutdown waits.
-   */
-  stop() {
-    this.stopped = true;
-  }
-  /**
-   * Wait (up to `timeoutMs`) for in-flight watcher work to settle during a
-   * graceful shutdown, so a turn whose reply is ready — or completes within the
-   * window — is delivered before the process exits, instead of being cut off and
-   * left for the ADR-0046 restart-recovery path.
-   *
-   * Bounded on purpose: the watcher's own give-up deadline is up to 10 minutes,
-   * far longer than a shutdown grace period (e.g. Fargate's SIGTERM→SIGKILL
-   * window). We poll `hasInFlightWatchers()` and return as soon as the in-flight
-   * set empties OR the timeout elapses. Anything still in flight at the timeout is
-   * safe to abandon — it stays `processing` server-side and is re-adopted on the
-   * next runner start (ADR-0046).
-   *
-   * @returns true if all in-flight work settled within the window; false if the
-   *          timeout elapsed with work still in flight.
-   */
-  async waitForInFlight(timeoutMs) {
-    const deadline = this.now() + timeoutMs;
-    const step = Math.min(this.pausedPollIntervalMs, 250);
-    if (this.activeDrain) {
-      let drainSettled = false;
-      void this.activeDrain.then(() => {
-        drainSettled = true;
-      });
-      while (!drainSettled) {
-        if (this.now() >= deadline) return false;
-        await this.sleep(step);
-      }
-    }
-    while (this.hasInFlightWatchers()) {
-      if (this.now() >= deadline) return false;
-      await this.sleep(step);
-    }
-    return true;
-  }
   /**
    * Await all outstanding per-session watchers (WI-3).
    *
@@ -2103,16 +1825,15 @@ var ChannelDriver = class {
     let dispatched = 0;
     let skippedAlreadyDispatched = 0;
     for (const message of messages) {
-      if (this.stopped) break;
       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
       };
-      let opencodeMessageId;
       try {
         this.log({
           level: "info",
@@ -2120,23 +1841,10 @@ var ChannelDriver = class {
           conversation_id: conv.id,
           message_id: message.id
         });
-        opencodeMessageId = await this.dispatchLocked(
-          sessionId,
-          () => sendPromptAsync(this.port, sessionId, message.content, options)
-        );
+        await sendPromptAsync(this.port, sessionId, message.content, options, opencodeMessageId);
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         this.dispatched.delete(message.id);
-        if (await sessionExists(this.port, sessionId) === false) {
-          this.sessions.delete(conv.id);
-          this.log({
-            level: "info",
-            message: `Message ${message.id.slice(0, 8)} dispatch hit a session (${sessionId.slice(0, 8)}) that was deleted mid-dispatch (cleanup race) \u2014 deferring this and later messages for conversation ${conv.id.slice(0, 8)} to the next tick (recreated then, in order). Already-dispatched turns keep their watcher.`,
-            conversation_id: conv.id,
-            message_id: message.id
-          });
-          break;
-        }
         await this.markFailed(conv.id, message.id).catch(() => {
         });
         this.log({
@@ -2147,15 +1855,6 @@ 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;
@@ -2172,33 +1871,16 @@ var ChannelDriver = class {
     return dispatched;
   }
   async ensureSession(conv) {
-    const bound = this.sessions.get(conv.id) ?? conv.opencode_session_id ?? null;
-    if (bound) {
-      const exists = await sessionExists(this.port, bound);
-      if (exists === false) {
-        this.log({
-          level: "info",
-          message: `OpenCode session ${bound} for conversation ${conv.id.slice(0, 8)} no longer exists (deleted or DB reset) \u2014 creating a fresh session and rebinding.`,
-          conversation_id: conv.id
-        });
-        this.sessions.delete(conv.id);
-        return this.createAndBindSession(conv.id);
-      }
-      this.sessions.set(conv.id, bound);
-      return bound;
+    const cached = this.sessions.get(conv.id);
+    if (cached) return cached;
+    if (conv.opencode_session_id) {
+      this.sessions.set(conv.id, conv.opencode_session_id);
+      return conv.opencode_session_id;
     }
-    return this.createAndBindSession(conv.id);
-  }
-  /**
-   * Create a fresh OpenCode session for a conversation, cache the binding, and
-   * best-effort persist it server-side. Shared by the first-ever bind and the
-   * self-heal recreate path in `ensureSession`.
-   */
-  async createAndBindSession(conversationId) {
     const directory = await this.resolveOpenCodeDirectory();
     const sessionId = await createOpenCodeSession(this.port, directory);
-    this.sessions.set(conversationId, sessionId);
-    await this.persistSession(conversationId, sessionId).catch(() => {
+    this.sessions.set(conv.id, sessionId);
+    await this.persistSession(conv.id, sessionId).catch(() => {
     });
     return sessionId;
   }
@@ -2221,25 +1903,6 @@ 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);
@@ -2262,7 +1925,11 @@ var ChannelDriver = class {
       deadline: now + this.pausedMaxWaitMs,
       started: false,
       done: false,
-      stuckReported: false
+      stuckReported: false,
+      redriveAttempts: 0,
+      lastRedriveAt: null,
+      redriveOpencodeMessageId: null,
+      attemptedOpencodeMessageIds: [opencodeMessageId]
     });
   }
   /**
@@ -2282,7 +1949,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) {
+  registerReadopted(conv, sessionId, message, opencodeMessageId, processedAtMs, redriveOpencodeMessageId = null) {
     let watcher = this.watchers.get(sessionId);
     if (!watcher) {
       watcher = {
@@ -2304,11 +1971,17 @@ var ChannelDriver = class {
       started: true,
       done: false,
       // Not yet reported stuck-queued. The once-guard (`stuckReported`) applies,
-      // 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
+      // 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]
     });
   }
   /**
@@ -2402,7 +2075,7 @@ var ChannelDriver = class {
           conv.id,
           inFlight.evidentMessageId,
           sessionId,
-          inFlight.opencodeMessageId
+          inFlight.redriveOpencodeMessageId
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
@@ -2437,7 +2110,7 @@ var ChannelDriver = class {
             conv.id,
             inFlight.evidentMessageId,
             sessionId,
-            inFlight.opencodeMessageId
+            inFlight.redriveOpencodeMessageId
           );
         } catch (err) {
           if (err instanceof ChannelAuthError) throw err;
@@ -2520,13 +2193,25 @@ var ChannelDriver = class {
       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 && !inFlight.stuckReported) {
-      inFlight.stuckReported = true;
-      void this.postSignal(conv.id, inFlight.evidentMessageId, "stuck_queued", {
-        stuck_for_ms: this.now() - inFlight.dispatchedAt
-      });
+    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({
@@ -2541,6 +2226,183 @@ var ChannelDriver = class {
       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(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
+    });
+    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();
+  }
+  /**
+   * 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
+      });
+      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)
   // -------------------------------------------------------------------------
@@ -2628,17 +2490,19 @@ 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, 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`):
+   * 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 stored id so the reply correlates by it;
-   *   - `unknown`/null id  → re-dispatch (opencode assigns a fresh id) + attach a watcher.
+   *                          tracking the effective id so the reply correlates by it;
+   *   - `unknown`          → re-dispatch the STABLE id + attach a watcher (orphan).
    *
    * Only `ChannelAuthError` propagates.
    */
@@ -2652,8 +2516,10 @@ var ChannelDriver = class {
       });
       return;
     }
-    const ocId = row.opencode_message_id;
-    const state = messageRunState(messages, ocId ?? "");
+    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({
@@ -2671,7 +2537,7 @@ var ChannelDriver = class {
         message_id: row.id
       });
       try {
-        await this.markDone(row.conversation_id, row.id, sessionId, ocId);
+        await this.markDone(row.conversation_id, row.id, sessionId, nativeRedriveId);
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         if (err instanceof ChannelTerminalError) {
@@ -2696,7 +2562,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)"}`,
@@ -2737,16 +2603,23 @@ var ChannelDriver = class {
       });
       return;
     }
-    if ((state === "running" || state === "queued") && ocId) {
+    if (state === "running" || state === "queued") {
       const conv = this.convForRow(sessionId, row);
       const message = this.queuedMessageForRow(row);
-      this.registerReadopted(conv, sessionId, message, ocId, this.processedAtMs(row));
+      this.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 (stored id, no re-dispatch)`,
+        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
       });
@@ -2755,45 +2628,23 @@ var ChannelDriver = class {
     await this.forceReadoptRun(sessionId, row);
   }
   /**
-   * 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.
+   * Re-dispatch an orphaned (`unknown`) `processing` row (ADR-0046 Decision §2).
    *
-   * ⚠️ 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).
+   * 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. Deadline anchored to
+   * `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) {
-    if (this.stopped) {
-      this.log({
-        level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} orphaned but the runner is stopping \u2014 not starting a fresh turn; leaving for restart recovery`,
-        conversation_id: row.conversation_id,
-        message_id: row.id
-      });
-      return;
-    }
-    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;
-    }
+    const ocId = opencodeMessageIdFor2(row.id);
     if (this.processedAtMs(row) + this.pausedMaxWaitMs <= this.now()) {
       this.dontRedispatch.add(row.id);
       this.log({
@@ -2810,19 +2661,13 @@ var ChannelDriver = class {
     };
     this.log({
       level: "info",
-      message: `Re-adopt: message ${row.id.slice(0, 8)} orphaned (user message absent) \u2014 re-dispatching (opencode assigns a fresh id)`,
+      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
     });
-    this.awaitingReadopt.add(row.id);
-    let ocId;
     try {
-      ocId = await this.dispatchLocked(
-        sessionId,
-        () => sendPromptAsync(this.port, sessionId, row.content, options)
-      );
+      await sendPromptAsync(this.port, sessionId, row.content, options, ocId);
     } catch (err) {
-      this.awaitingReadopt.delete(row.id);
       if (err instanceof ChannelAuthError) throw err;
       this.log({
         level: "error",
@@ -2832,22 +2677,11 @@ 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);
   }
   /**
@@ -2952,8 +2786,8 @@ var ChannelDriver = class {
     } catch {
     }
     for (const q of questions) {
+      if (q.sessionID !== sessionId) continue;
       if (watcher.reportedQuestions.has(q.id)) continue;
-      if (!await this.sessionBelongsTo(q.sessionID, sessionId)) continue;
       const paused = this.attributeInteraction(watcher, q.tool?.messageID, messages);
       const reported = await this.reportInteraction(
         watcher.conv.id,
@@ -2973,8 +2807,8 @@ var ChannelDriver = class {
     } catch {
     }
     for (const p of permissions) {
+      if (p.sessionID !== sessionId) continue;
       if (watcher.reportedPermissions.has(p.id)) continue;
-      if (!await this.sessionBelongsTo(p.sessionID, sessionId)) continue;
       const paused = this.attributeInteraction(watcher, p.messageID, messages);
       const reported = await this.reportInteraction(
         watcher.conv.id,
@@ -2985,50 +2819,6 @@ var ChannelDriver = class {
       if (reported) watcher.reportedPermissions.add(p.id);
     }
   }
-  /**
-   * True when `sessionId` is the `rootSessionId` itself OR a descendant of it —
-   * i.e. its `parentID` chain (resolved via `GET /session/:id`) reaches the
-   * watched root. Sub-agents spawned via the `task` tool run in child sessions,
-   * so their questions/permissions live under a different `sessionID` that must
-   * still be attributed to the root conversation the watcher owns.
-   *
-   * Parents are cached in `sessionParents` so we walk each session at most once;
-   * a bounded depth cap guards against a cycle or a pathological chain, and any
-   * fetch failure is treated as "not a descendant" (best-effort — the interaction
-   * simply isn't surfaced this tick and is retried next tick once resolvable).
-   */
-  async sessionBelongsTo(sessionId, rootSessionId) {
-    let current = sessionId;
-    for (let depth = 0; current && depth < 32; depth++) {
-      if (current === rootSessionId) return true;
-      const parent = await this.resolveSessionParent(current);
-      if (parent === null || parent === void 0) return false;
-      current = parent;
-    }
-    return false;
-  }
-  /**
-   * Resolve (and cache) a session's `parentID` via `GET /session/:id`. Returns
-   * `null` for a root session (no parent) and `undefined` when opencode is
-   * unreachable / the session can't be read (so the caller stops walking without
-   * caching a wrong answer — the next tick retries).
-   */
-  async resolveSessionParent(sessionId) {
-    const cached = this.sessionParents.get(sessionId);
-    if (cached !== void 0) return cached;
-    let parent = void 0;
-    try {
-      const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}`);
-      if (res.ok) {
-        const body = await res.json();
-        parent = body && typeof body.parentID === "string" ? body.parentID : null;
-      }
-    } catch {
-      parent = void 0;
-    }
-    if (parent !== void 0) this.sessionParents.set(sessionId, parent);
-    return parent;
-  }
   /**
    * Attribute a surfaced interaction to the in-flight message it paused on (M-1).
    *
@@ -3558,25 +3348,6 @@ async function resolveAgentIdFromKey(authHeader) {
     return { error: `Failed to resolve agent from key: ${message}` };
   }
 }
-async function notifyAgentDisconnected(agentId, authHeader) {
-  const apiUrl = getApiUrlConfig();
-  try {
-    const response = await fetch(`${apiUrl}/agents/${agentId}/disconnect`, {
-      method: "POST",
-      headers: { Authorization: authHeader }
-    });
-    if (!response.ok) {
-      const serverMessage = await readErrorMessage(response);
-      return {
-        ok: false,
-        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
-      };
-    }
-    return { ok: true };
-  } catch (error2) {
-    return { ok: false, error: error2 instanceof Error ? error2.message : String(error2) };
-  }
-}
 async function getAgentInfo(agentId, authHeader) {
   const apiUrl = getApiUrlConfig();
   try {
@@ -3623,7 +3394,7 @@ 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 SHUTDOWN_DRAIN_TIMEOUT_MS = Number(process.env.EVIDENT_SHUTDOWN_DRAIN_MS) || 25e3;
+var CHANNEL_SETTLE_MS = Number(process.env.EVIDENT_SETTLE_MS) || void 0;
 function log2(state, message, isError = false) {
   if (state.json) {
     console.log(
@@ -3778,7 +3549,7 @@ async function driveChannels(state, driver) {
       logActivity(state, { type: "error", error: `Channel processing error: ${errorMessage}` });
       if (state.interactive) displayStatus(state);
     }
-    await new Promise((resolve2) => setTimeout(resolve2, CHANNEL_POLL_INTERVAL_MS));
+    await new Promise((resolve) => setTimeout(resolve, CHANNEL_POLL_INTERVAL_MS));
     if (state.idleTimeout !== null && idlePolls >= 2) {
       const idleMs = idlePolls * CHANNEL_POLL_INTERVAL_MS;
       if (idleMs > state.idleTimeout * 1e3) {
@@ -3789,122 +3560,8 @@ async function driveChannels(state, driver) {
     }
   }
 }
-var SESSION_CLEANUP_FIRST_SWEEP_MS = 1e4;
-async function runSweep(state, driver, config2) {
-  const mode = `age=${config2.maxAgeMs ?? "\u2014"} count=${config2.maxCount ?? "\u2014"}`;
-  try {
-    const sessions = await listSessions(state.port);
-    if (sessions === null) {
-      logActivity(state, {
-        type: "info",
-        message: `Session cleanup: could not list sessions (opencode unreachable); skipping this sweep (${mode})`
-      });
-      return;
-    }
-    const toDelete = selectSessionsToDelete(
-      sessions.map((s) => ({ id: s.id, lastActivityMs: sessionLastActivityMs(s) })),
-      {
-        maxAgeMs: config2.maxAgeMs,
-        maxCount: config2.maxCount,
-        nowMs: Date.now(),
-        protectedIds: driver.protectedSessionIds()
-      }
-    );
-    const protectedNow = driver.protectedSessionIds();
-    let deleted = 0;
-    let failed = 0;
-    let skippedNewlyActive = 0;
-    for (const id of toDelete) {
-      if (protectedNow.has(id)) {
-        skippedNewlyActive++;
-        logActivity(state, {
-          type: "info",
-          message: `Session cleanup: skipping ${id} \u2014 became active/bound after selection (${mode})`
-        });
-        continue;
-      }
-      if (await deleteSession(state.port, id)) deleted++;
-      else failed++;
-    }
-    const failedNote = failed > 0 ? `, failed ${failed}` : "";
-    const skippedNote = skippedNewlyActive > 0 ? `, skipped ${skippedNewlyActive} newly-active` : "";
-    logActivity(state, {
-      type: "info",
-      message: `Session cleanup: inspected ${sessions.length}, deleted ${deleted}${failedNote}${skippedNote} (${mode})`
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    logActivity(state, {
-      type: "error",
-      error: `Session cleanup sweep failed (non-fatal, ${mode}): ${message}`
-    });
-  }
-}
-function scheduleSessionCleanup(state, driver, options) {
-  const config2 = resolveSessionCleanupConfig(
-    {
-      maxAge: options.sessionCleanupMaxAge,
-      maxCount: options.sessionCleanupMaxCount,
-      interval: options.sessionCleanupInterval
-    },
-    process.env
-  );
-  for (const warning2 of config2.warnings) {
-    logActivity(state, { type: "info", message: `Session cleanup: ${warning2}` });
-  }
-  if (!config2.enabled) return;
-  logActivity(state, {
-    type: "info",
-    message: `Session cleanup enabled (age=${config2.maxAgeMs ?? "\u2014"}, count=${config2.maxCount ?? "\u2014"}, interval=${config2.intervalMs}ms)`
-  });
-  const interval = setInterval(() => void runSweep(state, driver, config2), config2.intervalMs);
-  const firstSweep = setTimeout(
-    () => void runSweep(state, driver, config2),
-    SESSION_CLEANUP_FIRST_SWEEP_MS
-  );
-  state.sessionCleanupTimers.push(interval, firstSweep);
-}
-async function notifyOffline(state) {
-  if (!state.agentId || !state.authHeader) return;
-  if (!state.connected) {
-    log2(state, "Skipping offline signal \u2014 this runner does not hold the live tunnel");
-    return;
-  }
-  const result = await notifyAgentDisconnected(state.agentId, state.authHeader);
-  if (result.ok) {
-    log2(state, "Notified Evident the agent is going offline");
-  } else {
-    logActivity(state, {
-      type: "error",
-      error: `Could not notify Evident of offline status (relay will still report it): ${result.error}`
-    });
-    if (state.interactive) displayStatus(state);
-  }
-}
-async function cleanup(state, opts = {}) {
+async function cleanup(state) {
   state.running = false;
-  for (const timer of state.sessionCleanupTimers) {
-    clearInterval(timer);
-    clearTimeout(timer);
-  }
-  state.sessionCleanupTimers = [];
-  if (opts.graceful && state.channelDriver) {
-    state.channelDriver.stop();
-    log2(state, "Draining in-flight channel work before shutdown...");
-    if (state.interactive) {
-      logActivity(state, { type: "info", message: "Draining in-flight work before shutdown..." });
-      displayStatus(state);
-    }
-    const settled = await state.channelDriver.waitForInFlight(SHUTDOWN_DRAIN_TIMEOUT_MS);
-    if (!settled) {
-      logActivity(state, {
-        type: "info",
-        message: "Shutdown drain timed out with work still in flight \u2014 leaving it for restart recovery"
-      });
-      if (state.interactive) displayStatus(state);
-    }
-  }
-  await notifyOffline(state);
   if (state.connection) {
     state.connection.close();
     state.connection = null;
@@ -3935,13 +3592,10 @@ async function run(options) {
     opencodeVersion: null,
     opencodeProcess: null,
     connection: null,
-    channelDriver: null,
     running: true,
-    shuttingDown: false,
     activityLog: [],
     messageCount: 0,
     lastProxiedActivityAt: null,
-    sessionCleanupTimers: [],
     authHeader: ""
   };
   if (state.idleTimeout === null && (process.env.GITHUB_ACTIONS || process.env.CI)) {
@@ -3952,15 +3606,13 @@ async function run(options) {
     );
   }
   const handleSignal = async () => {
-    if (state.shuttingDown) return;
-    state.shuttingDown = true;
     if (state.interactive) {
       logActivity(state, { type: "info", message: "Shutting down..." });
       displayStatus(state);
     } else {
       log2(state, "Shutting down...");
     }
-    await cleanup(state, { graceful: true });
+    await cleanup(state);
     await shutdownTelemetry();
     process.exit(0);
   };
@@ -4081,13 +3733,13 @@ 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,
         error: entry.level === "error" ? entry.message : void 0
       })
     });
-    state.channelDriver = channelDriver;
     const connection = new RunnerConnection({
       agentId: state.agentId,
       getAuthHeader: () => state.authHeader,
@@ -4184,12 +3836,10 @@ async function run(options) {
       if (error2.message === "Unauthorized") tunnelSpinner?.fail("Unauthorized");
       throw error2;
     }
-    scheduleSessionCleanup(state, channelDriver, options);
     if (!interactive || state.json) {
       log2(state, "Driving channel messages...");
     }
     await driveChannels(state, channelDriver);
-    if (state.shuttingDown) return;
     await cleanup(state);
     if (state.json) {
       console.log(
@@ -4204,7 +3854,6 @@ async function run(options) {
     await shutdownTelemetry();
     process.exit(0);
   } catch (error2) {
-    if (state.shuttingDown) return;
     await cleanup(state);
     const message = error2 instanceof Error ? error2.message : String(error2);
     if (state.json) {
@@ -4239,16 +3888,7 @@ program.name("evident").description("Run OpenCode locally and connect it to Evid
 program.command("login").description("Authenticate with Evident").option("--token", "Use token-based authentication (for CI/CD)").option("--no-browser", "Do not open the browser automatically").action(login);
 program.command("logout").description("Remove stored credentials for the current endpoint").option("--all", "Remove stored credentials for all endpoints").action((options) => logout({ all: options.all }));
 program.command("whoami").description("Show the currently logged in user").action(whoami);
-program.command("run").description("Connect to Evident and process messages").option("-a, --agent [id]", "Agent ID to connect to (optional when EVIDENT_AGENT_KEY is set)").option("-p, --port <port>", "OpenCode port (default: 4096)", "4096").option("-v, --verbose", "Show detailed request/response information").option("-c, --conversation <id>", "Process only this specific conversation").option("--idle-timeout <seconds>", "Exit after N seconds idle").option("--json", "Output in JSON format").option(
-  "--session-cleanup-max-age <duration>",
-  "Delete OpenCode sessions idle longer than this (e.g. 7d, 24h). Enables cleanup. Env: EVIDENT_SESSION_CLEANUP_MAX_AGE"
-).option(
-  "--session-cleanup-max-count <n>",
-  "Keep only the newest N OpenCode sessions. Enables cleanup. Env: EVIDENT_SESSION_CLEANUP_MAX_COUNT"
-).option(
-  "--session-cleanup-interval <duration>",
-  "How often the cleanup sweep runs (default: 1h). Env: EVIDENT_SESSION_CLEANUP_INTERVAL"
-).action(
+program.command("run").description("Connect to Evident and process messages").option("-a, --agent [id]", "Agent ID to connect to (optional when EVIDENT_AGENT_KEY is set)").option("-p, --port <port>", "OpenCode port (default: 4096)", "4096").option("-v, --verbose", "Show detailed request/response information").option("-c, --conversation <id>", "Process only this specific conversation").option("--idle-timeout <seconds>", "Exit after N seconds idle").option("--json", "Output in JSON format").action(
   (options) => {
     run({
       agent: options.agent,
@@ -4256,11 +3896,7 @@ program.command("run").description("Connect to Evident and process messages").op
       verbose: options.verbose,
       conversation: options.conversation,
       idleTimeout: options.idleTimeout ? parseInt(options.idleTimeout, 10) : void 0,
-      json: options.json,
-      // Raw strings — the resolver in run.ts single-sources parsing (M1).
-      sessionCleanupMaxAge: options.sessionCleanupMaxAge,
-      sessionCleanupMaxCount: options.sessionCleanupMaxCount,
-      sessionCleanupInterval: options.sessionCleanupInterval
+      json: options.json
     });
   }
 );