@evident-ai/cli 3.4.1-dev.0b03f1c → 3.4.1-dev.10920a8

package/dist/index.js

@@ -623,6 +623,19 @@ function isInteractive(jsonOutput) {
   return true;
 }
 
+// src/lib/subscription-usage-report.ts
+function toReportedSubscription(collected) {
+  if (!collected) return null;
+  if (collected.ownerEmail === null && collected.planType === null && collected.organizationName === null) {
+    return null;
+  }
+  return {
+    owner_email: collected.ownerEmail,
+    plan_type: collected.planType,
+    organization_name: collected.organizationName
+  };
+}
+
 // src/commands/agent-lookup.ts
 async function readErrorMessage(response) {
   const text = await response.text().catch(() => "");
@@ -722,14 +735,6 @@ function toReportedWindow(window) {
   if (!window) return null;
   return { utilization: window.utilization, resets_at: window.resetsAt };
 }
-function toReportedOwner(snapshot) {
-  if (!snapshot.owner) return null;
-  return {
-    email: snapshot.owner.email,
-    organization_name: snapshot.owner.organizationName,
-    rate_limit_tier: snapshot.owner.rateLimitTier
-  };
-}
 async function reportClaudeUsage(agentId, authHeader, snapshot) {
   try {
     const apiUrl = getApiUrlConfig();
@@ -739,7 +744,7 @@ async function reportClaudeUsage(agentId, authHeader, snapshot) {
       body: JSON.stringify({
         five_hour: toReportedWindow(snapshot.fiveHour),
         seven_day: toReportedWindow(snapshot.sevenDay),
-        owner: toReportedOwner(snapshot)
+        subscription: toReportedSubscription(snapshot.subscription)
       }),
       signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
     });
@@ -763,13 +768,6 @@ function toReportedOpenAiWindow(window) {
     resets_at: window.resetsAt
   };
 }
-function toReportedOpenAiSubscription(snapshot) {
-  if (!snapshot.subscription) return null;
-  return {
-    owner_email: snapshot.subscription.ownerEmail,
-    plan_type: snapshot.subscription.planType
-  };
-}
 async function reportOpenAiUsage(agentId, authHeader, snapshot) {
   try {
     const apiUrl = getApiUrlConfig();
@@ -781,7 +779,7 @@ async function reportOpenAiUsage(agentId, authHeader, snapshot) {
         secondary: toReportedOpenAiWindow(snapshot.secondary),
         has_credits: snapshot.hasCredits,
         credits_unlimited: snapshot.creditsUnlimited,
-        subscription: toReportedOpenAiSubscription(snapshot)
+        subscription: toReportedSubscription(snapshot.subscription)
       }),
       signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
     });
