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

package/dist/index.js

@@ -285,14 +285,14 @@ function blank() {
   console.log();
 }
 function waitForEnter(prompt = "Press Enter to continue...") {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     process.stdout.write(chalk.dim(prompt));
     const handler = () => {
       process.stdin.removeListener("data", handler);
       process.stdin.setRawMode?.(false);
       process.stdin.pause();
       console.log();
-      resolve();
+      resolve2();
     };
     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((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, 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((resolve) => {
+  const token = await new Promise((resolve2) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve(data.trim());
+      resolve2(data.trim());
     });
     if (process.stdin.isTTY) {
       process.stdin.once("data", (chunk) => {
         process.stdin.pause();
-        resolve(chunk.toString().trim());
+        resolve2(chunk.toString().trim());
       });
       process.stdin.resume();
     }
@@ -706,7 +706,7 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
     if (health.healthy) {
       return health;
     }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
   }
   return { healthy: false, error: "Timeout waiting for OpenCode to be healthy" };
 }
@@ -1078,6 +1078,84 @@ async function getSessionMessages(port, sessionId) {
     return null;
   }
 }
+function isSessionActivelyGenerating(messages) {
+  if (!messages || messages.length === 0) return false;
+  const last = messages[messages.length - 1];
+  if (roleOf(last) !== "assistant") return false;
+  return completedOf(last) == null;
+}
+function 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 getSessionStatuses(port) {
+  try {
+    const res = await fetch(`${opencodeBase(port)}/session/status`);
+    if (!res.ok) {
+      console.error(
+        `[getSessionStatuses] GET /session/status returned HTTP ${res.status} (port ${port})`
+      );
+      return null;
+    }
+    const body = await res.json();
+    if (body == null || typeof body !== "object" || Array.isArray(body)) {
+      console.error(
+        `[getSessionStatuses] GET /session/status body was not a plain object (port ${port})`
+      );
+      return null;
+    }
+    return body;
+  } catch (err) {
+    console.error(
+      `[getSessionStatuses] GET /session/status failed (port ${port}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+async function isSessionOngoing(port, id) {
+  const map = await getSessionStatuses(port);
+  if (map == null) return null;
+  const entry = map[id];
+  return entry != null && entry.type !== "idle";
+}
 async function createOpenCodeSession(port, directory) {
   const url = new URL(`${opencodeBase(port)}/session`);
   if (directory && directory.trim()) {
@@ -1147,7 +1225,7 @@ async function sendPromptAsync(port, sessionId, content, options) {
       if (best) return best.id;
     }
     if (attempt < READ_BACK_ATTEMPTS - 1) {
-      await new Promise((resolve) => setTimeout(resolve, READ_BACK_DELAY_MS));
+      await new Promise((resolve2) => setTimeout(resolve2, READ_BACK_DELAY_MS));
     }
   }
   return null;
@@ -1204,6 +1282,11 @@ function messageRunState(messages, userMessageId) {
   if (isAssistantInFlight(reply)) return "running";
   return errorOf(reply) != null ? "failed" : "done";
 }
+function isPreamblePinnedRunning(messages, userMessageId) {
+  if (messageRunState(messages, userMessageId) !== "running") return false;
+  const reply = findLastAssistantReplyFor(messages, userMessageId);
+  return completedOf(reply) != null && finishOf(reply) === "tool-calls";
+}
 function messageError(messages, userMessageId) {
   const reply = findLastAssistantReplyFor(messages, userMessageId);
   const error2 = errorOf(reply);
@@ -1224,6 +1307,110 @@ function hasRunningAssistantExcept(messages, exceptUserMessageId) {
   );
 }
 
+// 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);
+    }
+  }
+  return toDelete;
+}
+var DEFAULT_INTERVAL = "1h";
+function resolve(flag, envValue, fallback) {
+  return flag ?? envValue ?? fallback;
+}
+function parseMaxCount(input) {
+  const trimmed = input.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`Invalid max-count "${input}": expected a positive integer.`);
+  }
+  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 };
+}
+
 // src/lib/tunnel/connection.ts
 import WebSocket2 from "ws";
 
@@ -1314,12 +1501,12 @@ var StreamForwarder = class {
     let endBody;
     if (has_body) {
       const chunks = [];
-      bodyPromise = new Promise((resolve) => {
+      bodyPromise = new Promise((resolve2) => {
         pushBody = (buf) => {
           chunks.push(buf);
         };
         endBody = () => {
-          resolve(Buffer.concat(chunks));
+          resolve2(Buffer.concat(chunks));
         };
       });
     }
@@ -1437,7 +1624,7 @@ function connectTunnel(options) {
   } = options;
   const tunnelUrl = getTunnelUrlConfig();
   const url = `${tunnelUrl}/tunnel/${agentId}/connect`;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const ws = new WebSocket2(url, {
       headers: {
         Authorization: authHeader
@@ -1502,7 +1689,7 @@ function connectTunnel(options) {
           clearTimeout(connectionTimeout);
           const connectedAgentId = message.agent_id ?? agentId;
           onConnected?.(connectedAgentId);
-          resolve({
+          resolve2({
             ws,
             close: () => ws.close(1e3, "CLI shutdown")
           });
@@ -1632,6 +1819,9 @@ var DEFAULT_RETRY_POLICY = {
 var DEFAULT_PAUSED_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_PAUSED_MAX_WAIT_MS = 10 * 60 * 1e3;
 var DEFAULT_STUCK_QUEUED_MS = 6e4;
+var HEARTBEAT_MS = 6e4;
+var ABSOLUTE_MAX_PROCESSING_MS = 6 * 60 * 60 * 1e3;
+var POLL_MISS_GRACE_MS = HEARTBEAT_MS;
 var ChannelAuthError = class extends Error {
   constructor(message) {
     super(message);
@@ -1749,8 +1939,33 @@ 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;
@@ -1782,8 +1997,21 @@ 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();
@@ -1795,6 +2023,7 @@ var ChannelDriver = class {
         });
       }
       for (const conv of conversations) {
+        if (this.stopped) break;
         dispatched += await this.processConversation(conv);
       }
       await this.readoptProcessing();
@@ -1815,6 +2044,73 @@ 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).
    *
@@ -1851,6 +2147,7 @@ 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;
@@ -1874,6 +2171,16 @@ var ChannelDriver = class {
       } 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({
@@ -1909,16 +2216,33 @@ var ChannelDriver = class {
     return dispatched;
   }
   async ensureSession(conv) {
-    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;
+    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;
     }
+    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(conv.id, sessionId);
-    await this.persistSession(conv.id, sessionId).catch(() => {
+    this.sessions.set(conversationId, sessionId);
+    await this.persistSession(conversationId, sessionId).catch(() => {
     });
     return sessionId;
   }
@@ -1969,7 +2293,9 @@ var ChannelDriver = class {
         inFlight: /* @__PURE__ */ new Map(),
         loop: null,
         reportedQuestions: /* @__PURE__ */ new Set(),
-        reportedPermissions: /* @__PURE__ */ new Set()
+        reportedPermissions: /* @__PURE__ */ new Set(),
+        lastGoodPollAt: this.now(),
+        hadUsablePoll: false
       };
       this.watchers.set(sessionId, watcher);
     }
@@ -1979,20 +2305,37 @@ var ChannelDriver = class {
       opencodeMessageId,
       message,
       dispatchedAt: now,
+      processingAnchorMs: now,
       deadline: now + this.pausedMaxWaitMs,
       started: false,
       done: false,
-      stuckReported: false
+      stuckReported: false,
+      lastAliveAt: 0,
+      aliveInFlight: false,
+      awaitingHumanLatched: false,
+      pausedOnQuestion: false,
+      pausedOnPermission: false,
+      pausedClearConfirmed: false,
+      pausedInFlight: false,
+      deliveryDeadlineAnchored: false
     });
   }
   /**
    * Register a RE-ADOPTED `processing` message with its session watcher
    * (ADR-0046, WI-4). Mirrors `registerInFlight` but anchors the give-up
    * `deadline` to the row's SERVER-SIDE `processed_at` (Invariant 1), NEVER to
-   * `now`: a row already `processing` for e.g. 5 min must give up ~5 min from now
-   * (10 min after `processed_at`), not 10 min from now — otherwise its deadline
-   * lands ~15 min after `processed_at`, coinciding with the cron reset →
-   * double-drive race. `dispatchedAt` stays `now` (only the appear-guard uses it).
+   * `now`, so the paused/queued/unreachable cases settle on the same wall-clock a
+   * fresh dispatch would (10 min after `processed_at`, not 10 min from now).
+   *
+   * This re-attaches into the SAME watcher, so the ADR-0047 progressing-vs-paused
+   * give-up (`serviceInFlightMessage`) applies unchanged: a re-adopted turn
+   * opencode reports ACTIVELY `running` is watched to completion (its liveness
+   * heartbeat keeps the cron off its row), while a re-adopted turn that is paused
+   * awaiting a human — or queued/unreachable — is still bounded by `deadline` and
+   * handed to the cron. The old "the `deadline` must settle before the ~15-min
+   * cron or they double-drive" reasoning is superseded: liveness now settles the
+   * actively-running case; `deadline` settles the rest. `dispatchedAt` stays `now`
+   * (only the appear-guard uses it).
    *
    * `evidentMessageId` addresses the SERVER row (for markProcessing/markDone);
    * `opencodeMessageId` is the id the watcher polls for a reply — for the orphan
@@ -2010,7 +2353,9 @@ var ChannelDriver = class {
         inFlight: /* @__PURE__ */ new Map(),
         loop: null,
         reportedQuestions: /* @__PURE__ */ new Set(),
-        reportedPermissions: /* @__PURE__ */ new Set()
+        reportedPermissions: /* @__PURE__ */ new Set(),
+        lastGoodPollAt: this.now(),
+        hadUsablePoll: false
       };
       this.watchers.set(sessionId, watcher);
     }
@@ -2019,6 +2364,10 @@ var ChannelDriver = class {
       opencodeMessageId,
       message,
       dispatchedAt: this.now(),
+      // Anchor the absolute-age ceiling to the SERVER-SIDE `processed_at` (the same
+      // value seeding `deadline`), NOT `dispatchedAt` — so a re-adopted zombie's age
+      // reflects the real turn duration and the ceiling fires on the ORIGINAL turn.
+      processingAnchorMs: processedAtMs,
       deadline: processedAtMs + this.pausedMaxWaitMs,
       // The server row is ALREADY `processing`; do not re-fire markProcessing.
       started: true,
@@ -2028,7 +2377,20 @@ var ChannelDriver = class {
       // 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
+      stuckReported: false,
+      // Task 5.2: a re-adopted actively-running row re-attaches into the SAME
+      // watcher and so hits the SAME actively-running heartbeat branch in
+      // `serviceInFlightMessage` as a fresh dispatch — monitoring observes "runner
+      // re-adopted and is confirming this row alive" via that `alive` heartbeat,
+      // with no extra `re_adopted` signal needed (folds old WI-6).
+      lastAliveAt: 0,
+      aliveInFlight: false,
+      awaitingHumanLatched: false,
+      pausedOnQuestion: false,
+      pausedOnPermission: false,
+      pausedClearConfirmed: false,
+      pausedInFlight: false,
+      deliveryDeadlineAnchored: false
     });
   }
   /**
@@ -2079,12 +2441,30 @@ var ChannelDriver = class {
             messages = Array.isArray(body) ? body : null;
           }
         } catch {
-          continue;
         }
+        if (messages != null && messages.length > 0) {
+          watcher.lastGoodPollAt = this.now();
+          watcher.hadUsablePoll = true;
+        } else {
+          const emptyButReachable = messages != null;
+          const graceApplies = !emptyButReachable || watcher.hadUsablePoll;
+          if (graceApplies && this.now() - watcher.lastGoodPollAt < POLL_MISS_GRACE_MS) {
+            continue;
+          }
+        }
+        const { openQuestions, openPermissions, questionsPolledOk, permissionsPolledOk } = await this.pollInteractions(sessionId, watcher, messages);
         for (const inFlight of [...watcher.inFlight.values()]) {
-          await this.serviceInFlightMessage(sessionId, watcher, inFlight, messages);
+          await this.serviceInFlightMessage(
+            sessionId,
+            watcher,
+            inFlight,
+            messages,
+            openQuestions,
+            openPermissions,
+            questionsPolledOk,
+            permissionsPolledOk
+          );
         }
-        await this.pollInteractions(sessionId, watcher, messages);
       }
     } catch (err) {
       if (err instanceof ChannelAuthError) {
@@ -2106,15 +2486,40 @@ var ChannelDriver = class {
       });
     }
   }
+  /**
+   * On FIRST observing a terminal (done/failed) state, ensure the delivery
+   * (markDone/markFailed) transient-retry path has a real window. A long
+   * ACTIVELY-running turn is kept past its original `deadline`, so by completion
+   * `now >= deadline` already holds and the retry bound below would fire on the
+   * first transient PATCH failure — dropping the message before its reply lands
+   * (Bugbot "Stale deadline aborts long-turn delivery"). Re-anchor once (latched)
+   * to a fresh `pausedMaxWaitMs` window; only extend if the current deadline is at
+   * or past now, so a still-ample window is left untouched.
+   */
+  anchorDeliveryDeadline(inFlight) {
+    if (inFlight.deliveryDeadlineAnchored) return;
+    inFlight.deliveryDeadlineAnchored = true;
+    if (this.now() >= inFlight.deadline) {
+      inFlight.deadline = this.now() + this.pausedMaxWaitMs;
+    }
+  }
   /**
    * Drive ONE in-flight message's lifecycle from the tick's message snapshot.
    * Fires markProcessing on queued→running and markDone on done (each once),
    * applies the idle-path re-dispatch guard, and removes the message from the
    * in-flight set on completion or timeout.
    */
-  async serviceInFlightMessage(sessionId, watcher, inFlight, messages) {
+  async serviceInFlightMessage(sessionId, watcher, inFlight, messages, openQuestions, openPermissions, questionsPolledOk, permissionsPolledOk) {
     const conv = watcher.conv;
     const state = messageRunState(messages, inFlight.opencodeMessageId);
+    const id = inFlight.evidentMessageId;
+    if (openQuestions.has(id)) inFlight.pausedOnQuestion = true;
+    else if (questionsPolledOk) inFlight.pausedOnQuestion = false;
+    if (openPermissions.has(id)) inFlight.pausedOnPermission = true;
+    else if (permissionsPolledOk) inFlight.pausedOnPermission = false;
+    const observedOpen = openQuestions.has(id) || openPermissions.has(id);
+    const latchedPaused = inFlight.pausedOnQuestion || inFlight.pausedOnPermission;
+    const awaitingHuman = observedOpen || latchedPaused;
     if ((state === "running" || state === "done" || state === "failed") && !inFlight.started) {
       let claimed;
       try {
@@ -2145,6 +2550,7 @@ var ChannelDriver = class {
       }
     }
     if (state === "done") {
+      this.anchorDeliveryDeadline(inFlight);
       if (!inFlight.done) {
         this.log({
           level: "info",
@@ -2195,6 +2601,7 @@ var ChannelDriver = class {
       return;
     }
     if (state === "failed") {
+      this.anchorDeliveryDeadline(inFlight);
       if (!inFlight.done) {
         const error2 = messageError(messages, inFlight.opencodeMessageId) ?? void 0;
         this.log({
@@ -2248,7 +2655,51 @@ var ChannelDriver = class {
         stuck_for_ms: this.now() - inFlight.dispatchedAt
       });
     }
-    if (this.now() >= inFlight.deadline) {
+    const activelyRunning = state === "running" && !awaitingHuman;
+    if (activelyRunning && this.now() - inFlight.processingAnchorMs >= ABSOLUTE_MAX_PROCESSING_MS) {
+      this.log({
+        level: "error",
+        message: `Message ${inFlight.evidentMessageId.slice(0, 8)} exceeded the absolute processing ceiling (${Math.round((this.now() - inFlight.processingAnchorMs) / 6e4)}min, session ${sessionId}) while still actively running \u2014 releasing so the cron can reclaim it`,
+        conversation_id: conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      void this.postSignal(conv.id, inFlight.evidentMessageId, "gave_up", {
+        watched_for_ms: this.now() - inFlight.processingAnchorMs
+      });
+      this.removeInFlight(watcher, inFlight.evidentMessageId);
+      return;
+    }
+    if (activelyRunning && !inFlight.awaitingHumanLatched && !inFlight.aliveInFlight && this.now() - inFlight.lastAliveAt >= HEARTBEAT_MS) {
+      inFlight.aliveInFlight = true;
+      void this.postSignal(conv.id, inFlight.evidentMessageId, "alive").then((ok) => {
+        inFlight.aliveInFlight = false;
+        if (ok) inFlight.lastAliveAt = this.now();
+      });
+    }
+    if (awaitingHuman) {
+      if (!inFlight.awaitingHumanLatched) {
+        inFlight.deadline = this.now() + this.pausedMaxWaitMs;
+        inFlight.awaitingHumanLatched = true;
+      }
+      if (!inFlight.pausedClearConfirmed && !inFlight.pausedInFlight) {
+        inFlight.pausedInFlight = true;
+        void this.postSignal(conv.id, inFlight.evidentMessageId, "paused").then((ok) => {
+          inFlight.pausedInFlight = false;
+          if (ok && inFlight.awaitingHumanLatched) inFlight.pausedClearConfirmed = true;
+        });
+      }
+    } else if (inFlight.awaitingHumanLatched) {
+      inFlight.awaitingHumanLatched = false;
+      inFlight.pausedOnQuestion = false;
+      inFlight.pausedOnPermission = false;
+      inFlight.pausedClearConfirmed = false;
+    }
+    const siblingPaused = (sib) => openQuestions.has(sib.evidentMessageId) || openPermissions.has(sib.evidentMessageId) || sib.awaitingHumanLatched || sib.pausedOnQuestion || sib.pausedOnPermission;
+    const hasActivelyRunningSibling = [...watcher.inFlight.values()].some(
+      (sib) => sib.evidentMessageId !== inFlight.evidentMessageId && messageRunState(messages, sib.opencodeMessageId) === "running" && !siblingPaused(sib)
+    );
+    const queuedBehindRunningSibling = state === "queued" && hasActivelyRunningSibling;
+    if (!activelyRunning && !queuedBehindRunningSibling && this.now() >= inFlight.deadline) {
       this.log({
         level: "info",
         message: `Message ${inFlight.evidentMessageId.slice(0, 8)} did not complete within the watch window \u2014 leaving for the cron safety net`,
@@ -2339,8 +2790,10 @@ var ChannelDriver = class {
         });
         continue;
       }
+      const anyUntracked = sessionRows.some((row) => !this.isTracked(sessionId, row.id));
+      const sessionOngoing = anyUntracked ? await isSessionOngoing(this.port, sessionId) : null;
       for (const row of sessionRows) {
-        await this.readoptOne(sessionId, row, messages);
+        await this.readoptOne(sessionId, row, messages, sessionOngoing);
       }
     }
   }
@@ -2362,7 +2815,7 @@ var ChannelDriver = class {
    *
    * Only `ChannelAuthError` propagates.
    */
-  async readoptOne(sessionId, row, messages) {
+  async readoptOne(sessionId, row, messages, sessionOngoing) {
     if (this.isTracked(sessionId, row.id)) {
       this.log({
         level: "info",
@@ -2457,6 +2910,67 @@ var ChannelDriver = class {
       });
       return;
     }
+    let statusReadableOngoing = null;
+    if (state === "running" && ocId) {
+      const reply = findLastAssistantReplyFor(messages, ocId);
+      const shape = this.replyCompletionShape(reply);
+      const ongoing = sessionOngoing;
+      statusReadableOngoing = ongoing;
+      if (ongoing === false) {
+        this.log({
+          level: "info",
+          message: `Re-adopt: message ${row.id.slice(0, 8)} running/${shape} but session ${sessionId.slice(0, 8)} is not-ongoing per GET /session/status (absent/idle) \u2014 re-dispatching from scratch (status-gated recovery)`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+        await this.forceReadoptRun(sessionId, row);
+        return;
+      }
+      if (ongoing === true) {
+        this.log({
+          level: "info",
+          message: `Re-adopt: message ${row.id.slice(0, 8)} running/${shape} and session ${sessionId.slice(0, 8)} is ongoing per GET /session/status (busy/retry) \u2014 re-attaching watcher (no re-dispatch)`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+      } else {
+        if (shape === "b1") {
+          this.log({
+            level: "info",
+            message: `Re-adopt: message ${row.id.slice(0, 8)} running/b1 but GET /session/status was unreadable (null) for session ${sessionId.slice(0, 8)} \u2014 NOT latching a b1 row on a transient status blip; leaving it un-tracked to re-evaluate on the next drain`,
+            conversation_id: row.conversation_id,
+            message_id: row.id
+          });
+          return;
+        }
+        this.log({
+          level: "info",
+          message: `Re-adopt: message ${row.id.slice(0, 8)} running/${shape} but GET /session/status was unreadable (null) for session ${sessionId.slice(0, 8)} \u2014 falling back to the #253 preamble + descendant cross-check`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+      }
+    }
+    if (statusReadableOngoing === null && state === "running" && ocId && isPreamblePinnedRunning(messages, ocId)) {
+      const descendantAlive = await this.isAnyDescendantSessionAlive(sessionId);
+      if (descendantAlive === true) {
+        this.log({
+          level: "info",
+          message: `Re-adopt: message ${row.id.slice(0, 8)} preamble-pinned running (root ${sessionId.slice(0, 8)}) but a live descendant sub-agent session was found \u2014 treating as still running, re-attaching watcher (no re-dispatch)`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+      } else {
+        this.log({
+          level: "info",
+          message: `Re-adopt: message ${row.id.slice(0, 8)} preamble-pinned on recovery (root ${sessionId.slice(0, 8)}), no live descendant runner \u2014 re-dispatching from scratch${descendantAlive === null ? " (descendant liveness indeterminate; a restart guarantees no live runner, so this does NOT block the re-dispatch)" : ""}`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+        await this.forceReadoptRun(sessionId, row);
+        return;
+      }
+    }
     if ((state === "running" || state === "queued") && ocId) {
       const conv = this.convForRow(sessionId, row);
       const message = this.queuedMessageForRow(row);
@@ -2496,6 +3010,15 @@ var ChannelDriver = class {
    * `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",
@@ -2651,21 +3174,41 @@ var ChannelDriver = class {
    * RUNNING (not done) is the one that paused. With one running message that is
    * unambiguous; with several we prefer an explicit messageID match, else the
    * oldest running message.
+   *
+   * Returns the set of in-flight Evident message ids that are paused awaiting a
+   * human — an outstanding (still-open) question/permission is attributed to them.
+   * `serviceInFlightMessage` uses this to keep an actively-running turn watched
+   * forever (ADR-0047) while still bounding a turn merely blocked on a person who
+   * may never answer. Attribution here covers ALL open interactions, not just
+   * NEW (un-deduped) ones — a question stays "awaiting a human" until answered,
+   * even after it was already surfaced to the channel.
    */
   async pollInteractions(sessionId, watcher, messages) {
+    const openQuestions = /* @__PURE__ */ new Set();
+    const openPermissions = /* @__PURE__ */ new Set();
+    let questionsPolledOk = true;
+    let permissionsPolledOk = true;
     let questions = [];
     try {
       const res = await this.fetchImpl(`${this.opencodeBase}/question`);
       if (res.ok) {
         const body = await res.json();
-        questions = Array.isArray(body) ? body : [];
+        if (Array.isArray(body)) {
+          questions = body;
+        } else {
+          questionsPolledOk = false;
+        }
+      } else {
+        questionsPolledOk = false;
       }
     } catch {
+      questionsPolledOk = false;
     }
     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);
+      if (paused) openQuestions.add(paused.evidentMessageId);
+      if (watcher.reportedQuestions.has(q.id)) continue;
       const reported = await this.reportInteraction(
         watcher.conv.id,
         "question",
@@ -2679,14 +3222,22 @@ var ChannelDriver = class {
       const res = await this.fetchImpl(`${this.opencodeBase}/permission`);
       if (res.ok) {
         const body = await res.json();
-        permissions = Array.isArray(body) ? body : [];
+        if (Array.isArray(body)) {
+          permissions = body;
+        } else {
+          permissionsPolledOk = false;
+        }
+      } else {
+        permissionsPolledOk = false;
       }
     } catch {
+      permissionsPolledOk = false;
     }
     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);
+      if (paused) openPermissions.add(paused.evidentMessageId);
+      if (watcher.reportedPermissions.has(p.id)) continue;
       const reported = await this.reportInteraction(
         watcher.conv.id,
         "permission",
@@ -2695,6 +3246,128 @@ var ChannelDriver = class {
       );
       if (reported) watcher.reportedPermissions.add(p.id);
     }
+    return { openQuestions, openPermissions, questionsPolledOk, permissionsPolledOk };
+  }
+  /**
+   * 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;
+  }
+  /**
+   * DEFENSIVE cross-check for the restart-recovery path (WI-2): is any descendant
+   * (`task` sub-agent) session under `rootSessionId` still genuinely doing work?
+   *
+   * The PRIMARY recovery trigger is "preamble-pinned on recovery ⇒ idle" — a
+   * runner restart wipes OpenCode's in-memory `SessionStatus`/`Runner`, so a
+   * completed `finish: "tool-calls"` root reply encountered during re-adoption is
+   * idle by OpenCode's own definition and is re-dispatched. This method exists only
+   * so the WI-3 caller can VETO that re-dispatch in the rare case a descendant is
+   * provably in flight at the exact moment of recovery.
+   *
+   * "Alive" criterion (TIGHTENED): a descendant is alive only when it is PROVABLY,
+   * ACTIVELY generating — its LAST message is an assistant still mid-generation
+   * (`completed == null`, via `isSessionActivelyGenerating`). An
+   * INCOMPLETE-BUT-NOT-GENERATING child — last message a user message, or a
+   * completed `finish: "tool-calls"` step — is NOT alive after a restart (nothing
+   * is generating once the runner is gone), so it does NOT veto. (This is
+   * deliberately NOT `!isTurnComplete`, which also matches those dead-but-non-terminal
+   * shapes and would falsely veto — re-hanging the very turn this path recovers.)
+   *
+   * Return contract (encoded so WI-3 need not re-derive it):
+   *  - `true`  → a descendant is provably, actively generating (veto re-dispatch).
+   *  - `false` → descendants exist but none is actively generating (the restart
+   *              case), OR no descendant is found at all.
+   *  - `null`  → liveness is INDETERMINATE (enumeration via `listSessions` failed).
+   *
+   * ⚠️ `null` (UNKNOWN) MUST NOT be treated as "alive": WI-3 treats `null` the same
+   * as `false` and does NOT veto — a restart guarantees no live runner, so an
+   * indeterminate cross-check almost always means "couldn't reach a child that no
+   * longer exists". The inversion lives in the caller; this method just reports
+   * true/false/null faithfully.
+   *
+   * VERIFY-BEFORE-DEPEND: we depend ONLY on (a) `parentID` from `GET /session/:id`
+   * (already proven by the existing child-session interaction tests, via
+   * `resolveSessionParent`/`sessionBelongsTo`) and (b) the child's own message-list
+   * terminal state. We do NOT depend on any session-level `busy`/`idle` field —
+   * there is none on `GET /session/:id`; OpenCode's busy state is in-memory
+   * `SessionStatus` only.
+   */
+  async isAnyDescendantSessionAlive(rootSessionId) {
+    const sessions = await listSessions(this.port);
+    if (!sessions) {
+      this.log({
+        level: "error",
+        message: `Re-adopt: could not enumerate sessions to cross-check descendant liveness for root ${rootSessionId} (listSessions failed) \u2014 treating child liveness as indeterminate`
+      });
+      return null;
+    }
+    for (const candidate of sessions) {
+      if (!candidate?.id || candidate.id === rootSessionId) continue;
+      if (!await this.sessionBelongsTo(candidate.id, rootSessionId)) continue;
+      const childMsgs = await getSessionMessages(this.port, candidate.id);
+      if (isSessionActivelyGenerating(childMsgs)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Cheap decision-telemetry label for a running row's LAST correlated reply
+   * (WI-2 Task 2.2): which running SHAPE it is, for the status-gated recovery log.
+   *   - `b1`    — the reply itself is still in flight (`time.completed == null`) —
+   *               the aborted-in-flight production bug after a restart.
+   *   - `b2`    — a COMPLETED reply pinned running only by `finish === "tool-calls"`
+   *               (the sub-agent preamble — #253's shape).
+   *   - `other` — any other shape (defensive; a running row is normally b1 or b2).
+   * Reads `info.time.completed` / `info.finish` (tolerating the legacy top-level
+   * shape) directly rather than re-importing the module-private `completedOf`/
+   * `finishOf` — this is a display label only, not a correctness predicate.
+   */
+  replyCompletionShape(reply) {
+    if (!reply) return "other";
+    const completed = reply.info?.time?.completed ?? reply.time?.completed;
+    if (completed == null) return "b1";
+    const finish = reply.info?.finish ?? reply.finish;
+    return finish === "tool-calls" ? "b2" : "other";
   }
   /**
    * Attribute a surfaced interaction to the in-flight message it paused on (M-1).
@@ -2927,6 +3600,12 @@ var ChannelDriver = class {
    * MUST NOT use `callWithRetry` (a telemetry ping must not block the sequential
    * watcher tick — one attempt is enough). A failure is SWALLOWED but LOGGED with
    * context (no silent catch, per development-workflow).
+   *
+   * Returns whether the POST SUCCEEDED (2xx). Most callers ignore this (pure
+   * telemetry), but the `paused` liveness-clear uses it to know whether to
+   * RE-ASSERT on a later tick — a single dropped `paused` POST must not leave a
+   * stale `last_seen_alive_at` on a still-paused row (Bugbot "Failed paused signal
+   * leaves liveness").
    */
   async postSignal(conversationId, messageId, signal, extra) {
     try {
@@ -2945,7 +3624,9 @@ var ChannelDriver = class {
           conversation_id: conversationId,
           message_id: messageId
         });
+        return false;
       }
+      return true;
     } catch (err) {
       this.log({
         level: "error",
@@ -2953,6 +3634,7 @@ var ChannelDriver = class {
         conversation_id: conversationId,
         message_id: messageId
       });
+      return false;
     }
   }
   async persistSession(conversationId, sessionId) {
@@ -3225,6 +3907,25 @@ 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 {
@@ -3271,6 +3972,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;
 function log2(state, message, isError = false) {
   if (state.json) {
     console.log(
@@ -3425,7 +4127,7 @@ async function driveChannels(state, driver) {
       logActivity(state, { type: "error", error: `Channel processing error: ${errorMessage}` });
       if (state.interactive) displayStatus(state);
     }
-    await new Promise((resolve) => setTimeout(resolve, CHANNEL_POLL_INTERVAL_MS));
+    await new Promise((resolve2) => setTimeout(resolve2, CHANNEL_POLL_INTERVAL_MS));
     if (state.idleTimeout !== null && idlePolls >= 2) {
       const idleMs = idlePolls * CHANNEL_POLL_INTERVAL_MS;
       if (idleMs > state.idleTimeout * 1e3) {
@@ -3436,8 +4138,122 @@ async function driveChannels(state, driver) {
     }
   }
 }
-async function cleanup(state) {
+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 = {}) {
   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;
@@ -3468,10 +4284,13 @@ 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)) {
@@ -3482,13 +4301,15 @@ 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);
+    await cleanup(state, { graceful: true });
     await shutdownTelemetry();
     process.exit(0);
   };
@@ -3615,6 +4436,7 @@ async function run(options) {
         error: entry.level === "error" ? entry.message : void 0
       })
     });
+    state.channelDriver = channelDriver;
     const connection = new RunnerConnection({
       agentId: state.agentId,
       getAuthHeader: () => state.authHeader,
@@ -3711,10 +4533,12 @@ 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(
@@ -3729,6 +4553,7 @@ 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) {
@@ -3763,7 +4588,16 @@ 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").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").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(
   (options) => {
     run({
       agent: options.agent,
@@ -3771,7 +4605,11 @@ 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
+      json: options.json,
+      // Raw strings — the resolver in run.ts single-sources parsing (M1).
+      sessionCleanupMaxAge: options.sessionCleanupMaxAge,
+      sessionCleanupMaxCount: options.sessionCleanupMaxCount,
+      sessionCleanupInterval: options.sessionCleanupInterval
     });
   }
 );