@evident-ai/cli 3.0.1-dev.39d9b5f → 3.0.1-dev.3bffad2

package/dist/index.js

@@ -1078,6 +1078,12 @@ 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,
@@ -1120,6 +1126,36 @@ async function sessionExists(port, id) {
     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()) {
@@ -1137,17 +1173,113 @@ async function createOpenCodeSession(port, directory) {
   const data = await response.json();
   return data.id;
 }
+async function getModelAttachmentCapability(port, model) {
+  try {
+    const res = await fetch(`${opencodeBase(port)}/config/providers`);
+    if (!res.ok) {
+      console.error(
+        `[getModelAttachmentCapability] GET /config/providers returned HTTP ${res.status} (port ${port})`
+      );
+      return null;
+    }
+    const body = await res.json();
+    const providers = Array.isArray(body?.providers) ? body.providers : null;
+    if (!providers) {
+      console.error(
+        `[getModelAttachmentCapability] GET /config/providers body had no providers array (port ${port})`
+      );
+      return null;
+    }
+    const slash = model ? model.indexOf("/") : -1;
+    const providerId = slash > 0 ? model.slice(0, slash) : void 0;
+    let modelId = slash > 0 ? model.slice(slash + 1) : void 0;
+    const defaults2 = body?.default && typeof body.default === "object" ? body.default : void 0;
+    let provider = providerId ? providers.find((p) => p?.id === providerId) : void 0;
+    if (!provider && !providerId) {
+      const defaultProviderIds = defaults2 ? Object.keys(defaults2) : [];
+      if (defaultProviderIds.length === 1) {
+        provider = providers.find((p) => p?.id === defaultProviderIds[0]);
+      }
+    }
+    if (!provider || !provider.models) return null;
+    if (!modelId && defaults2 && typeof provider.id === "string") {
+      const def = defaults2[provider.id];
+      if (typeof def === "string") modelId = def;
+    }
+    if (!modelId) {
+      if (providerId) {
+        const keys = Object.keys(provider.models);
+        if (keys.length === 1) modelId = keys[0];
+      }
+      if (!modelId) return null;
+    }
+    const entry = provider.models[modelId];
+    if (!entry || typeof entry !== "object") return null;
+    return typeof entry.attachment === "boolean" ? entry.attachment : null;
+  } catch (err) {
+    console.error(
+      `[getModelAttachmentCapability] GET /config/providers failed (port ${port}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+async function buildFileParts(attachments, capable) {
+  const outcomes = [];
+  const parts = [];
+  const capabilityUnknown = capable === null;
+  if (capable !== true) {
+    for (const a of attachments.inputs) {
+      outcomes.push({ index: a.index, mime: a.mime, filename: a.filename, status: "skipped" });
+    }
+    return { parts, outcomes, capabilityUnknown };
+  }
+  for (const a of attachments.inputs) {
+    let dataUrl = null;
+    try {
+      dataUrl = await attachments.fetchDataUrl(a.index);
+    } catch (err) {
+      console.error(
+        `[buildFileParts] attachment ${a.index} (${a.mime}) fetch threw \u2014 omitting: ${err instanceof Error ? err.message : String(err)}`
+      );
+      dataUrl = null;
+    }
+    if (dataUrl == null) {
+      outcomes.push({ index: a.index, mime: a.mime, filename: a.filename, status: "failed" });
+      continue;
+    }
+    parts.push({
+      type: "file",
+      mime: a.mime,
+      url: dataUrl,
+      ...a.filename ? { filename: a.filename } : {}
+    });
+    outcomes.push({ index: a.index, mime: a.mime, filename: a.filename, status: "sent" });
+  }
+  return { parts, outcomes, capabilityUnknown };
+}
 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) {
+async function sendPromptAsync(port, sessionId, content, options, attachments) {
   const before = await getSessionMessages(port, sessionId);
   const knownUserIds = new Set(
     (before ?? []).filter((m) => roleOf(m) === "user").map((m) => idOf(m)).filter((id) => typeof id === "string")
   );
+  const parts = [{ type: "text", text: content }];
+  let pendingOutcomes = null;
+  if (attachments && attachments.inputs.length > 0) {
+    const capable = await getModelAttachmentCapability(port, options?.model);
+    const {
+      parts: fileParts,
+      outcomes,
+      capabilityUnknown
+    } = await buildFileParts(attachments, capable);
+    parts.push(...fileParts);
+    if (attachments.onOutcomes) pendingOutcomes = { outcomes, capabilityUnknown };
+  }
   const body = {
-    parts: [{ type: "text", text: content }]
+    parts
   };
   if (options?.agent) {
     body.agent = options.agent;
@@ -1186,7 +1318,10 @@ async function sendPromptAsync(port, sessionId, content, options) {
           best = { id, created };
         }
       }
-      if (best) return best.id;
+      if (best) {
+        if (pendingOutcomes && attachments?.onOutcomes) attachments.onOutcomes(pendingOutcomes);
+        return best.id;
+      }
     }
     if (attempt < READ_BACK_ATTEMPTS - 1) {
       await new Promise((resolve2) => setTimeout(resolve2, READ_BACK_DELAY_MS));
@@ -1246,6 +1381,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);
@@ -1770,6 +1910,17 @@ function messageIdOf(m) {
   const infoId = m.info?.id;
   return typeof infoId === "string" ? infoId : void 0;
 }
+function cleanImageMime(contentType) {
+  if (!contentType) return null;
+  const media = contentType.split(";")[0].trim().toLowerCase();
+  return /^image\/[a-z0-9.+-]+$/.test(media) ? media : null;
+}
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
 var DEFAULT_RETRY_POLICY = {
   maxAttempts: 6,
   baseDelayMs: 500,
@@ -1779,6 +1930,7 @@ 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) {
@@ -1876,6 +2028,15 @@ var ChannelDriver = class {
    * the row leaves the processing list, exactly like `dontRedispatch`.
    */
   doneUndeliverable = /* @__PURE__ */ new Set();
+  /**
+   * "Already emitted `readopt_poll_unresolved` for this row" (#229). The b1 /
+   * unreadable-status re-evaluate leaf leaves the row UN-tracked so it is re-read
+   * every ~2s drain until the status map becomes readable — but the server-visible
+   * signal is an OUTCOME, so it must fire at most ONCE per row, not once per drain
+   * (Bugbot "Re-adopt signals flood every drain"). Cleared when the row leaves the
+   * processing list, exactly like `dontRedispatch`/`doneUndeliverable`.
+   */
+  readoptPollUnresolvedSignalled = /* @__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
@@ -1890,6 +2051,15 @@ var ChannelDriver = class {
    * so the NEXT tick may retry exactly once more).
    */
   awaitingReadopt = /* @__PURE__ */ new Set();
+  /**
+   * "Already signalled `attachments_skipped` for this Evident message id" (#376).
+   * The in-thread skip note is an OUTCOME, so it must fire AT MOST ONCE per message
+   * — never re-post on a re-dispatch of the same row (`forceReadoptRun` or the
+   * next-tick null-id retry both re-run `sendPromptAsync`, which re-fires
+   * `onOutcomes`). Mirrors `readoptPollUnresolvedSignalled`: a local dedup on the
+   * outcome, not the dispatch. Not cleared (a message is signalled once for life).
+   */
+  attachmentsSkippedSignalled = /* @__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
@@ -1907,6 +2077,16 @@ var ChannelDriver = class {
    * entry = not yet resolved; `null` = resolved root (stop walking).
    */
   sessionParents = /* @__PURE__ */ new Map();
+  /**
+   * Per-session OpenCode title cache (#310), keyed by sessionId. Only a resolved
+   * NON-EMPTY name is stored (terminal — a real session name won't later un-name),
+   * so we do NOT re-GET `/session/:id` every tick. A missing entry = not yet
+   * resolved OR resolved-but-still-empty → re-fetch on next need, since OpenCode
+   * names sessions asynchronously mid-turn. Driver-level (not per-watcher) so both
+   * the watcher completion path AND the restart-recovery re-adopt path (which has
+   * no watcher) can resolve the title.
+   */
+  sessionTitles = /* @__PURE__ */ new Map();
   /** Serialises drains so a reconnect during a drain doesn't double-process. */
   draining = false;
   /**
@@ -1944,9 +2124,6 @@ var ChannelDriver = class {
   get opencodeBase() {
     return `http://127.0.0.1:${this.port}`;
   }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
   /**
    * Drain all pending channel conversations once: poll → dispatch → register.
    * Called on tunnel `connected` (WI-CHAN-4) and on each poll tick by `run.ts`.
@@ -2088,9 +2265,7 @@ var ChannelDriver = class {
       if (!stillLive) return;
     }
   }
-  // -------------------------------------------------------------------------
   // Conversation processing (WI-3 — async dispatch)
-  // -------------------------------------------------------------------------
   /**
    * Dispatch each pending message for a conversation to opencode's native queue
    * via `prompt_async` (Task 3.2) and register it with the conversation's
@@ -2122,9 +2297,10 @@ var ChannelDriver = class {
           conversation_id: conv.id,
           message_id: message.id
         });
+        const sendAttachments = this.buildSendAttachments(conv, message);
         opencodeMessageId = await this.dispatchLocked(
           sessionId,
-          () => sendPromptAsync(this.port, sessionId, message.content, options)
+          () => sendPromptAsync(this.port, sessionId, message.content, options, sendAttachments)
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
@@ -2132,7 +2308,7 @@ var ChannelDriver = class {
         if (await sessionExists(this.port, sessionId) === false) {
           this.sessions.delete(conv.id);
           this.log({
-            level: "info",
+            level: "warn",
             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
@@ -2151,7 +2327,7 @@ var ChannelDriver = class {
       }
       if (opencodeMessageId === null) {
         this.log({
-          level: "error",
+          level: "warn",
           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
@@ -2165,7 +2341,7 @@ var ChannelDriver = class {
     }
     if (messages.length > 0 && dispatched === 0 && skippedAlreadyDispatched === messages.length) {
       this.log({
-        level: "error",
+        level: "warn",
         message: `Conversation ${conv.id.slice(0, 8)} has ${messages.length} pending message(s) but ALL are already marked dispatched locally (in-flight set: ${this.dispatched.size}) \u2014 none sent to OpenCode this tick. If this repeats, a message may be stuck acknowledged-but-never-dispatched (its watcher never settled).`,
         conversation_id: conv.id
       });
@@ -2179,7 +2355,7 @@ var ChannelDriver = class {
       const exists = await sessionExists(this.port, bound);
       if (exists === false) {
         this.log({
-          level: "info",
+          level: "debug",
           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
         });
@@ -2214,15 +2390,13 @@ var ChannelDriver = class {
     this.opencodeDirectory = await getOpenCodeDirectory(this.port);
     if (!this.opencodeDirectory) {
       this.log({
-        level: "info",
+        level: "warn",
         message: "Could not determine opencode directory (GET /path) \u2014 new sessions may not appear in opencode web"
       });
     }
     return this.opencodeDirectory;
   }
-  // -------------------------------------------------------------------------
   // 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
@@ -2242,6 +2416,103 @@ var ChannelDriver = class {
     );
     return run2;
   }
+  // Inbound image attachments (#255, WI-8)
+  /**
+   * Build the `SendAttachmentsInput` for a message's inbound images, or
+   * `undefined` when the message has none (so a text-only turn is unchanged).
+   *
+   * The driver OWNS the two channel-facing concerns the session module cannot:
+   *   - the AUTHENTICATED byte fetch through Evident's WI-6 endpoint
+   *     (`fetchAttachmentDataUrl`), using the SAME `getAuthHeader()` as every
+   *     other combinedAuth callback — the CLI NEVER talks to Slack directly;
+   *   - the in-thread SKIP NOTE (`signalAttachmentsSkipped`) posted over the
+   *     existing callback surface when any image was skipped/failed.
+   * `sendPromptAsync` applies the capability gate + appends the `file` parts and
+   * reports outcomes back via `onOutcomes`.
+   */
+  buildSendAttachments(conv, message) {
+    const refs = message.attachments;
+    if (!refs || refs.length === 0) return void 0;
+    return {
+      inputs: refs.map((a, index) => ({
+        index,
+        mime: a.mime,
+        ...a.filename ? { filename: a.filename } : {}
+      })),
+      fetchDataUrl: (index) => this.fetchAttachmentDataUrl(message.id, index, refs[index].mime),
+      onOutcomes: ({ outcomes, capabilityUnknown }) => this.signalAttachmentsSkipped(conv.id, message.id, outcomes, capabilityUnknown)
+    };
+  }
+  /**
+   * Fetch ONE inbound image's bytes through Evident's WI-6 endpoint
+   * (`GET {apiUrl}/agents/{agentId}/attachments/{messageId}/{index}`) using the
+   * existing authenticated fetch, and base64-encode into a
+   * `data:<mime>;base64,<…>` URL for the opencode `file` part's `url`.
+   *
+   * The endpoint streams the source bytes verbatim (200), or returns 404
+   * (not-owned / out-of-range / deleted-at-source / workspace gone) / 413
+   * (over-cap). On ANY non-2xx or thrown failure we return `null` so the caller
+   * OMITS that one image and the text turn still sends — NEVER throws the turn.
+   * Failures are logged with context (no silent swallow).
+   */
+  async fetchAttachmentDataUrl(messageId, index, mime) {
+    try {
+      const res = await this.fetchImpl(
+        `${this.apiUrl}/agents/${this.agentId}/attachments/${messageId}/${index}`,
+        { headers: { Authorization: this.getAuthHeader() } }
+      );
+      if (!res.ok) {
+        this.log({
+          level: "error",
+          message: `Attachment fetch for message ${messageId.slice(0, 8)} index ${index} returned HTTP ${res.status} \u2014 omitting this image (text turn proceeds)`,
+          message_id: messageId
+        });
+        return null;
+      }
+      const buf = await res.arrayBuffer();
+      const base64 = Buffer.from(buf).toString("base64");
+      const dataMime = cleanImageMime(res.headers.get("content-type")) || mime;
+      return `data:${dataMime};base64,${base64}`;
+    } catch (err) {
+      this.log({
+        level: "error",
+        message: `Attachment fetch for message ${messageId.slice(0, 8)} index ${index} failed \u2014 omitting this image (text turn proceeds): ${err instanceof Error ? err.message : String(err)}`,
+        message_id: messageId
+      });
+      return null;
+    }
+  }
+  /**
+   * On any skipped/failed image, post an in-thread note to Evident over the
+   * EXISTING combinedAuth callback surface — the CLI NEVER posts to Slack directly.
+   * Evident routes the note to source via `conversation.deliver`.
+   *
+   * The `POST .../messages/:id/signal` route accepts `attachments_skipped` (in
+   * `messageSignalSchema`) and turns it into an in-thread note delivered through
+   * `conversation.deliver` (e.g. "N image(s) couldn't be forwarded"), so the note
+   * reaches the channel.
+   *
+   * Fire-and-forget: never throws into the send/tick (logs its own failure).
+   */
+  signalAttachmentsSkipped(conversationId, messageId, outcomes, capabilityUnknown) {
+    const skipped = outcomes.filter((o) => o.status === "skipped").length;
+    const failed = outcomes.filter((o) => o.status === "failed").length;
+    if (skipped === 0 && failed === 0) return;
+    if (this.attachmentsSkippedSignalled.has(messageId)) return;
+    this.attachmentsSkippedSignalled.add(messageId);
+    const skippedReason = capabilityUnknown ? "unknown" : "unsupported";
+    this.log({
+      level: "info",
+      message: `Message ${messageId.slice(0, 8)}: ${skipped} image(s) skipped (${capabilityUnknown ? "capability was unreadable \u2014 failed open to text-only" : "model not attachment-capable"}), ${failed} image(s) unavailable (deleted-at-source or fetch failure) \u2014 noting to Evident`,
+      conversation_id: conversationId,
+      message_id: messageId
+    });
+    void this.postSignal(conversationId, messageId, "attachments_skipped", {
+      skipped,
+      failed,
+      ...skipped > 0 ? { skipped_reason: skippedReason } : {}
+    });
+  }
   /** Register a freshly-dispatched message with its session's watcher state. */
   registerInFlight(conv, sessionId, message, opencodeMessageId) {
     let watcher = this.watchers.get(sessionId);
@@ -2263,6 +2534,7 @@ var ChannelDriver = class {
       opencodeMessageId,
       message,
       dispatchedAt: now,
+      processingAnchorMs: now,
       deadline: now + this.pausedMaxWaitMs,
       started: false,
       done: false,
@@ -2321,6 +2593,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,
@@ -2474,18 +2750,20 @@ var ChannelDriver = class {
     const latchedPaused = inFlight.pausedOnQuestion || inFlight.pausedOnPermission;
     const awaitingHuman = observedOpen || latchedPaused;
     if ((state === "running" || state === "done" || state === "failed") && !inFlight.started) {
+      const title = await this.resolveSessionTitle(sessionId, watcher.conv.id);
       let claimed;
       try {
         claimed = await this.markProcessing(
           conv.id,
           inFlight.evidentMessageId,
           sessionId,
-          inFlight.opencodeMessageId
+          inFlight.opencodeMessageId,
+          title
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         this.log({
-          level: "error",
+          level: "warn",
           message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} processing (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
           conversation_id: conv.id,
           message_id: inFlight.evidentMessageId
@@ -2495,7 +2773,7 @@ var ChannelDriver = class {
       inFlight.started = true;
       if (!claimed) {
         this.log({
-          level: "info",
+          level: "debug",
           message: `Message ${inFlight.evidentMessageId.slice(0, 8)} already marked processing \u2014 continuing`,
           conversation_id: conv.id,
           message_id: inFlight.evidentMessageId
@@ -2511,18 +2789,20 @@ var ChannelDriver = class {
           conversation_id: conv.id,
           message_id: inFlight.evidentMessageId
         });
+        const title = await this.resolveSessionTitle(sessionId, watcher.conv.id);
         try {
           await this.markDone(
             conv.id,
             inFlight.evidentMessageId,
             sessionId,
-            inFlight.opencodeMessageId
+            inFlight.opencodeMessageId,
+            title
           );
         } catch (err) {
           if (err instanceof ChannelAuthError) throw err;
           if (err instanceof ChannelTerminalError) {
             this.log({
-              level: "error",
+              level: "warn",
               message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 leaving for the cron safety net: ${err.message}`,
               conversation_id: conv.id,
               message_id: inFlight.evidentMessageId
@@ -2532,7 +2812,7 @@ var ChannelDriver = class {
           }
           if (this.now() >= inFlight.deadline) {
             this.log({
-              level: "error",
+              level: "warn",
               message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done within the watch window \u2014 leaving for the cron safety net: ${err instanceof Error ? err.message : String(err)}`,
               conversation_id: conv.id,
               message_id: inFlight.evidentMessageId
@@ -2541,7 +2821,7 @@ var ChannelDriver = class {
             return;
           }
           this.log({
-            level: "error",
+            level: "warn",
             message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
             conversation_id: conv.id,
             message_id: inFlight.evidentMessageId
@@ -2569,7 +2849,7 @@ var ChannelDriver = class {
           if (err instanceof ChannelAuthError) throw err;
           if (err instanceof ChannelTerminalError) {
             this.log({
-              level: "error",
+              level: "warn",
               message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} failed (terminal HTTP ${err.status}) \u2014 leaving for the cron safety net: ${err.message}`,
               conversation_id: conv.id,
               message_id: inFlight.evidentMessageId
@@ -2579,7 +2859,7 @@ var ChannelDriver = class {
           }
           if (this.now() >= inFlight.deadline) {
             this.log({
-              level: "error",
+              level: "warn",
               message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} failed within the watch window \u2014 leaving for the cron safety net: ${err instanceof Error ? err.message : String(err)}`,
               conversation_id: conv.id,
               message_id: inFlight.evidentMessageId
@@ -2588,7 +2868,7 @@ var ChannelDriver = class {
             return;
           }
           this.log({
-            level: "error",
+            level: "warn",
             message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} failed (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
             conversation_id: conv.id,
             message_id: inFlight.evidentMessageId
@@ -2609,6 +2889,19 @@ var ChannelDriver = class {
       });
     }
     const activelyRunning = state === "running" && !awaitingHuman;
+    if (activelyRunning && this.now() - inFlight.processingAnchorMs >= ABSOLUTE_MAX_PROCESSING_MS) {
+      this.log({
+        level: "warn",
+        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) => {
@@ -2641,7 +2934,7 @@ var ChannelDriver = class {
     const queuedBehindRunningSibling = state === "queued" && hasActivelyRunningSibling;
     if (!activelyRunning && !queuedBehindRunningSibling && this.now() >= inFlight.deadline) {
       this.log({
-        level: "info",
+        level: "debug",
         message: `Message ${inFlight.evidentMessageId.slice(0, 8)} did not complete within the watch window \u2014 leaving for the cron safety net`,
         conversation_id: conv.id,
         message_id: inFlight.evidentMessageId
@@ -2652,9 +2945,7 @@ var ChannelDriver = class {
       this.removeInFlight(watcher, inFlight.evidentMessageId);
     }
   }
-  // -------------------------------------------------------------------------
   // Restart recovery: re-adopt `processing` messages (ADR-0046, WI-3/4/5)
-  // -------------------------------------------------------------------------
   /**
    * Re-adopt this agent's `processing` messages on drain (ADR-0046 Decision §1).
    *
@@ -2671,15 +2962,20 @@ var ChannelDriver = class {
    */
   async readoptProcessing() {
     const rows = await this.getProcessingMessages();
-    if (this.dontRedispatch.size > 0 || this.doneUndeliverable.size > 0) {
+    if (this.dontRedispatch.size > 0 || this.doneUndeliverable.size > 0 || this.readoptPollUnresolvedSignalled.size > 0) {
       const stillProcessing = new Set(rows.map((r) => r.id));
-      for (const id of [...this.dontRedispatch, ...this.doneUndeliverable]) {
+      for (const id of [
+        ...this.dontRedispatch,
+        ...this.doneUndeliverable,
+        ...this.readoptPollUnresolvedSignalled
+      ]) {
         if (!stillProcessing.has(id)) {
           const cleared = this.dontRedispatch.delete(id);
           const clearedUndeliverable = this.doneUndeliverable.delete(id);
+          this.readoptPollUnresolvedSignalled.delete(id);
           if (cleared || clearedUndeliverable) {
             this.log({
-              level: "info",
+              level: "debug",
               message: `Re-adopt: message ${id.slice(0, 8)} left the processing list (cron reset) \u2014 cleared gave-up marker`,
               message_id: id
             });
@@ -2692,7 +2988,7 @@ var ChannelDriver = class {
     for (const row of rows) {
       if (!row.opencode_session_id) {
         this.log({
-          level: "error",
+          level: "warn",
           message: `Cannot re-adopt processing message ${row.id.slice(0, 8)} \u2014 no opencode session id; leaving for the cron safety net`,
           conversation_id: row.conversation_id,
           message_id: row.id
@@ -2709,7 +3005,7 @@ var ChannelDriver = class {
         const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
         if (!res.ok) {
           this.log({
-            level: "error",
+            level: "warn",
             message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned HTTP ${res.status} \u2014 skipping this session this tick`
           });
           continue;
@@ -2717,7 +3013,7 @@ var ChannelDriver = class {
         const body = await res.json();
         if (!Array.isArray(body)) {
           this.log({
-            level: "error",
+            level: "warn",
             message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned a non-array message body \u2014 skipping this session this tick`
           });
           continue;
@@ -2725,13 +3021,15 @@ var ChannelDriver = class {
         messages = body;
       } catch (err) {
         this.log({
-          level: "error",
+          level: "warn",
           message: `Re-adopt: failed to poll session ${sessionId.slice(0, 8)} (will retry next drain): ${err instanceof Error ? err.message : String(err)}`
         });
         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);
       }
     }
   }
@@ -2753,10 +3051,10 @@ 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",
+        level: "debug",
         message: `Re-adopt: message ${row.id.slice(0, 8)} already tracked in-flight \u2014 skipping (owned by the watcher loop)`,
         conversation_id: row.conversation_id,
         message_id: row.id
@@ -2768,7 +3066,7 @@ var ChannelDriver = class {
     if (state === "done") {
       if (this.doneUndeliverable.has(row.id)) {
         this.log({
-          level: "info",
+          level: "debug",
           message: `Re-adopt: message ${row.id.slice(0, 8)} markDone is terminally undeliverable \u2014 left to the cron; skipping until it leaves processing`,
           conversation_id: row.conversation_id,
           message_id: row.id
@@ -2782,21 +3080,23 @@ var ChannelDriver = class {
         message_id: row.id
       });
       try {
-        await this.markDone(row.conversation_id, row.id, sessionId, ocId);
+        const title = await this.resolveSessionTitle(sessionId, row.conversation_id);
+        await this.markDone(row.conversation_id, row.id, sessionId, ocId, title);
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         if (err instanceof ChannelTerminalError) {
           this.doneUndeliverable.add(row.id);
           this.log({
-            level: "error",
+            level: "warn",
             message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 parking until it leaves processing; leaving for the cron safety net: ${err.message}`,
             conversation_id: row.conversation_id,
             message_id: row.id
           });
+          void this.postSignal(row.conversation_id, row.id, "readopt_undeliverable");
           return;
         }
         this.log({
-          level: "error",
+          level: "warn",
           message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} done (will retry next drain): ${err instanceof Error ? err.message : String(err)}`,
           conversation_id: row.conversation_id,
           message_id: row.id
@@ -2804,6 +3104,7 @@ var ChannelDriver = class {
         return;
       }
       this.dontRedispatch.delete(row.id);
+      void this.postSignal(row.conversation_id, row.id, "readopt_done");
       return;
     }
     if (state === "failed") {
@@ -2821,15 +3122,16 @@ var ChannelDriver = class {
         if (err instanceof ChannelTerminalError) {
           this.doneUndeliverable.add(row.id);
           this.log({
-            level: "error",
+            level: "warn",
             message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} failed (terminal HTTP ${err.status}) \u2014 parking until it leaves processing; leaving for the cron safety net: ${err.message}`,
             conversation_id: row.conversation_id,
             message_id: row.id
           });
+          void this.postSignal(row.conversation_id, row.id, "readopt_undeliverable");
           return;
         }
         this.log({
-          level: "error",
+          level: "warn",
           message: `Re-adopt: failed to mark message ${row.id.slice(0, 8)} failed (will retry next drain): ${err instanceof Error ? err.message : String(err)}`,
           conversation_id: row.conversation_id,
           message_id: row.id
@@ -2837,17 +3139,83 @@ var ChannelDriver = class {
         return;
       }
       this.dontRedispatch.delete(row.id);
+      void this.postSignal(row.conversation_id, row.id, "readopt_failed");
       return;
     }
     if (this.dontRedispatch.has(row.id)) {
       this.log({
-        level: "info",
+        level: "debug",
         message: `Re-adopt: message ${row.id.slice(0, 8)} already gave up \u2014 left to the cron; skipping until it leaves processing`,
         conversation_id: row.conversation_id,
         message_id: row.id
       });
       return;
     }
+    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: "debug",
+          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: "debug",
+            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
+          });
+          if (!this.readoptPollUnresolvedSignalled.has(row.id)) {
+            this.readoptPollUnresolvedSignalled.add(row.id);
+            void this.postSignal(row.conversation_id, row.id, "readopt_poll_unresolved");
+          }
+          return;
+        }
+        this.log({
+          level: "debug",
+          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: "debug",
+          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);
@@ -2856,11 +3224,12 @@ var ChannelDriver = class {
       this.readopted.add(row.id);
       this.ensureWatcherRunning(sessionId);
       this.log({
-        level: "info",
+        level: "debug",
         message: `Re-adopt: message ${row.id.slice(0, 8)} ${state} \u2014 re-attached watcher (stored id, no re-dispatch)`,
         conversation_id: row.conversation_id,
         message_id: row.id
       });
+      void this.postSignal(row.conversation_id, row.id, "readopt_reattached");
       return;
     }
     await this.forceReadoptRun(sessionId, row);
@@ -2889,7 +3258,7 @@ var ChannelDriver = class {
   async forceReadoptRun(sessionId, row) {
     if (this.stopped) {
       this.log({
-        level: "info",
+        level: "debug",
         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
@@ -2898,7 +3267,7 @@ var ChannelDriver = class {
     }
     if (this.awaitingReadopt.has(row.id)) {
       this.log({
-        level: "info",
+        level: "debug",
         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
@@ -2908,11 +3277,12 @@ var ChannelDriver = class {
     if (this.processedAtMs(row) + this.pausedMaxWaitMs <= this.now()) {
       this.dontRedispatch.add(row.id);
       this.log({
-        level: "info",
+        level: "debug",
         message: `Re-adopt: message ${row.id.slice(0, 8)} orphaned but its re-adopt window has already elapsed \u2014 not dispatching an unwatchable turn; parking until it leaves processing (cron will reset it)`,
         conversation_id: row.conversation_id,
         message_id: row.id
       });
+      void this.postSignal(row.conversation_id, row.id, "readopt_window_elapsed");
       return;
     }
     const options = {
@@ -2926,40 +3296,44 @@ var ChannelDriver = class {
       message_id: row.id
     });
     this.awaitingReadopt.add(row.id);
+    const readoptConv = this.convForRow(sessionId, row);
+    const readoptMessage = this.queuedMessageForRow(row);
+    const sendAttachments = this.buildSendAttachments(readoptConv, readoptMessage);
     let ocId;
     try {
       ocId = await this.dispatchLocked(
         sessionId,
-        () => sendPromptAsync(this.port, sessionId, row.content, options)
+        () => sendPromptAsync(this.port, sessionId, row.content, options, sendAttachments)
       );
     } catch (err) {
       this.awaitingReadopt.delete(row.id);
       if (err instanceof ChannelAuthError) throw err;
       this.log({
-        level: "error",
+        level: "warn",
         message: `Re-adopt: re-dispatch failed for message ${row.id.slice(0, 8)} (will retry next drain): ${err instanceof Error ? err.message : String(err)}`,
         conversation_id: row.conversation_id,
         message_id: row.id
       });
+      void this.postSignal(row.conversation_id, row.id, "readopt_orphan_unsent");
       return;
     }
     if (ocId === null) {
       this.awaitingReadopt.delete(row.id);
       this.log({
-        level: "error",
+        level: "warn",
         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
       });
+      void this.postSignal(row.conversation_id, row.id, "readopt_orphan_unsent");
       return;
     }
-    const conv = this.convForRow(sessionId, row);
-    const message = this.queuedMessageForRow(row);
-    this.registerReadopted(conv, sessionId, message, ocId, this.processedAtMs(row));
+    this.registerReadopted(readoptConv, sessionId, readoptMessage, ocId, this.processedAtMs(row));
     this.dispatched.add(row.id);
     this.readopted.add(row.id);
     this.awaitingReadopt.delete(row.id);
     this.ensureWatcherRunning(sessionId);
+    void this.postSignal(row.conversation_id, row.id, "readopt_redispatched");
   }
   /**
    * True if `evidentMessageId` is already being driven — either in the
@@ -3008,7 +3382,8 @@ var ChannelDriver = class {
       opencode_agent: row.opencode_agent,
       opencode_model: row.opencode_model,
       source_message_id: row.source_message_id,
-      slack_user_id: row.slack_user_id
+      slack_user_id: row.slack_user_id,
+      attachments: row.attachments ?? null
     };
   }
   /**
@@ -3029,7 +3404,7 @@ var ChannelDriver = class {
     if (this.readopted.delete(evidentMessageId) && inFlight && !inFlight.done) {
       this.dontRedispatch.add(evidentMessageId);
       this.log({
-        level: "info",
+        level: "debug",
         message: `Re-adopt: message ${evidentMessageId.slice(0, 8)} gave up \u2014 parking until it leaves the processing list (cron reset)`,
         conversation_id: watcher.conv.id,
         message_id: evidentMessageId
@@ -3169,6 +3544,128 @@ var ChannelDriver = class {
     if (parent !== void 0) this.sessionParents.set(sessionId, parent);
     return parent;
   }
+  /**
+   * Resolve (and cache in `sessionTitles`) the OpenCode session TITLE (#310) so the
+   * status PATCH can carry it into the "Live sessions" list. Driver-level cache so
+   * BOTH the watcher completion path and the restart-recovery re-adopt path (which
+   * has no watcher) can use it. `conversationId` is passed only for log context.
+   * Best-effort:
+   *   - a resolved NON-EMPTY title is cached and terminal (a real session name
+   *     won't later un-name), so we do NOT re-GET `/session/:id` every tick;
+   *   - while the title is still absent/empty we do NOT latch it — OpenCode names
+   *     sessions asynchronously mid-turn, so an early call (e.g. at `processing`)
+   *     must leave the cache unresolved and re-fetch on the next need so a later
+   *     call (e.g. at `done`) picks up the name assigned in the meantime. Such a
+   *     call returns `null` (omit the title on THIS PATCH) without caching;
+   *   - a failed request likewise leaves the cache unresolved (retry next need)
+   *     and returns `null` — it must NEVER throw or block completion.
+   * A failure is logged with agent/session context (no silent catch).
+   */
+  async resolveSessionTitle(sessionId, conversationId) {
+    const cached = this.sessionTitles.get(sessionId);
+    if (cached != null) return cached;
+    try {
+      const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}`);
+      if (res.ok) {
+        const body = await res.json();
+        const title = body && typeof body.title === "string" ? body.title.trim() : "";
+        if (title.length > 0) {
+          this.sessionTitles.set(sessionId, title);
+          return title;
+        }
+        return null;
+      }
+      this.log({
+        level: "debug",
+        message: `Session title fetch for session ${sessionId.slice(0, 8)} (agent ${this.agentId.slice(0, 8)}) returned HTTP ${res.status} \u2014 omitting title`,
+        conversation_id: conversationId
+      });
+    } catch (err) {
+      this.log({
+        level: "debug",
+        message: `Best-effort session title fetch failed for session ${sessionId.slice(0, 8)} (agent ${this.agentId.slice(0, 8)}) \u2014 omitting title: ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: conversationId
+      });
+    }
+    return null;
+  }
+  /**
+   * 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: "warn",
+        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).
    *
@@ -3219,9 +3716,7 @@ var ChannelDriver = class {
     }
     return inFlight.sort(byOldest)[0];
   }
-  // -------------------------------------------------------------------------
   // Evident API calls (combinedAuth thread routes)
-  // -------------------------------------------------------------------------
   async getPendingConversations() {
     const res = await this.fetchImpl(
       `${this.apiUrl}/agents/${this.agentId}/conversations/pending`,
@@ -3301,7 +3796,7 @@ var ChannelDriver = class {
    * A single attempt (no internal retry): the watcher's per-tick loop is the
    * retry vehicle for the swap-to-running.
    */
-  async markProcessing(conversationId, messageId, sessionId, opencodeMessageId) {
+  async markProcessing(conversationId, messageId, sessionId, opencodeMessageId, title) {
     const res = await this.fetchImpl(
       `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
       {
@@ -3310,7 +3805,8 @@ var ChannelDriver = class {
         body: JSON.stringify({
           status: "processing",
           opencode_session_id: sessionId,
-          ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {}
+          ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {},
+          ...title ? { title } : {}
         })
       }
     );
@@ -3349,7 +3845,7 @@ var ChannelDriver = class {
    *                                    watcher retries next tick within the
    *                                    deadline, Finding 4).
    */
-  async markDone(conversationId, messageId, sessionId, opencodeMessageId) {
+  async markDone(conversationId, messageId, sessionId, opencodeMessageId, title) {
     const res = await this.fetchImpl(
       `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
       {
@@ -3358,7 +3854,8 @@ var ChannelDriver = class {
         body: JSON.stringify({
           status: "done",
           opencode_session_id: sessionId,
-          ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {}
+          ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {},
+          ...title ? { title } : {}
         })
       }
     );
@@ -3419,7 +3916,7 @@ var ChannelDriver = class {
       );
       if (!res.ok) {
         this.log({
-          level: "error",
+          level: "warn",
           message: `Signal '${signal}' for message ${messageId.slice(0, 8)} returned HTTP ${res.status} (telemetry-only, ignored)`,
           conversation_id: conversationId,
           message_id: messageId
@@ -3429,7 +3926,7 @@ var ChannelDriver = class {
       return true;
     } catch (err) {
       this.log({
-        level: "error",
+        level: "warn",
         message: `Signal '${signal}' for message ${messageId.slice(0, 8)} failed (telemetry-only, ignored): ${err instanceof Error ? err.message : String(err)}`,
         conversation_id: conversationId,
         message_id: messageId
@@ -3491,9 +3988,7 @@ var ChannelDriver = class {
       return false;
     }
   }
-  // -------------------------------------------------------------------------
   // Retry wrapper
-  // -------------------------------------------------------------------------
   /**
    * Invoke an Evident API call, retrying on transient failures (5xx / 429 /
    * network errors) with exponential backoff + jitter (capped). Auth failures
@@ -3773,23 +4268,53 @@ 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) {
+function resolveLogLevel(options) {
+  const accepted = Object.keys(LOG_LEVELS);
+  const validate = (value, source) => {
+    const normalized = value.trim().toLowerCase();
+    if (!accepted.includes(normalized)) {
+      throw new Error(
+        `Invalid log level "${value}"${source}; expected one of ${accepted.join(", ")}`
+      );
+    }
+    return normalized;
+  };
+  if (options.logLevel !== void 0) {
+    return validate(options.logLevel, " (--log-level)");
+  }
+  if (options.verbose) {
+    return "debug";
+  }
+  const env = process.env.EVIDENT_LOG_LEVEL;
+  if (env !== void 0 && env !== "") {
+    return validate(env, " (EVIDENT_LOG_LEVEL)");
+  }
+  return "info";
+}
+function meetsThreshold(state, level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[state.logLevel];
+}
+function log2(state, message, level = "info") {
+  if (!meetsThreshold(state, level)) return;
   if (state.json) {
     console.log(
       JSON.stringify({
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        level: isError ? "error" : "info",
+        level,
         message
       })
     );
   } else if (!state.interactive) {
-    const prefix = isError ? chalk6.red("\u2717") : chalk6.green("\u2022");
+    const prefix = level === "error" ? chalk6.red("\u2717") : level === "warn" ? chalk6.yellow("!") : level === "debug" ? chalk6.dim("\xB7") : chalk6.green("\u2022");
     console.log(`${prefix} ${message}`);
   }
 }
 function logActivity(state, entry) {
+  const level = entry.level ?? (entry.type === "error" ? "error" : "info");
+  if (!meetsThreshold(state, level)) return;
   const fullEntry = {
     ...entry,
+    level,
     timestamp: /* @__PURE__ */ new Date()
   };
   state.activityLog.push(fullEntry);
@@ -3798,9 +4323,9 @@ function logActivity(state, entry) {
   }
   if (!state.interactive) {
     if (entry.type === "error") {
-      log2(state, entry.error ?? "Unknown error", true);
-    } else if (entry.type === "info" && entry.message) {
-      log2(state, entry.message);
+      log2(state, entry.error ?? "Unknown error", level);
+    } else if (entry.message) {
+      log2(state, entry.message, level);
     }
   }
 }
@@ -3999,7 +4524,7 @@ function scheduleSessionCleanup(state, driver, options) {
     process.env
   );
   for (const warning2 of config2.warnings) {
-    logActivity(state, { type: "info", message: `Session cleanup: ${warning2}` });
+    logActivity(state, { type: "info", level: "warn", message: `Session cleanup: ${warning2}` });
   }
   if (!config2.enabled) return;
   logActivity(state, {
@@ -4071,6 +4596,20 @@ async function cleanup(state, opts = {}) {
 }
 async function run(options) {
   const interactive = isInteractive(options.json);
+  let logLevel;
+  try {
+    logLevel = resolveLogLevel(options);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (options.json) {
+      console.log(JSON.stringify({ status: "error", error: message }));
+    } else {
+      printError(message);
+    }
+    await shutdownTelemetry();
+    process.exit(1);
+    return;
+  }
   const state = {
     agentId: options.agent || "",
     agentName: null,
@@ -4079,6 +4618,7 @@ async function run(options) {
     idleTimeout: options.idleTimeout ?? null,
     json: options.json ?? false,
     interactive,
+    logLevel,
     connected: false,
     opencodeConnected: false,
     opencodeVersion: null,
@@ -4096,8 +4636,8 @@ async function run(options) {
   if (state.idleTimeout === null && (process.env.GITHUB_ACTIONS || process.env.CI)) {
     log2(
       state,
-      "Warning: No --idle-timeout set in CI environment. The runner will poll indefinitely until the job times out. Consider adding --idle-timeout 30 to avoid wasting runner minutes.",
-      false
+      "No --idle-timeout set in CI environment. The runner will poll indefinitely until the job times out. Consider adding --idle-timeout 30 to avoid wasting runner minutes.",
+      "warn"
     );
   }
   const handleSignal = async () => {
@@ -4213,9 +4753,9 @@ async function run(options) {
       ocSpinner?.succeed(`OpenCode running on port ${state.port}${version2}`);
       const versionWarning = buildOpenCodeVersionWarning(state.opencodeVersion);
       if (versionWarning) {
-        log2(state, versionWarning, false);
+        log2(state, versionWarning, "warn");
         if (state.interactive && !state.json) {
-          logActivity(state, { type: "info", message: versionWarning });
+          logActivity(state, { type: "info", level: "warn", message: versionWarning });
         }
       }
     } catch (error2) {
@@ -4230,11 +4770,17 @@ async function run(options) {
       getAuthHeader: () => state.authHeader,
       conversationFilter: state.conversationFilter,
       stuckQueuedMs: CHANNEL_STUCK_QUEUED_MS,
-      log: (entry) => logActivity(state, {
-        type: entry.level === "error" ? "error" : "info",
-        message: entry.message,
-        error: entry.level === "error" ? entry.message : void 0
-      })
+      log: (entry) => (
+        // Thread the driver's real level straight through so `debug`/`warn`
+        // survive the sink filter (they no longer collapse to info). `type`
+        // stays the coarse error/non-error split the activity log renders with.
+        logActivity(state, {
+          type: entry.level === "error" ? "error" : "info",
+          level: entry.level,
+          message: entry.message,
+          error: entry.level === "error" ? entry.message : void 0
+        })
+      )
     });
     state.channelDriver = channelDriver;
     const connection = new RunnerConnection({
@@ -4388,7 +4934,10 @@ 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(
+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(
+  "--log-level <level>",
+  "Log verbosity: debug | info | warn | error (default: info). Env: EVIDENT_LOG_LEVEL"
+).option("-v, --verbose", "Alias for --log-level debug (ignored if --log-level is set)").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(
@@ -4402,6 +4951,9 @@ program.command("run").description("Connect to Evident and process messages").op
     run({
       agent: options.agent,
       port: parseInt(options.port, 10),
+      // Raw string — validation/precedence is single-sourced in run.ts's
+      // resolveLogLevel (flag > -v > EVIDENT_LOG_LEVEL > info).
+      logLevel: options.logLevel,
       verbose: options.verbose,
       conversation: options.conversation,
       idleTimeout: options.idleTimeout ? parseInt(options.idleTimeout, 10) : void 0,