@@ -1097,7 +1095,7 @@ function ownerLookupFailure(error2) {
 }
 async function getClaudeUsageOwner(accessToken) {
   if (cachedOwner?.accessToken === accessToken) {
-    return { owner: cachedOwner.owner, ownerLookupError: null };
+    return { subscription: cachedOwner.owner, ownerLookupError: null };
   }
   try {
     const response = await fetch(CLAUDE_PROFILE_URL, {
@@ -1109,27 +1107,27 @@ async function getClaudeUsageOwner(accessToken) {
       signal: AbortSignal.timeout(CLAUDE_PROFILE_TIMEOUT_MS)
     });
     if (!response.ok) {
-      return { owner: null, ownerLookupError: `HTTP ${response.status}` };
+      return { subscription: null, ownerLookupError: `HTTP ${response.status}` };
     }
     let body;
     try {
       body = await response.json();
     } catch (error2) {
-      return { owner: null, ownerLookupError: "malformed response" };
+      return { subscription: null, ownerLookupError: "malformed response" };
     }
     const profile = body;
     if (typeof profile.account?.email !== "string" || !profile.account.email.trim()) {
-      return { owner: null, ownerLookupError: "malformed response" };
+      return { subscription: null, ownerLookupError: "malformed response" };
     }
-    const owner = {
-      email: profile.account.email,
+    const subscription = {
+      ownerEmail: profile.account.email,
       organizationName: typeof profile.organization?.name === "string" && profile.organization.name.trim() ? profile.organization.name.trim() : null,
-      rateLimitTier: typeof profile.organization?.rate_limit_tier === "string" && profile.organization.rate_limit_tier.trim() ? profile.organization.rate_limit_tier.trim() : null
+      planType: typeof profile.organization?.rate_limit_tier === "string" && profile.organization.rate_limit_tier.trim() ? profile.organization.rate_limit_tier.trim() : null
     };
-    cachedOwner = { accessToken, owner };
-    return { owner, ownerLookupError: null };
+    cachedOwner = { accessToken, owner: subscription };
+    return { subscription, ownerLookupError: null };
   } catch (error2) {
-    return { owner: null, ownerLookupError: ownerLookupFailure(error2) };
+    return { subscription: null, ownerLookupError: ownerLookupFailure(error2) };
   }
 }
 async function getClaudeUsage() {
@@ -1158,11 +1156,11 @@ async function getClaudeUsage() {
     throw new ClaudeUsageError(`Claude usage request failed: HTTP ${res.status}`, "request_failed");
   }
   const body = await res.json();
-  const { owner, ownerLookupError } = await getClaudeUsageOwner(credentials2.accessToken);
+  const { subscription, ownerLookupError } = await getClaudeUsageOwner(credentials2.accessToken);
   return {
     fiveHour: toWindow(body.five_hour),
     sevenDay: toWindow(body.seven_day),
-    owner,
+    subscription,
     ownerLookupError
   };
 }
@@ -3263,21 +3261,74 @@ function collectSubagentSessions(messages, userMessageId) {
   }
   return refs;
 }
-function messageUsage(messages, userMessageId) {
-  if (!messages || messages.length === 0) return null;
-  const byParentAll = messages.filter(
-    (m) => roleOf(m) === "assistant" && parentIdOf(m) === userMessageId
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function taskCallModel(value) {
+  if (!value || typeof value !== "object") return null;
+  const model = value;
+  const modelID = typeof model.modelID === "string" ? model.modelID : void 0;
+  const providerID = typeof model.providerID === "string" ? model.providerID : void 0;
+  return modelID || providerID ? { modelID, providerID } : null;
+}
+function collectTaskCalls(messages, userMessageId) {
+  if (!messages || messages.length === 0) return [];
+  const calls = [];
+  for (const message of messages) {
+    if (roleOf(message) !== "assistant" || parentIdOf(message) !== userMessageId) continue;
+    for (const part of message.parts ?? []) {
+      if (part.tool !== "task" || !part.callID || !part.state || part.state.status === "pending") {
+        continue;
+      }
+      const rawName = part.state.input?.subagent_type;
+      const subagentName = typeof rawName === "string" && rawName.trim().length > 0 ? rawName : rawName === void 0 ? "general" : "unknown";
+      const metadata = part.state.metadata;
+      calls.push({
+        callID: part.callID,
+        subagentName,
+        childSessionId: typeof metadata?.sessionId === "string" ? metadata.sessionId : null,
+        parentSessionId: typeof metadata?.parentSessionId === "string" ? metadata.parentSessionId : null,
+        model: taskCallModel(metadata?.model),
+        status: part.state.status ?? "unknown",
+        timeStart: finiteNumber(part.state.time?.start),
+        timeEnd: finiteNumber(part.state.time?.end)
+      });
+    }
+  }
+  return calls;
+}
+function attributeTaskCallUsage(messages, windows) {
+  const eligibleWindows = windows.filter(
+    (window) => window.timeStart !== null && Number.isFinite(window.timeStart)
   );
-  const byParentNonErrored = byParentAll.filter((m) => errorOf(m) == null);
-  const byParent = byParentNonErrored.length > 0 ? byParentNonErrored : byParentAll;
-  let correlated;
-  if (byParent.length > 0) {
-    correlated = byParent;
-  } else {
-    const reply = findAssistantReplyAfter(messages, userMessageId);
-    correlated = reply ? [reply] : [];
+  const assignments = /* @__PURE__ */ new Map();
+  for (const window of eligibleWindows) assignments.set(window.callID, []);
+  const unattributed = [];
+  for (const message of messages ?? []) {
+    if (roleOf(message) !== "assistant") continue;
+    const created = finiteNumber(createdOf(message));
+    const matching = created === null ? [] : eligibleWindows.filter(
+      (window) => window.timeStart <= created && (window.timeEnd === null || window.timeEnd === void 0 || created <= window.timeEnd)
+    );
+    if (matching.length === 0) {
+      unattributed.push(message);
+      continue;
+    }
+    matching.sort((a, b) => a.timeStart - b.timeStart);
+    assignments.get(matching[0].callID)?.push(message);
   }
-  if (correlated.length === 0) return null;
+  return {
+    invocations: eligibleWindows.map((window) => {
+      const assigned = assignments.get(window.callID) ?? [];
+      return { callID: window.callID, messages: assigned, usage: sumAssistantUsage(assigned) };
+    }),
+    unattributed
+  };
+}
+function sumAssistantUsage(messages) {
+  if (!messages || messages.length === 0) return null;
+  const nonErrored = messages.filter((message) => errorOf(message) == null);
+  const selected = nonErrored.length > 0 ? nonErrored : messages;
   let sawAnyUsage = false;
   let inputSum = 0;
   let outputSum = 0;
@@ -3288,7 +3339,7 @@ function messageUsage(messages, userMessageId) {
   let sawCost = false;
   let modelId = null;
   let providerId = null;
-  for (const m of correlated) {
+  for (const m of selected) {
     const info = m.info;
     if (!info) continue;
     const tokens = info.tokens;
@@ -3323,12 +3374,28 @@ function messageUsage(messages, userMessageId) {
     usage_tokens_reasoning: reasoningSum,
     usage_tokens_cache_read: cacheReadSum,
     usage_tokens_cache_write: cacheWriteSum,
-    // NULL means "OpenCode never reported a cost" (never inferred from
-    // tokens) — distinct from a genuine 0-cost turn, which would set
-    // `sawCost` true with `costSum === 0`.
+    // NULL means OpenCode never reported a cost; it is distinct from a genuine
+    // zero-cost message, which sets `sawCost` with `costSum === 0`.
     usage_cost_usd: sawCost ? costSum : null
   };
 }
+function messageUsage(messages, userMessageId) {
+  if (!messages || messages.length === 0) return null;
+  const byParentAll = messages.filter(
+    (m) => roleOf(m) === "assistant" && parentIdOf(m) === userMessageId
+  );
+  const byParentNonErrored = byParentAll.filter((m) => errorOf(m) == null);
+  const byParent = byParentNonErrored.length > 0 ? byParentNonErrored : byParentAll;
+  let correlated;
+  if (byParent.length > 0) {
+    correlated = byParent;
+  } else {
+    const reply = findAssistantReplyAfter(messages, userMessageId);
+    correlated = reply ? [reply] : [];
+  }
+  if (correlated.length === 0) return null;
+  return sumAssistantUsage(correlated);
+}
 function messageRunState(messages, userMessageId) {
   if (!messages || messages.length === 0) return "unknown";
   const hasUser = messages.some((m) => idOf(m) === userMessageId);
@@ -3458,6 +3525,28 @@ function hasRunningAssistantExcept(messages, exceptUserMessageId) {
     (m) => roleOf(m) === "assistant" && parentIdOf(m) !== exceptUserMessageId && isAssistantInFlight(m)
   );
 }
+function hasLaterSiblingTurnStarted(messages, userMessageId, siblingUserMessageIds) {
+  if (!messages || messages.length === 0) return false;
+  const userIndex = messages.findIndex((message) => idOf(message) === userMessageId);
+  if (userIndex === -1) return false;
+  let hasLaterUser = false;
+  let hasStartedLaterUser = false;
+  for (let i = userIndex + 1; i < messages.length; i++) {
+    const message = messages[i];
+    if (roleOf(message) !== "user") continue;
+    hasLaterUser = true;
+    const laterUserMessageId = idOf(message);
+    if (laterUserMessageId === void 0 || !siblingUserMessageIds.has(laterUserMessageId)) {
+      return false;
+    }
+    if (messages.some(
+      (candidate) => roleOf(candidate) === "assistant" && parentIdOf(candidate) === laterUserMessageId
+    )) {
+      hasStartedLaterUser = true;
+    }
+  }
+  return hasLaterUser && hasStartedLaterUser;
+}
 async function hasAnyConfiguredProvider(port) {
   try {
     const res = await timedFetch(`${opencodeBase(port)}/config/providers`);
@@ -3489,6 +3578,76 @@ async function hasAnyConfiguredProvider(port) {
     return null;
   }
 }
+function sessionErrorReason(error2) {
+  const record = typeof error2 === "object" && error2 !== null ? error2 : null;
+  const data = record?.data;
+  const dataRecord = typeof data === "object" && data !== null ? data : null;
+  const rawReason = typeof dataRecord?.message === "string" && dataRecord.message || typeof record?.message === "string" && record.message || typeof error2 === "string" && error2 || typeof record?.name === "string" && record.name || "OpenCode reported a session error with no details";
+  const reason = rawReason.replace(/\s+/g, " ").trim().slice(0, 500);
+  return reason || "OpenCode reported a session error with no details";
+}
+function parseSessionErrorFrame(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch (error2) {
+    void error2;
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const parsedRecord = parsed;
+  const payload = parsedRecord.payload;
+  const event = payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : parsedRecord;
+  if (event.type !== "session.error") return null;
+  const properties = event.properties;
+  if (properties === null || typeof properties !== "object" || Array.isArray(properties)) {
+    return null;
+  }
+  const propertiesRecord = properties;
+  const sessionId = propertiesRecord.sessionID;
+  if (typeof sessionId !== "string" || sessionId.length === 0) return null;
+  return {
+    sessionId,
+    reason: sessionErrorReason(propertiesRecord.error)
+  };
+}
+async function readSessionErrorStream(port, options) {
+  let reader = null;
+  try {
+    const response = await fetch(`${opencodeBase(port)}/event`, {
+      headers: { accept: "text/event-stream" },
+      signal: options.signal
+    });
+    if (!response.ok || !response.body) {
+      return { reason: "unavailable", detail: `HTTP ${response.status}` };
+    }
+    reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const processLine = (line) => {
+      const trimmed = line.trimEnd();
+      if (!trimmed.startsWith("data:")) return;
+      const event = parseSessionErrorFrame(trimmed.slice("data:".length).replace(/^ /, ""));
+      if (event) options.onSessionError(event);
+    };
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return { reason: "ended" };
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) processLine(line);
+    }
+  } catch (err) {
+    if (options.signal.aborted) return { reason: "aborted" };
+    return {
+      reason: "unavailable",
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    if (reader) void reader.cancel().catch(() => void 0);
+  }
+}
 async function reloadProviderCache(port) {
   try {
     const res = await timedFetch(`${opencodeBase(port)}/config`, {
@@ -4384,7 +4543,7 @@ function parseChatGptIdentity(accessToken) {
   const auth = payload["https://api.openai.com/auth"];
   const ownerEmail = typeof profile?.email === "string" ? profile.email.trim() || null : null;
   const planType = typeof auth?.chatgpt_plan_type === "string" ? auth.chatgpt_plan_type.trim() || null : null;
-  return ownerEmail === null && planType === null ? null : { ownerEmail, planType };
+  return ownerEmail === null && planType === null ? null : { ownerEmail, planType, organizationName: null };
 }
 function toWindow2(headers, name) {
   const utilizationHeader = headers.get(`x-codex-${name}-used-percent`);
@@ -5228,6 +5387,10 @@ var DEFAULT_RETRY_POLICY = {
   baseDelayMs: 500,
   maxDelayMs: 3e4
 };
+var SUBAGENT_TELEMETRY_FETCH_TIMEOUT_MS = 2e3;
+var SESSION_ERROR_STREAM_HEALTHY_MS = 5e3;
+var SESSION_ERROR_BUFFER_TTL_MS = SESSION_ERROR_STREAM_HEALTHY_MS;
+var MAX_BUFFERED_SESSION_ERRORS = 256;
 var DEFAULT_PAUSED_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_PAUSED_MAX_WAIT_MS = 10 * 60 * 1e3;
 var DEFAULT_STUCK_QUEUED_MS = 6e4;
@@ -5368,6 +5531,17 @@ var ChannelDriver = class _ChannelDriver {
    * message; it is removed once its in-flight set empties.
    */
   watchers = /* @__PURE__ */ new Map();
+  sessionErrorStream = null;
+  /**
+   * Session-error failures currently being reported; entries are empty at rest
+   * because each handoff deletes its id in `finally`.
+   */
+  sessionErrorHandled = /* @__PURE__ */ new Set();
+  /**
+   * Session errors that arrived before their dispatch was registered. Bounded FIFO
+   * with a short TTL so an unmatched session cannot retain an event indefinitely.
+   */
+  bufferedSessionErrors = /* @__PURE__ */ new Map();
   /**
    * AUTHORITATIVE local dedup (WI-3): Evident message ids that have been
    * dispatched and are still in-flight. A message in this set is never
@@ -5551,6 +5725,13 @@ var ChannelDriver = class _ChannelDriver {
    * no watcher) can resolve the title.
    */
   sessionTitles = /* @__PURE__ */ new Map();
+  /** One best-effort terminal subagent collection per Evident message id. */
+  subagentInvocationCollections = /* @__PURE__ */ new Map();
+  /**
+   * Early snapshots are only liveness hints; they must not become the terminal
+   * collection when the task parts or child transcript have advanced.
+   */
+  subagentInvocationPrefetches = /* @__PURE__ */ new Map();
   /** Serialises drains so a reconnect during a drain doesn't double-process. */
   draining = false;
   /**
@@ -5765,6 +5946,21 @@ var ChannelDriver = class _ChannelDriver {
     }
     return ids;
   }
+  /**
+   * OpenCode user-message ids tracked for other Evident messages in a session.
+   * Excluding this message makes an unattributed later row fail safe; a missing
+   * watcher yields no attributions, per `hasLaterSiblingTurnStarted`'s docblock.
+   */
+  siblingOpencodeMessageIds(watcher, ownEvidentMessageId) {
+    const ids = /* @__PURE__ */ new Set();
+    if (!watcher) return ids;
+    for (const inFlight of watcher.inFlight.values()) {
+      if (inFlight.evidentMessageId !== ownEvidentMessageId) {
+        ids.add(inFlight.opencodeMessageId);
+      }
+    }
+    return ids;
+  }
   /**
    * File-pull work, for `run.ts`'s idle accounting (#559).
    *
@@ -5831,6 +6027,8 @@ var ChannelDriver = class _ChannelDriver {
    */
   stop() {
     this.stopped = true;
+    this.sessionErrorStream?.abort.abort();
+    this.sessionErrorStream = null;
   }
   /**
    * The server clears this request when a new MicroVM identity is recorded, so a
@@ -5905,6 +6103,7 @@ var ChannelDriver = class _ChannelDriver {
    */
   async processConversation(conv) {
     const { sessionId, refusedSessionId, created: sessionCreated } = await this.ensureSession(conv);
+    this.ensureSessionErrorStream();
     const messages = await this.getPendingMessages(conv.id);
     let dispatched = 0;
     let skippedAlreadyDispatched = 0;
@@ -6251,6 +6450,23 @@ var ChannelDriver = class _ChannelDriver {
     if (state === "running" || state === "queued") {
       const ongoing = await isSessionOngoing(this.port, sessionId);
       if (ongoing === true) {
+        if (state === "queued") {
+          const siblingOcIds = this.siblingOpencodeMessageIds(
+            this.watchers.get(sessionId),
+            message.id
+          );
+          if (hasLaterSiblingTurnStarted(messages, ocId ?? "", siblingOcIds)) {
+            this.log({
+              level: "warn",
+              message: `Re-drive: OpenCode already served a later, different Evident message's turn in session ${sessionId.slice(0, 8)} while message ${message.id.slice(0, 8)} produced no reply \u2014 re-dispatching instead of reattaching to someone else's turn`,
+              conversation_id: conv.id,
+              message_id: message.id
+            });
+            this.clearRedriveUnresolved(message.id);
+            void this.postSignal(conv.id, message.id, "redrive_redispatched");
+            return "dispatch";
+          }
+        }
         return this.reattachRedrive(conv, sessionId, message, ocId);
       }
       if (ongoing === false) {
@@ -6340,16 +6556,37 @@ var ChannelDriver = class _ChannelDriver {
       if (state === "done") {
         const title = await this.resolveSessionTitle(sessionId, conv.id);
         const usage = messageUsage(messages, ocId ?? "");
+        const usageAgentName = this.usageAgentName(messages, ocId ?? "");
+        const subagentInvocations = await this.resolveSubagentInvocations(
+          messages,
+          ocId ?? "",
+          message.id
+        );
         this.log({
           level: "info",
           message: `Re-drive: message ${message.id.slice(0, 8)} completed while its row was wrongly reclaimed to pending \u2014 marking done instead of re-dispatching`,
           conversation_id: conv.id,
           message_id: message.id
         });
-        await this.markDone(conv.id, message.id, sessionId, ocId, title, usage);
+        await this.markDone(
+          conv.id,
+          message.id,
+          sessionId,
+          ocId,
+          title,
+          usage,
+          usageAgentName,
+          subagentInvocations
+        );
       } else {
         const error2 = messageError(messages, ocId ?? "") ?? void 0;
         const usage = messageUsage(messages, ocId ?? "");
+        const usageAgentName = this.usageAgentName(messages, ocId ?? "");
+        const subagentInvocations = await this.resolveSubagentInvocations(
+          messages,
+          ocId ?? "",
+          message.id
+        );
         const failure = await this.classifyModelAuthFailure(messages, ocId ?? "");
         this.log({
           level: "error",
@@ -6357,7 +6594,16 @@ var ChannelDriver = class _ChannelDriver {
           conversation_id: conv.id,
           message_id: message.id
         });
-        await this.markFailed(conv.id, message.id, sessionId, error2, usage, failure);
+        await this.markFailed(
+          conv.id,
+          message.id,
+          sessionId,
+          error2,
+          usage,
+          failure,
+          usageAgentName,
+          subagentInvocations
+        );
       }
       if (ocId !== null) {
         await this.reportSubagentAuthFailures(conv.id, ocId, message.id, messages);
@@ -6901,6 +7147,24 @@ var ChannelDriver = class _ChannelDriver {
       ambiguousPinnedSinceMs: 0,
       ambiguousResolved: false
     });
+    const buffered = this.bufferedSessionErrors.get(sessionId);
+    if (!buffered) return;
+    this.bufferedSessionErrors.delete(sessionId);
+    if (this.now() - buffered.receivedAt < SESSION_ERROR_BUFFER_TTL_MS) {
+      this.handleSessionError(buffered.event);
+    }
+  }
+  bufferSessionError(event) {
+    this.bufferedSessionErrors.delete(event.sessionId);
+    this.bufferedSessionErrors.set(event.sessionId, {
+      event,
+      receivedAt: this.now()
+    });
+    while (this.bufferedSessionErrors.size > MAX_BUFFERED_SESSION_ERRORS) {
+      const oldest = this.bufferedSessionErrors.keys().next().value;
+      if (typeof oldest !== "string") break;
+      this.bufferedSessionErrors.delete(oldest);
+    }
   }
   /**
    * Build a fresh `SessionWatcher`. Seeds `lastTickAt`/`lastObservedTickAt`
@@ -7105,6 +7369,7 @@ var ChannelDriver = class _ChannelDriver {
   ensureWatcherRunning(sessionId) {
     const watcher = this.watchers.get(sessionId);
     if (!watcher) return;
+    this.ensureSessionErrorStream();
     if (watcher.loop) return;
     if (watcher.inFlight.size === 0) {
       this.watchers.delete(sessionId);
@@ -7120,6 +7385,154 @@ var ChannelDriver = class _ChannelDriver {
     });
     watcher.loop = loop;
   }
+  ensureSessionErrorStream() {
+    if (this.sessionErrorStream || this.stopped) return;
+    const abort = new AbortController();
+    const loop = this.runSessionErrorStream(abort.signal);
+    this.sessionErrorStream = { abort, loop };
+  }
+  async runSessionErrorStream(signal) {
+    let attempt = 0;
+    let warned = false;
+    while (!this.stopped && !signal.aborted) {
+      const openedAt = this.now();
+      try {
+        const outcome = await readSessionErrorStream(this.port, {
+          signal,
+          onSessionError: (event) => this.handleSessionError(event)
+        });
+        if (outcome.reason === "aborted" || signal.aborted) return;
+        const healthy = this.now() - openedAt >= SESSION_ERROR_STREAM_HEALTHY_MS;
+        if (outcome.reason === "unavailable" || outcome.reason === "ended") {
+          if (!healthy) {
+            const detail = outcome.reason === "unavailable" ? outcome.detail : "stream ended";
+            this.log({
+              level: warned ? "debug" : "warn",
+              message: `OpenCode session-error stream ${warned ? "still unavailable" : "unavailable"} (${detail}); transcript polling remains the evidence path`
+            });
+            warned = true;
+          }
+        }
+        if (healthy) {
+          if (warned) {
+            this.log({
+              level: "info",
+              message: "OpenCode session-error stream reconnected; transcript polling remains the evidence path"
+            });
+            warned = false;
+          }
+          attempt = 0;
+        } else {
+          attempt += 1;
+        }
+        if (this.stopped || signal.aborted) return;
+        await this.sleep(backoffDelay(healthy ? 0 : attempt - 1, this.retry));
+      } catch (err) {
+        if (this.stopped || signal.aborted) return;
+        this.log({
+          level: "error",
+          message: `OpenCode session-error stream failed unexpectedly: ${err instanceof Error ? err.message : String(err)}`
+        });
+        const healthy = this.now() - openedAt >= SESSION_ERROR_STREAM_HEALTHY_MS;
+        const delayAttempt = healthy ? 0 : attempt;
+        attempt = healthy ? 0 : attempt + 1;
+        try {
+          await this.sleep(backoffDelay(delayAttempt, this.retry));
+        } catch (sleepErr) {
+          this.log({
+            level: "error",
+            message: `OpenCode session-error stream backoff failed unexpectedly: ${sleepErr instanceof Error ? sleepErr.message : String(sleepErr)}`
+          });
+        }
+      }
+    }
+  }
+  handleSessionError(event) {
+    try {
+      const watcher = this.watchers.get(event.sessionId);
+      if (!watcher) {
+        this.bufferSessionError(event);
+        this.log({
+          level: "debug",
+          message: `Ignoring session error for unknown session ${event.sessionId.slice(0, 8)}`
+        });
+        return;
+      }
+      if ([...watcher.inFlight.values()].some((message) => message.started && !message.done)) {
+        this.log({
+          level: "debug",
+          message: `A turn is already running in session ${event.sessionId.slice(0, 8)} \u2014 deferring to transcript polling`,
+          conversation_id: watcher.conv.id
+        });
+        return;
+      }
+      const inFlight = [...watcher.inFlight.values()].filter((message) => !message.started && !message.done).sort((a, b) => a.dispatchedAt - b.dispatchedAt)[0];
+      if (!inFlight) {
+        this.bufferSessionError(event);
+        this.log({
+          level: "debug",
+          message: `No queued in-flight turn to correlate with session error in ${event.sessionId.slice(0, 8)}`,
+          conversation_id: watcher.conv.id
+        });
+        return;
+      }
+      if (this.sessionErrorHandled.has(inFlight.evidentMessageId)) return;
+      this.sessionErrorHandled.add(inFlight.evidentMessageId);
+      void this.failFromSessionError(watcher, event, inFlight);
+    } catch (err) {
+      this.log({
+        level: "error",
+        message: `Failed to handle OpenCode session error for ${event.sessionId.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async failFromSessionError(watcher, event, inFlight) {
+    try {
+      const messages = await getSessionMessages(this.port, event.sessionId);
+      const state = messageRunState(messages, inFlight.opencodeMessageId);
+      if (state !== "queued") {
+        this.log({
+          level: "debug",
+          message: `Session error for message ${inFlight.evidentMessageId.slice(0, 8)} observed state ${state}; leaving it to transcript polling`,
+          conversation_id: watcher.conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        return;
+      }
+      this.log({
+        level: "error",
+        message: `OpenCode could not run message ${inFlight.evidentMessageId.slice(0, 8)} in session ${event.sessionId.slice(0, 8)}: ${event.reason}`,
+        conversation_id: watcher.conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      await this.markFailed(
+        watcher.conv.id,
+        inFlight.evidentMessageId,
+        event.sessionId,
+        `OpenCode could not run this turn: ${event.reason}`
+      );
+      inFlight.done = true;
+      this.removeInFlight(watcher, inFlight.evidentMessageId);
+    } catch (err) {
+      if (err instanceof ChannelAuthError) {
+        this.log({
+          level: "warn",
+          message: `OpenCode session error could not mark message ${inFlight.evidentMessageId.slice(0, 8)} failed because authentication failed: ${err.message}; leaving it to transcript polling / the existing give-up path`,
+          conversation_id: watcher.conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+      } else {
+        this.log({
+          level: "warn",
+          message: `OpenCode session error could not mark message ${inFlight.evidentMessageId.slice(0, 8)} failed: ${err instanceof Error ? err.message : String(err)}; leaving it to transcript polling / the existing give-up path`,
+          conversation_id: watcher.conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+      }
+    } finally {
+      this.sessionErrorHandled.delete(inFlight.evidentMessageId);
+    }
+  }
   /**
    * The per-session polling loop (WI-3). Once per tick it:
    *   1. polls `GET /session/:id/message` once and, per in-flight message,
@@ -7232,6 +7645,21 @@ var ChannelDriver = class _ChannelDriver {
     const conv = watcher.conv;
     const state = messageRunState(messages, inFlight.opencodeMessageId);
     const id = inFlight.evidentMessageId;
+    if (messages && collectTaskCalls(messages, inFlight.opencodeMessageId).length > 0 && !this.subagentInvocationPrefetches.has(id)) {
+      void this.resolveSubagentInvocations(
+        messages,
+        inFlight.opencodeMessageId,
+        id,
+        "prefetch"
+      ).catch((err) => {
+        this.log({
+          level: "warn",
+          message: `Best-effort subagent usage prefetch failed for message ${id.slice(0, 8)} \u2014 omitting invocation telemetry: ${err instanceof Error ? err.message : String(err)}`,
+          conversation_id: conv.id,
+          message_id: id
+        });
+      });
+    }
     if (openQuestions.has(id)) inFlight.pausedOnQuestion = true;
     else if (questionsPolledOk) inFlight.pausedOnQuestion = false;
     if (openPermissions.has(id)) inFlight.pausedOnPermission = true;
@@ -7285,6 +7713,12 @@ var ChannelDriver = class _ChannelDriver {
           message_id: inFlight.evidentMessageId
         });
         const usage = messageUsage(messages, inFlight.opencodeMessageId);
+        const usageAgentName = this.usageAgentName(messages ?? [], inFlight.opencodeMessageId);
+        const subagentInvocations = await this.resolveSubagentInvocations(
+          messages,
+          inFlight.opencodeMessageId,
+          inFlight.evidentMessageId
+        );
         const failure = await this.classifyModelAuthFailure(messages, inFlight.opencodeMessageId);
         try {
           await this.markFailed(
@@ -7293,7 +7727,9 @@ var ChannelDriver = class _ChannelDriver {
             sessionId,
             error2,
             usage,
-            failure
+            failure,
+            usageAgentName,
+            subagentInvocations
           );
         } catch (err) {
           if (err instanceof ChannelAuthError) throw err;
@@ -7336,9 +7772,11 @@ var ChannelDriver = class _ChannelDriver {
       this.removeInFlight(watcher, inFlight.evidentMessageId);
       return;
     }
+    const siblingOcIds = this.siblingOpencodeMessageIds(watcher, inFlight.evidentMessageId);
+    const skippedByOpencode = state === "queued" && hasLaterSiblingTurnStarted(messages, inFlight.opencodeMessageId, siblingOcIds);
     const pastStuckBound = this.now() - inFlight.dispatchedAt >= this.stuckQueuedMs;
     const sessionIdle = state === "queued" && !hasRunningAssistantExcept(messages, inFlight.opencodeMessageId);
-    if (state === "queued" && pastStuckBound && sessionIdle && !inFlight.stuckReported) {
+    if (state === "queued" && pastStuckBound && (sessionIdle || skippedByOpencode) && !inFlight.stuckReported) {
       inFlight.stuckReported = true;
       void this.postSignal(conv.id, inFlight.evidentMessageId, "stuck_queued", {
         stuck_for_ms: this.now() - inFlight.dispatchedAt
@@ -7499,7 +7937,7 @@ var ChannelDriver = class _ChannelDriver {
     const hasActivelyRunningSibling = [...watcher.inFlight.values()].some(
       (sib) => sib.evidentMessageId !== inFlight.evidentMessageId && messageRunState(messages, sib.opencodeMessageId) === "running" && !siblingPaused(sib)
     );
-    const queuedBehindRunningSibling = state === "queued" && hasActivelyRunningSibling;
+    const queuedBehindRunningSibling = state === "queued" && hasActivelyRunningSibling && !skippedByOpencode;
     if (!activelyRunning && !queuedBehindRunningSibling && this.now() >= inFlight.deadline) {
       this.log({
         level: "debug",
@@ -7534,6 +7972,12 @@ var ChannelDriver = class _ChannelDriver {
       });
       const title = await this.resolveSessionTitle(sessionId, watcher.conv.id);
       const usage = messageUsage(messages, inFlight.opencodeMessageId);
+      const usageAgentName = this.usageAgentName(messages ?? [], inFlight.opencodeMessageId);
+      const subagentInvocations = await this.resolveSubagentInvocations(
+        messages,
+        inFlight.opencodeMessageId,
+        inFlight.evidentMessageId
+      );
       try {
         await this.markDone(
           conv.id,
@@ -7541,7 +7985,9 @@ var ChannelDriver = class _ChannelDriver {
           sessionId,
           inFlight.opencodeMessageId,
           title,
-          usage
+          usage,
+          usageAgentName,
+          subagentInvocations
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
@@ -7720,6 +8166,12 @@ var ChannelDriver = class _ChannelDriver {
     if (state === "failed" && !restartAborted) {
       const error2 = messageError(messages, ocId ?? "") ?? void 0;
       const usage = messageUsage(messages, ocId ?? "");
+      const usageAgentName = this.usageAgentName(messages, ocId ?? "");
+      const subagentInvocations = await this.resolveSubagentInvocations(
+        messages,
+        ocId ?? "",
+        row.id
+      );
       const failure = await this.classifyModelAuthFailure(messages, ocId ?? "");
       this.log({
         level: "error",
@@ -7728,7 +8180,16 @@ var ChannelDriver = class _ChannelDriver {
         message_id: row.id
       });
       try {
-        await this.markFailed(row.conversation_id, row.id, sessionId, error2, usage, failure);
+        await this.markFailed(
+          row.conversation_id,
+          row.id,
+          sessionId,
+          error2,
+          usage,
+          failure,
+          usageAgentName,
+          subagentInvocations
+        );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         if (err instanceof ChannelTerminalError) {
@@ -7890,7 +8351,22 @@ var ChannelDriver = class _ChannelDriver {
     try {
       const title = await this.resolveSessionTitle(sessionId, row.conversation_id);
       const usage = messageUsage(messages, ocId ?? "");
-      await this.markDone(row.conversation_id, row.id, sessionId, ocId, title, usage);
+      const usageAgentName = this.usageAgentName(messages, ocId ?? "");
+      const subagentInvocations = await this.resolveSubagentInvocations(
+        messages,
+        ocId ?? "",
+        row.id
+      );
+      await this.markDone(
+        row.conversation_id,
+        row.id,
+        sessionId,
+        ocId,
+        title,
+        usage,
+        usageAgentName,
+        subagentInvocations
+      );
     } catch (err) {
       if (err instanceof ChannelAuthError) throw err;
       if (err instanceof ChannelTerminalError) {
@@ -8294,6 +8770,166 @@ var ChannelDriver = class _ChannelDriver {
     if (parent !== void 0) this.sessionParents.set(sessionId, parent);
     return parent;
   }
+  usageAgentName(messages, userMessageId) {
+    const reply = findLastAssistantReplyFor(messages, userMessageId);
+    const mode = reply?.info?.mode;
+    if (typeof mode === "string" && mode.length > 0) return mode;
+    const agent = reply?.info?.agent;
+    return typeof agent === "string" && agent.length > 0 ? agent : null;
+  }
+  async resolveSubagentInvocations(messages, userMessageId, messageId, phase = "terminal") {
+    if (!messages) return void 0;
+    const cache = phase === "prefetch" ? this.subagentInvocationPrefetches : this.subagentInvocationCollections;
+    const cached = cache.get(messageId);
+    if (cached) return cached;
+    const collection = this.buildSubagentInvocations(messages, userMessageId, messageId).catch(
+      (err) => {
+        this.log({
+          level: "warn",
+          message: `Best-effort subagent usage collection failed for message ${messageId.slice(0, 8)} \u2014 omitting invocation telemetry: ${err instanceof Error ? err.message : String(err)}`,
+          message_id: messageId
+        });
+        return void 0;
+      }
+    );
+    cache.set(messageId, collection);
+    const result = await collection;
+    if (result === void 0 && cache.get(messageId) === collection) cache.delete(messageId);
+    return result;
+  }
+  clearSubagentInvocationCaches(messageId) {
+    this.subagentInvocationCollections.delete(messageId);
+    this.subagentInvocationPrefetches.delete(messageId);
+  }
+  async buildSubagentInvocations(messages, userMessageId, messageId) {
+    const rootCalls = collectTaskCalls(messages, userMessageId);
+    if (rootCalls.length === 0) return void 0;
+    const childMessages = /* @__PURE__ */ new Map();
+    const seenCallIds = new Set(rootCalls.map((call) => call.callID));
+    const work = rootCalls.map((call) => ({
+      call,
+      depth: 1
+    }));
+    const payload = [];
+    const fetchChildMessages = (sessionId) => {
+      const cached = childMessages.get(sessionId);
+      if (cached) return cached;
+      const pending = (async () => {
+        try {
+          const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
+          if (!res.ok) {
+            this.log({
+              level: "warn",
+              message: `Best-effort subagent session fetch for message ${messageId.slice(0, 8)} and child session ${sessionId.slice(0, 8)} returned HTTP ${res.status} \u2014 omitting invocation telemetry`,
+              message_id: messageId
+            });
+            return null;
+          }
+          const body = await res.json();
+          if (!Array.isArray(body)) throw new Error("response body was not a message array");
+          return body;
+        } catch (err) {
+          this.log({
+            level: "warn",
+            message: `Best-effort subagent session fetch failed for message ${messageId.slice(0, 8)} and child session ${sessionId.slice(0, 8)} \u2014 omitting invocation telemetry: ${err instanceof Error ? err.message : String(err)}`,
+            message_id: messageId
+          });
+          return null;
+        }
+      })();
+      childMessages.set(sessionId, pending);
+      return pending;
+    };
+    const fetchChildWithoutBlocking = async (sessionId) => {
+      const pending = fetchChildMessages(sessionId);
+      let timer;
+      const timeout = new Promise((resolve4) => {
+        timer = setTimeout(() => {
+          this.log({
+            level: "warn",
+            message: `Best-effort subagent session fetch for message ${messageId.slice(0, 8)} and child session ${sessionId.slice(0, 8)} was slow \u2014 omitting invocation telemetry without delaying completion`,
+            message_id: messageId
+          });
+          resolve4(null);
+        }, SUBAGENT_TELEMETRY_FETCH_TIMEOUT_MS);
+      });
+      try {
+        return await Promise.race([pending, timeout]);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    };
+    while (work.length > 0) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const item of work.splice(0)) {
+        const group = groups.get(item.call.childSessionId) ?? [];
+        group.push(item);
+        groups.set(item.call.childSessionId, group);
+      }
+      const groupResults = await Promise.all(
+        [...groups].map(async ([sessionId, items]) => ({
+          sessionId,
+          items,
+          messages: sessionId === null ? [] : await fetchChildWithoutBlocking(sessionId)
+        }))
+      );
+      for (const { sessionId, items, messages: child } of groupResults) {
+        if (sessionId !== null && child === null) continue;
+        const attribution = sessionId === null ? { invocations: [], unattributed: [] } : attributeTaskCallUsage(
+          child,
+          items.map(({ call }) => ({
+            callID: call.callID,
+            timeStart: call.timeStart,
+            timeEnd: call.timeEnd
+          }))
+        );
+        if (sessionId !== null && attribution.unattributed.length > 0) {
+          this.log({
+            level: "warn",
+            message: `Omitted ${attribution.unattributed.length} unattributable assistant message(s) from subagent usage for message ${messageId.slice(0, 8)} and child session ${sessionId.slice(0, 8)} \u2014 assigned to no invocation window`,
+            message_id: messageId
+          });
+        }
+        const usageByCall = new Map(
+          attribution.invocations.map((invocation) => [invocation.callID, invocation.usage])
+        );
+        const messagesByCall = new Map(
+          attribution.invocations.map((invocation) => [invocation.callID, invocation.messages])
+        );
+        for (const { call, depth } of items) {
+          const usage = usageByCall.get(call.callID) ?? null;
+          payload.push({
+            tool_call_id: call.callID,
+            agent_name: call.subagentName,
+            opencode_session_id: call.childSessionId,
+            parent_opencode_session_id: call.parentSessionId,
+            depth,
+            status: call.status,
+            started_at: call.timeStart === null ? null : new Date(call.timeStart).toISOString(),
+            ended_at: call.timeEnd === null ? null : new Date(call.timeEnd).toISOString(),
+            usage_provider_id: usage?.usage_provider_id ?? call.model?.providerID ?? null,
+            usage_model_id: usage?.usage_model_id ?? call.model?.modelID ?? null,
+            usage_tokens_input: usage?.usage_tokens_input ?? null,
+            usage_tokens_output: usage?.usage_tokens_output ?? null,
+            usage_tokens_reasoning: usage?.usage_tokens_reasoning ?? null,
+            usage_tokens_cache_read: usage?.usage_tokens_cache_read ?? null,
+            usage_tokens_cache_write: usage?.usage_tokens_cache_write ?? null,
+            usage_cost_usd: usage?.usage_cost_usd ?? null
+          });
+          for (const assigned of messagesByCall.get(call.callID) ?? []) {
+            const parentId = assigned.info?.parentID ?? assigned.parentID;
+            if (!parentId) continue;
+            for (const nested of collectTaskCalls([assigned], parentId)) {
+              if (seenCallIds.has(nested.callID)) continue;
+              seenCallIds.add(nested.callID);
+              work.push({ call: nested, depth: depth + 1 });
+            }
+          }
+        }
+      }
+    }
+    return payload.length > 0 ? payload : void 0;
+  }
   /**
    * OpenCode's synchronous default session title (e.g.
    * `"New session - 1737800000000"`), assigned immediately when a session is
@@ -8777,7 +9413,7 @@ var ChannelDriver = class _ChannelDriver {
    *                                    watcher retries next tick within the
    *                                    deadline, Finding 4).
    */
-  async markDone(conversationId, messageId, sessionId, opencodeMessageId, title, usage) {
+  async markDone(conversationId, messageId, sessionId, opencodeMessageId, title, usage, usageAgentName, subagentInvocations) {
     const res = await this.fetchImpl(
       `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
       {
@@ -8793,15 +9429,21 @@ var ChannelDriver = class _ChannelDriver {
           opencode_session_id: sessionId,
           ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {},
           ...title ? { title } : {},
-          ...usage ? usage : {}
+          ...usage ? usage : {},
+          ...usageAgentName ? { usage_agent_name: usageAgentName } : {},
+          ...subagentInvocations && subagentInvocations.length > 0 ? { subagent_invocations: subagentInvocations } : {}
         })
       }
     );
     this.assertAuth(res, "marking message as done");
-    if (res.ok) return;
+    if (res.ok) {
+      this.clearSubagentInvocationCaches(messageId);
+      return;
+    }
     if (isRetryableStatus(res.status)) {
       throw new Error(`marking message as done: HTTP ${res.status}`);
     }
+    this.clearSubagentInvocationCaches(messageId);
     throw new ChannelTerminalError(`marking message as done: HTTP ${res.status}`, res.status);
   }
   /**
@@ -8816,7 +9458,7 @@ var ChannelDriver = class _ChannelDriver {
    *     exists but is wedged, so the next attempt must get a fresh one
    *     instead of reusing it — see WI-1's server-side null-clearing PATCH).
    */
-  async markFailed(conversationId, messageId, sessionId, error2, usage, failure) {
+  async markFailed(conversationId, messageId, sessionId, error2, usage, failure, usageAgentName, subagentInvocations) {
     const body = { status: "failed" };
     if (sessionId === null) {
       body.opencode_session_id = null;
@@ -8825,23 +9467,33 @@ var ChannelDriver = class _ChannelDriver {
     }
     if (error2 !== void 0) body.error = error2;
     if (usage) Object.assign(body, usage);
+    if (usageAgentName) body.usage_agent_name = usageAgentName;
+    if (subagentInvocations && subagentInvocations.length > 0) {
+      body.subagent_invocations = subagentInvocations;
+    }
     if (failure) {
       body.failure_kind = failure.kind;
       body.failure_provider_id = failure.providerId;
       body.failure_model_id = failure.modelId;
       body.failure_reason = failure.reason;
     }
-    await this.callWithRetry(
-      "marking message as failed",
-      () => this.fetchImpl(
-        `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
-        {
-          method: "PATCH",
-          headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
-          body: JSON.stringify(body)
-        }
-      )
-    );
+    try {
+      await this.callWithRetry(
+        "marking message as failed",
+        () => this.fetchImpl(
+          `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
+          {
+            method: "PATCH",
+            headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          }
+        )
+      );
+    } catch (err) {
+      if (err instanceof ChannelTerminalError) this.clearSubagentInvocationCaches(messageId);
+      throw err;
+    }
+    this.clearSubagentInvocationCaches(messageId);
   }
   /**
    * Classify an errored turn as a model-auth failure (#736 P1-4), for `markFailed`.
@@ -11269,6 +11921,7 @@ async function run(options) {
             logActivity(state, { type: "info", level: "warn", message: versionWarning });
           }
         }
+        await reloadProviderCache(state.port);
         const noProviderWarning = buildNoProviderWarning(
           await hasAnyConfiguredProvider(state.port)
         );