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

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(() => "");
@@ -670,12 +683,15 @@ async function resolveAgentIdFromKey(authHeader) {
   }
 }
 var BEST_EFFORT_NOTIFY_TIMEOUT_MS = 2e3;
-async function notifyAgentDisconnected(agentId, authHeader) {
-  const apiUrl = getApiUrlConfig();
+async function postBestEffort(path, authHeader, body) {
   try {
-    const response = await fetch(`${apiUrl}/runners/${agentId}/disconnect`, {
+    const apiUrl = getApiUrlConfig();
+    const headers = { Authorization: authHeader };
+    if (body !== void 0) headers["Content-Type"] = "application/json";
+    const response = await fetch(`${apiUrl}${path}`, {
       method: "POST",
-      headers: { Authorization: authHeader },
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
       signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
     });
     if (!response.ok) {
@@ -687,73 +703,32 @@ async function notifyAgentDisconnected(agentId, authHeader) {
     }
     return { ok: true };
   } catch (error2) {
-    return { ok: false, error: describeBestEffortError(error2) };
+    return { ok: false, error: describeTimeoutError(error2, BEST_EFFORT_NOTIFY_TIMEOUT_MS) };
   }
 }
-function describeBestEffortError(error2) {
+function describeTimeoutError(error2, timeoutMs) {
   const name = error2?.name;
   if (name === "TimeoutError" || name === "AbortError") {
-    return `timed out after ${BEST_EFFORT_NOTIFY_TIMEOUT_MS}ms`;
+    return `timed out after ${timeoutMs}ms`;
   }
   return error2 instanceof Error ? error2.message : String(error2);
 }
+async function notifyAgentDisconnected(agentId, authHeader) {
+  return postBestEffort(`/runners/${agentId}/disconnect`, authHeader);
+}
 async function reportMicrovmId(agentId, authHeader, microvmId) {
-  try {
-    const apiUrl = getApiUrlConfig();
-    const response = await fetch(`${apiUrl}/runners/${agentId}/microvm`, {
-      method: "POST",
-      headers: { Authorization: authHeader, "Content-Type": "application/json" },
-      body: JSON.stringify({ microvm_id: microvmId }),
-      signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      const serverMessage = await readErrorMessage(response);
-      return {
-        ok: false,
-        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
-      };
-    }
-    return { ok: true };
-  } catch (error2) {
-    return { ok: false, error: describeBestEffortError(error2) };
-  }
+  return postBestEffort(`/runners/${agentId}/microvm`, authHeader, { microvm_id: microvmId });
 }
 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();
-    const response = await fetch(`${apiUrl}/runners/${agentId}/claude-usage`, {
-      method: "POST",
-      headers: { Authorization: authHeader, "Content-Type": "application/json" },
-      body: JSON.stringify({
-        five_hour: toReportedWindow(snapshot.fiveHour),
-        seven_day: toReportedWindow(snapshot.sevenDay),
-        owner: toReportedOwner(snapshot)
-      }),
-      signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      const serverMessage = await readErrorMessage(response);
-      return {
-        ok: false,
-        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
-      };
-    }
-    return { ok: true };
-  } catch (error2) {
-    return { ok: false, error: describeBestEffortError(error2) };
-  }
+  return postBestEffort(`/runners/${agentId}/claude-usage`, authHeader, {
+    five_hour: toReportedWindow(snapshot.fiveHour),
+    seven_day: toReportedWindow(snapshot.sevenDay),
+    subscription: toReportedSubscription(snapshot.subscription)
+  });
 }
 function toReportedOpenAiWindow(window) {
   if (!window) return null;
@@ -763,69 +738,26 @@ 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();
-    const response = await fetch(`${apiUrl}/runners/${agentId}/openai-usage`, {
-      method: "POST",
-      headers: { Authorization: authHeader, "Content-Type": "application/json" },
-      body: JSON.stringify({
-        primary: toReportedOpenAiWindow(snapshot.primary),
-        secondary: toReportedOpenAiWindow(snapshot.secondary),
-        has_credits: snapshot.hasCredits,
-        credits_unlimited: snapshot.creditsUnlimited,
-        subscription: toReportedOpenAiSubscription(snapshot)
-      }),
-      signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      const serverMessage = await readErrorMessage(response);
-      return {
-        ok: false,
-        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
-      };
-    }
-    return { ok: true };
-  } catch (error2) {
-    return { ok: false, error: describeBestEffortError(error2) };
-  }
+  return postBestEffort(`/runners/${agentId}/openai-usage`, authHeader, {
+    primary: toReportedOpenAiWindow(snapshot.primary),
+    secondary: toReportedOpenAiWindow(snapshot.secondary),
+    has_credits: snapshot.hasCredits,
+    credits_unlimited: snapshot.creditsUnlimited,
+    subscription: toReportedSubscription(snapshot.subscription)
+  });
 }
 async function reportResourceUsage(agentId, authHeader, usage) {
-  try {
-    const apiUrl = getApiUrlConfig();
-    const response = await fetch(`${apiUrl}/runners/${agentId}/resource-usage`, {
-      method: "POST",
-      headers: { Authorization: authHeader, "Content-Type": "application/json" },
-      body: JSON.stringify({
-        cpu_percent: usage.cpuPercent,
-        cpu_peak_percent: usage.cpuPeakPercent,
-        cpu_count: usage.cpuCount,
-        memory_total_bytes: usage.memoryTotalBytes,
-        memory_available_bytes: usage.memoryAvailableBytes,
-        disk_total_bytes: usage.diskTotalBytes,
-        disk_free_bytes: usage.diskFreeBytes,
-        opencode_db_bytes: usage.opencodeDbBytes
-      }),
-      signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      const serverMessage = await readErrorMessage(response);
-      return {
-        ok: false,
-        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
-      };
-    }
-    return { ok: true };
-  } catch (error2) {
-    return { ok: false, error: describeBestEffortError(error2) };
-  }
+  return postBestEffort(`/runners/${agentId}/resource-usage`, authHeader, {
+    cpu_percent: usage.cpuPercent,
+    cpu_peak_percent: usage.cpuPeakPercent,
+    cpu_count: usage.cpuCount,
+    memory_total_bytes: usage.memoryTotalBytes,
+    memory_available_bytes: usage.memoryAvailableBytes,
+    disk_total_bytes: usage.diskTotalBytes,
+    disk_free_bytes: usage.diskFreeBytes,
+    opencode_db_bytes: usage.opencodeDbBytes
+  });
 }
 async function getAgentInfo(agentId, authHeader) {
   const apiUrl = getApiUrlConfig();
@@ -877,13 +809,6 @@ function authLabelFor(credentials2) {
   }
   return "user token";
 }
-function describeFetchError(error2) {
-  const name = error2?.name;
-  if (name === "TimeoutError" || name === "AbortError") {
-    return `timed out after ${STATUS_TIMEOUT_MS}ms waiting for a response`;
-  }
-  return error2 instanceof Error ? error2.message : String(error2);
-}
 async function checkStatus(jsonMode) {
   const apiUrl = getApiUrlConfig();
   const credentials2 = await getAuthCredentials();
@@ -911,7 +836,7 @@ async function checkStatus(jsonMode) {
       endpoint: apiUrl,
       authLabel: authLabelFor(credentials2),
       reason: "unreachable",
-      error: `Could not reach ${apiUrl}: ${describeFetchError(error2)}. The credentials were NOT validated.`,
+      error: `Could not reach ${apiUrl}: ${describeTimeoutError(error2, STATUS_TIMEOUT_MS)}. The credentials were NOT validated.`,
       exitCode: 75
     };
   }
@@ -1097,7 +1022,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 +1034,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 +1083,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
   };
 }
@@ -1253,11 +1178,11 @@ function stripQuery(url) {
 }
 
 // src/commands/run.ts
-import ora3 from "ora";
+import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.0.0" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.4.1-dev.0c8854e" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -1731,6 +1656,11 @@ function isSessionDbRecoveryRecord(value) {
   );
 }
 
+// src/lib/opencode/auth.ts
+function buildOpenCodeBasicAuthHeader(password) {
+  return `Basic ${Buffer.from(["opencode", password].join(":")).toString("base64")}`;
+}
+
 // src/lib/opencode/health.ts
 async function checkOpenCodeHealth(port) {
   try {
@@ -1748,6 +1678,27 @@ async function checkOpenCodeHealth(port) {
     return { healthy: false, error: message };
   }
 }
+async function checkOpenCode2Health(port, password) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/global/health`, {
+      headers: {
+        Authorization: buildOpenCodeBasicAuthHeader(password)
+      },
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (response.status === 401) {
+      return { healthy: false, authFailed: true, error: "HTTP 401" };
+    }
+    if (!response.ok) {
+      return { healthy: false, error: `HTTP ${response.status}` };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { healthy: true, version: data.version };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
+    return { healthy: false, error: message };
+  }
+}
 async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
   const startTime = Date.now();
   while (Date.now() - startTime < timeoutMs) {
@@ -1759,6 +1710,61 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
   }
   return { healthy: false, error: "Timeout waiting for OpenCode to be healthy" };
 }
+async function waitForOpenCode2Health(port, password, timeoutMs = 3e4) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    const health = await checkOpenCode2Health(port, password);
+    if (health.healthy || health.authFailed) {
+      return health;
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+  }
+  return { healthy: false, error: "Timeout waiting for OpenCode to be healthy" };
+}
+
+// src/lib/http-timeout.ts
+var REQUEST_TIMEOUT_MS = 6e4;
+function withRequestTimeout(fetchImpl, timeoutMs) {
+  return ((input, init) => fetchImpl(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+}
+
+// src/lib/opencode/client.ts
+function redactPassword(message, password) {
+  return message.replaceAll(password, "[redacted]");
+}
+function createOpenCodeClient(options) {
+  const password = options.password ?? null;
+  const fetchImpl = withRequestTimeout(options.fetchImpl ?? fetch, REQUEST_TIMEOUT_MS);
+  const baseUrl = `http://127.0.0.1:${options.port}`;
+  return {
+    port: options.port,
+    version: options.version,
+    password,
+    async request(path, init, requestOptions) {
+      const requestInit = options.version === "v2" && password !== null ? (() => {
+        const headers = new Headers(init?.headers);
+        headers.set("Authorization", buildOpenCodeBasicAuthHeader(password));
+        return { ...init, headers };
+      })() : init;
+      try {
+        const response = await fetchImpl(`${baseUrl}${path}`, requestInit);
+        if (!response.ok && !requestOptions?.allowStatuses?.includes(response.status)) {
+          const body = await response.text();
+          throw new Error(
+            `OpenCode request failed: HTTP ${response.status}${body ? `: ${body}` : ""}`
+          );
+        }
+        return response;
+      } catch (error2) {
+        if (options.version === "v2" && password !== null) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          throw new Error(redactPassword(message, password));
+        }
+        throw error2;
+      }
+    }
+  };
+}
 
 // src/lib/opencode/session-db-boot.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -2422,15 +2428,23 @@ function isQueueValidatedVersion(version2) {
   if (!version2) return false;
   return QUEUE_VALIDATED_OPENCODE_VERSIONS.includes(version2);
 }
-function buildOpenCodeVersionWarning(version2) {
-  if (isQueueValidatedVersion(version2)) return null;
-  const detected = version2 ? `v${version2}` : "unknown";
+function buildOpenCodeVersionWarning(version2, major) {
+  if (major === "v2") return null;
   const validated = QUEUE_VALIDATED_OPENCODE_VERSIONS.map((v) => `v${v}`).join(", ");
-  return `Warning: opencode ${detected} is not a queue-validated version (validated: ${validated}). Native message queuing \u2014 which channel (Slack) message handling relies on \u2014 is unverified on this version; queued/follow-up messages may behave unexpectedly. Continuing anyway. Bumping the validated set requires re-running the queue validation.`;
+  if (!version2) {
+    return `Warning: the running opencode's version could not be determined from its health response, so queue validation could not be checked (validated: ${validated}). Compare against \`opencode --version\`; continuing anyway.`;
+  }
+  if (isQueueValidatedVersion(version2)) return null;
+  return `Warning: opencode v${version2} is not a queue-validated version (validated: ${validated}). Native message queuing \u2014 which channel (Slack) message handling relies on \u2014 is unverified on this version; queued/follow-up messages may behave unexpectedly. Continuing anyway. Bumping the validated set requires re-running the queue validation.`;
+}
+function reportedOpenCodeVersion(input) {
+  if (!input.connected) return null;
+  return input.version || `${input.major}-unknown`;
 }
 
 // src/lib/opencode/process.ts
 import { execSync, spawn as spawn3 } from "child_process";
+import { randomBytes } from "node:crypto";
 
 // src/lib/process-stop.ts
 async function stopProcessAndWait(child, timeoutMs, sendTerm, sendKill) {
@@ -2489,6 +2503,17 @@ async function stopProcessAndWait(child, timeoutMs, sendTerm, sendKill) {
 // src/lib/opencode/process.ts
 var OPENCODE_PORT_RANGE = [4096, 4097, 4098, 4099, 4100];
 var VALID_OPENCODE_LOG_LEVELS = /* @__PURE__ */ new Set(["DEBUG", "INFO", "WARN", "ERROR"]);
+var VALID_OPENCODE2_LOG_LEVELS = /* @__PURE__ */ new Set([
+  "all",
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "warning",
+  "error",
+  "fatal",
+  "none"
+]);
 function resolveOpenCodeLogLevel(env) {
   const raw = env.OPENCODE_LOG_LEVEL;
   if (!raw) return "INFO";
@@ -2499,6 +2524,16 @@ function resolveOpenCodeLogLevel(env) {
   );
   return "INFO";
 }
+function resolveOpenCode2LogLevel(env) {
+  const raw = env.OPENCODE_LOG_LEVEL;
+  if (!raw) return "info";
+  const lower = raw.toLowerCase();
+  if (VALID_OPENCODE2_LOG_LEVELS.has(lower)) return lower;
+  console.warn(
+    `startOpenCode2: ignoring invalid OPENCODE_LOG_LEVEL "${raw}" (expected all|trace|debug|info|warn|warning|error|fatal|none) \u2014 using info`
+  );
+  return "info";
+}
 function getProcessCwd(pid) {
   const platform = process.platform;
   try {
@@ -2681,6 +2716,37 @@ async function startOpenCode(port, options = {}) {
   });
   return child;
 }
+async function startOpenCode2(port, options = {}) {
+  const password = randomBytes(24).toString("hex");
+  let command = "opencode2";
+  const logLevel = options.inheritStdio ? ["--log-level", resolveOpenCode2LogLevel(process.env)] : [];
+  let args = ["serve", "--port", port.toString(), "--hostname", "127.0.0.1", ...logLevel];
+  try {
+    execSync("which opencode2", { stdio: "ignore" });
+  } catch {
+    command = "npx";
+    args = [
+      "-y",
+      "-p",
+      "@opencode-ai/cli@beta",
+      "--",
+      "opencode2",
+      "serve",
+      "--port",
+      port.toString(),
+      "--hostname",
+      "127.0.0.1",
+      ...logLevel
+    ];
+  }
+  const child = spawn3(command, args, {
+    env: { ...process.env, OPENCODE_SERVER_PASSWORD: password },
+    detached: true,
+    stdio: options.inheritStdio ? "inherit" : "ignore",
+    cwd: process.cwd()
+  });
+  return { child, password };
+}
 function stopOpenCodeAndWait(opencodeProcess, timeoutMs) {
   const sendSignal = (signal) => {
     if (process.platform === "win32") {
@@ -2828,27 +2894,500 @@ function buildNoProviderWarning(hasProvider) {
   return "Warning: opencode has no authenticated model provider configured, so it won't be able to answer prompts. Run `opencode auth login` to set one up (see https://opencode.ai for details).";
 }
 
-// src/lib/http-timeout.ts
-var REQUEST_TIMEOUT_MS = 6e4;
-function withRequestTimeout(fetchImpl, timeoutMs) {
-  return ((input, init) => fetchImpl(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+// src/lib/opencode/session-v2.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function adaptTime(value) {
+  if (!isRecord(value)) return void 0;
+  const created = finiteNumber(value.created);
+  const completed = finiteNumber(value.completed);
+  if (created === void 0 && completed === void 0) return void 0;
+  return {
+    ...created !== void 0 ? { created } : {},
+    ...completed !== void 0 ? { completed } : {}
+  };
+}
+function adaptTokens(value) {
+  if (!isRecord(value)) return void 0;
+  const input = finiteNumber(value.input);
+  const output = finiteNumber(value.output);
+  const reasoning = finiteNumber(value.reasoning);
+  const cache = isRecord(value.cache) ? {
+    ...finiteNumber(value.cache.read) !== void 0 ? { read: finiteNumber(value.cache.read) } : {},
+    ...finiteNumber(value.cache.write) !== void 0 ? { write: finiteNumber(value.cache.write) } : {}
+  } : void 0;
+  if (input === void 0 && output === void 0 && reasoning === void 0 && !cache) {
+    return void 0;
+  }
+  return {
+    ...input !== void 0 ? { input } : {},
+    ...output !== void 0 ? { output } : {},
+    ...reasoning !== void 0 ? { reasoning } : {},
+    ...cache ? { cache } : {}
+  };
+}
+function adaptMessageInfo(value, role) {
+  const info = {
+    id: value.id,
+    role
+  };
+  const time = adaptTime(value.time);
+  if (time) info.time = time;
+  if (typeof value.finish === "string") info.finish = value.finish;
+  if ("error" in value) info.error = value.error;
+  if (typeof value.agent === "string") info.agent = value.agent;
+  if (isRecord(value.model)) {
+    if (typeof value.model.id === "string") info.modelID = value.model.id;
+    if (typeof value.model.providerID === "string") info.providerID = value.model.providerID;
+  }
+  if (typeof value.cost === "number" && Number.isFinite(value.cost)) info.cost = value.cost;
+  const tokens = adaptTokens(value.tokens);
+  if (tokens) info.tokens = tokens;
+  return info;
+}
+function adaptV2Message(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.type !== "string") {
+    return null;
+  }
+  if (value.type === "user") {
+    if (typeof value.text !== "string") return null;
+    return {
+      info: adaptMessageInfo(value, "user"),
+      parts: [{ type: "text", text: value.text }]
+    };
+  }
+  if (value.type !== "assistant" || !Array.isArray(value.content)) return null;
+  const parts = [];
+  for (const content of value.content) {
+    if (!isRecord(content) || typeof content.type !== "string") return null;
+    if (content.type === "text") {
+      if (typeof content.text !== "string") return null;
+      parts.push({ type: "text", text: content.text });
+    } else {
+      parts.push({ type: content.type });
+    }
+  }
+  return {
+    info: adaptMessageInfo(value, "assistant"),
+    parts
+  };
+}
+function adaptFormTool(value) {
+  if (!isRecord(value) || typeof value.messageID !== "string" || typeof value.id !== "string") {
+    return void 0;
+  }
+  return { messageID: value.messageID, callID: value.id };
+}
+function adaptV2FormWire(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.sessionID !== "string") {
+    return null;
+  }
+  return value;
+}
+function adaptV2FormField(value, header) {
+  if (!isRecord(value)) return null;
+  const question = typeof value.title === "string" ? value.title : typeof value.question === "string" ? value.question : typeof value.key === "string" ? value.key : null;
+  if (!question) return null;
+  const options = Array.isArray(value.options) ? value.options.flatMap((option) => {
+    if (!isRecord(option)) return [];
+    const label = typeof option.label === "string" ? option.label : typeof option.value === "string" ? option.value : null;
+    if (!label) return [];
+    return [
+      {
+        label,
+        description: typeof option.description === "string" ? option.description : ""
+      }
+    ];
+  }) : [];
+  return { question, header, options };
+}
+function adaptV2Form(value) {
+  const form = adaptV2FormWire(value);
+  if (!form || !Array.isArray(form.fields)) return null;
+  const header = typeof form.title === "string" ? form.title : "";
+  const questions = form.fields.map((field) => adaptV2FormField(field, header)).filter((question) => question !== null);
+  if (questions.length === 0) return null;
+  const tool = isRecord(form.metadata) ? adaptFormTool(form.metadata.tool) : void 0;
+  return {
+    id: form.id,
+    sessionID: form.sessionID,
+    questions,
+    ...tool ? { tool } : {},
+    raw: form
+  };
+}
+function adaptV2FormList(value) {
+  if (!isRecord(value) || !Array.isArray(value.data)) return null;
+  return value.data.map(adaptV2Form).filter((form) => form !== null);
+}
+function adaptPattern(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (Array.isArray(value) && value.every((pattern) => typeof pattern === "string")) {
+    return value;
+  }
+  return void 0;
+}
+function adaptV2PermissionWire(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.sessionID !== "string") {
+    return null;
+  }
+  if (typeof value.permission !== "string" && typeof value.action !== "string") return null;
+  return value;
+}
+function adaptV2Permission(value) {
+  const permission = adaptV2PermissionWire(value);
+  if (!permission) return null;
+  const type = permission.permission ?? permission.action;
+  if (!type) return null;
+  const pattern = adaptPattern(permission.pattern) ?? adaptPattern(permission.patterns) ?? adaptPattern(permission.resources);
+  const time = isRecord(permission.time) ? finiteNumber(permission.time.created) !== void 0 ? { created: finiteNumber(permission.time.created) } : void 0 : void 0;
+  return {
+    id: permission.id,
+    type,
+    sessionID: permission.sessionID,
+    metadata: isRecord(permission.metadata) ? permission.metadata : {},
+    raw: permission,
+    ...pattern !== void 0 ? { pattern } : {},
+    ...typeof permission.messageID === "string" ? { messageID: permission.messageID } : {},
+    ...typeof permission.callID === "string" ? { callID: permission.callID } : {},
+    ...typeof permission.title === "string" ? { title: permission.title } : {},
+    ...time ? { time } : {}
+  };
+}
+function adaptV2PermissionList(value) {
+  if (!isRecord(value) || !Array.isArray(value.data)) return null;
+  return value.data.map(adaptV2Permission).filter((permission) => permission !== null);
+}
+function adaptV2Session(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || value.id.length === 0) return null;
+  const time = isRecord(value.time) ? {
+    ...finiteNumber(value.time.created) !== void 0 ? { created: finiteNumber(value.time.created) } : {},
+    ...finiteNumber(value.time.updated) !== void 0 ? { updated: finiteNumber(value.time.updated) } : {}
+  } : void 0;
+  return {
+    id: value.id,
+    ...typeof value.title === "string" ? { title: value.title } : {},
+    ...typeof value.parentID === "string" ? { parentID: value.parentID } : {},
+    ...time && Object.keys(time).length > 0 ? { time } : {}
+  };
+}
+function adaptV2SessionList(value) {
+  if (!isRecord(value) || !Array.isArray(value.data) || !isRecord(value.cursor)) return null;
+  return {
+    data: value.data.map(adaptV2Session).filter((session) => session !== null),
+    cursor: value.cursor
+  };
+}
+function adaptV2Location(value) {
+  const candidates = [
+    value,
+    isRecord(value) ? value.data : void 0,
+    isRecord(value) ? value.location : void 0
+  ];
+  for (const candidate of candidates) {
+    if (!isRecord(candidate) || typeof candidate.directory !== "string") continue;
+    const directory = candidate.directory.trim();
+    if (directory) return directory;
+  }
+  return null;
+}
+function adaptV2Messages(value) {
+  if (!isRecord(value) || !Array.isArray(value.data)) return [];
+  return value.data.slice().reverse().map(adaptV2Message).filter((message) => message !== null);
+}
+async function readJson(response) {
+  try {
+    return await response.json();
+  } catch (error2) {
+    throw new Error(
+      `OpenCode V2 response was not valid JSON: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+}
+async function readData(client, path, init) {
+  const response = await client.request(path, init);
+  const body = await readJson(response);
+  if (!isRecord(body) || !("data" in body)) {
+    throw new Error(`OpenCode V2 response for ${path} was missing its data envelope`);
+  }
+  return body.data;
+}
+var OpenCodeV2PromptAckError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenCodeV2PromptAckError";
+  }
+};
+async function getOpenCodeDirectoryV2(client) {
+  try {
+    return adaptV2Location(await readJson(await client.request("/api/location")));
+  } catch (error2) {
+    console.error(
+      `[getOpenCodeDirectoryV2] GET /api/location failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function createV2Session(client, directory) {
+  const data = await readData(client, "/api/session", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ location: { directory } })
+  });
+  if (!isRecord(data) || typeof data.id !== "string" || data.id.length === 0) {
+    throw new Error("OpenCode V2 create session response was missing data.id");
+  }
+  return data.id;
+}
+async function getV2Session(client, sessionId) {
+  const data = await readData(client, `/api/session/${encodeURIComponent(sessionId)}`);
+  const session = adaptV2Session(data);
+  if (!session) throw new Error("OpenCode V2 get session response contained an invalid session");
+  return session;
+}
+async function listV2SessionPage(client, cursor) {
+  const path = cursor ? `/api/session?cursor=${encodeURIComponent(cursor)}` : "/api/session";
+  try {
+    return adaptV2SessionList(await readJson(await client.request(path)));
+  } catch (error2) {
+    console.error(
+      `[listV2SessionPage] GET ${path} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function listV2Sessions(client) {
+  const sessions = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  let hasNextPage = true;
+  try {
+    while (hasNextPage) {
+      const page = await listV2SessionPage(client, cursor);
+      if (!page) return null;
+      sessions.push(...page.data);
+      const next = page.cursor.next;
+      if (next === void 0 || next === null) {
+        hasNextPage = false;
+        continue;
+      }
+      if (typeof next !== "string" || next.length === 0 || seenCursors.has(next)) {
+        throw new Error("OpenCode V2 session list contained an invalid next cursor");
+      }
+      seenCursors.add(next);
+      cursor = next;
+    }
+    return sessions;
+  } catch (error2) {
+    console.error(
+      `[listV2Sessions] session pagination failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function deleteV2Session(client, sessionId) {
+  try {
+    await client.request(`/api/session/${encodeURIComponent(sessionId)}`, { method: "DELETE" });
+    return true;
+  } catch (error2) {
+    console.error(
+      `[deleteV2Session] DELETE /api/session/${sessionId} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return false;
+  }
+}
+async function v2SessionExists(client, sessionId) {
+  try {
+    const response = await client.request(
+      `/api/session/${encodeURIComponent(sessionId)}`,
+      void 0,
+      { allowStatuses: [404] }
+    );
+    return response.status === 404 ? false : true;
+  } catch (error2) {
+    console.error(
+      `[v2SessionExists] GET /api/session/${sessionId} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function sendV2Prompt(client, sessionId, text) {
+  const path = `/api/session/${encodeURIComponent(sessionId)}/prompt`;
+  const response = await client.request(path, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ text, delivery: "queue" })
+  });
+  let body;
+  try {
+    body = await readJson(response);
+  } catch (error2) {
+    throw new OpenCodeV2PromptAckError(
+      `OpenCode V2 prompt response could not be read: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  const data = isRecord(body) && "data" in body ? body.data : void 0;
+  if (!isRecord(data) || typeof data.id !== "string" || data.id.length === 0) {
+    throw new OpenCodeV2PromptAckError("OpenCode V2 prompt response was missing data.id");
+  }
+  return data.id;
+}
+async function getV2SessionMessages(client, sessionId) {
+  const path = `/api/session/${encodeURIComponent(sessionId)}/message?order=desc&limit=200`;
+  try {
+    const body = await readJson(await client.request(path));
+    if (!isRecord(body) || !Array.isArray(body.data) || !isRecord(body.cursor)) return null;
+    return adaptV2Messages(body);
+  } catch (error2) {
+    console.error(
+      `[getV2SessionMessages] GET ${path} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function listV2Forms(client, sessionId) {
+  const path = `/api/session/${encodeURIComponent(sessionId)}/form`;
+  try {
+    return adaptV2FormList(await readJson(await client.request(path)));
+  } catch (error2) {
+    console.error(
+      `[listV2Forms] GET ${path} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function listV2Permissions(client, sessionId) {
+  const path = `/api/session/${encodeURIComponent(sessionId)}/permission`;
+  try {
+    return adaptV2PermissionList(await readJson(await client.request(path)));
+  } catch (error2) {
+    console.error(
+      `[listV2Permissions] GET ${path} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function getV2ActiveSessions(client) {
+  try {
+    const body = await readJson(await client.request("/api/session/active"));
+    if (!isRecord(body) || !isRecord(body.data)) return null;
+    return body.data;
+  } catch (error2) {
+    console.error(
+      `[getV2ActiveSessions] GET /api/session/active failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function isV2SessionOngoing(client, sessionId) {
+  const activeSessions = await getV2ActiveSessions(client);
+  if (activeSessions === null) return null;
+  return Object.prototype.hasOwnProperty.call(activeSessions, sessionId);
+}
+function sessionErrorReason(value) {
+  if (typeof value === "string" && value.trim()) return value.trim().slice(0, 500);
+  if (isRecord(value)) {
+    const data = isRecord(value.data) ? value.data : void 0;
+    const reason = typeof data?.message === "string" && data.message || typeof value.message === "string" && value.message || typeof value.name === "string" && value.name;
+    if (reason) return reason.replace(/\s+/g, " ").trim().slice(0, 500);
+  }
+  return "OpenCode reported a session error with no details";
+}
+function adaptV2SessionErrorEvent(value) {
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch (error2) {
+      void error2;
+      return null;
+    }
+  }
+  if (!isRecord(parsed)) return null;
+  try {
+    const establishedShape = parseSessionErrorFrame(JSON.stringify(parsed));
+    if (establishedShape) return establishedShape;
+  } catch (error2) {
+    void error2;
+  }
+  const candidates = [parsed, parsed.payload, parsed.data].filter(isRecord);
+  for (const event of candidates) {
+    if (event.type !== "session.error") continue;
+    const properties = [event.properties, event.data, event].find(isRecord);
+    if (!properties) continue;
+    const sessionId = typeof properties.sessionID === "string" && properties.sessionID || typeof properties.sessionId === "string" && properties.sessionId;
+    if (!sessionId) continue;
+    return {
+      sessionId,
+      reason: sessionErrorReason(properties.error ?? properties)
+    };
+  }
+  return null;
+}
+async function readV2SessionErrorStream(client, options) {
+  let reader = null;
+  try {
+    const response = await client.request("/api/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 = adaptV2SessionErrorEvent(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 (error2) {
+    if (options.signal.aborted) return { reason: "aborted" };
+    return {
+      reason: "unavailable",
+      detail: error2 instanceof Error ? error2.message : String(error2)
+    };
+  } finally {
+    if (reader) void reader.cancel().catch(() => void 0);
+  }
 }
 
 // src/lib/opencode/session.ts
+var ALL_HTTP_STATUSES = Array.from({ length: 500 }, (_, index) => index + 100);
 function timedFetch(input, init) {
   return withRequestTimeout(fetch, REQUEST_TIMEOUT_MS)(input, init);
 }
+function requestWithClient(port, client, path, init, options) {
+  return client ? client.request(path, init, options) : timedFetch(`${opencodeBase(port)}${path}`, init);
+}
 function opencodeBase(port) {
   return `http://127.0.0.1:${port}`;
 }
-async function getOpenCodeDirectory(port) {
+async function getOpenCodeDirectory(port, client) {
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/path`);
+    const res = await requestWithClient(port, client, "/path");
     if (!res.ok) return null;
     const body = await res.json();
     const dir = typeof body.directory === "string" && body.directory || typeof body.worktree === "string" && body.worktree || typeof body.path?.cwd === "string" && body.path.cwd || typeof body.path?.directory === "string" && body.path.directory || null;
     return dir && dir.trim() ? dir.trim() : null;
-  } catch {
+  } catch (error2) {
+    console.error(
+      `[getOpenCodeDirectory] GET /path failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
     return null;
   }
 }
@@ -2892,16 +3431,48 @@ function isAssistantInFlight(m) {
   if (completedOf(m) == null) return true;
   return finishOf(m) === "tool-calls";
 }
-async function getSessionMessages(port, sessionId) {
+async function getSessionMessages(port, sessionId, client) {
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/session/${sessionId}/message`);
+    const path = `/session/${sessionId}/message`;
+    const res = await requestWithClient(port, client, path);
     if (!res.ok) return null;
     const body = await res.json();
     return Array.isArray(body) ? body : null;
-  } catch {
+  } catch (error2) {
+    console.error(
+      `[getSessionMessages] GET /session/${sessionId}/message failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
     return null;
   }
 }
+async function fetchSessionMessages(port, sessionId, client) {
+  const response = await requestWithClient(port, client, `/session/${sessionId}/message`);
+  if (!response.ok) return null;
+  const body = await response.json();
+  return Array.isArray(body) ? body : null;
+}
+async function pollSessionMessagesForRedrive(port, sessionId, client) {
+  try {
+    const response = await requestWithClient(
+      port,
+      client,
+      `/session/${sessionId}/message`,
+      void 0,
+      { allowStatuses: ALL_HTTP_STATUSES }
+    );
+    if (!response.ok) {
+      return { ok: false, status: response.status, body: await response.text(), malformed: false };
+    }
+    const body = await response.json();
+    if (!Array.isArray(body)) return { ok: false, status: null, body: "", malformed: true };
+    return { ok: true, messages: body };
+  } catch (error2) {
+    console.error(
+      `[pollSessionMessagesForRedrive] GET /session/${sessionId}/message failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return { ok: false, status: null, body: "", malformed: false };
+  }
+}
 function isSessionActivelyGenerating(messages) {
   if (!messages || messages.length === 0) return false;
   const last = messages[messages.length - 1];
@@ -2922,27 +3493,37 @@ function sessionLastActivityMs(session) {
   }
   return null;
 }
-async function listSessions(port) {
+async function listSessions(port, client) {
+  if (client?.version === "v2") return listV2Sessions(client);
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/session`);
+    const res = await requestWithClient(port, client, "/session");
     if (!res.ok) return null;
     const body = await res.json();
     return Array.isArray(body) ? body : null;
-  } catch {
+  } catch (error2) {
+    console.error(
+      `[listSessions] GET /session failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
     return null;
   }
 }
-async function deleteSession(port, id) {
+async function deleteSession(port, id, client) {
+  if (client?.version === "v2") return deleteV2Session(client, id);
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/session/${id}`, { method: "DELETE" });
+    const res = await requestWithClient(port, client, `/session/${id}`, { method: "DELETE" });
     return res.status >= 200 && res.status < 300;
-  } catch {
+  } catch (error2) {
+    console.error(
+      `[deleteSession] DELETE /session/${id} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
     return false;
   }
 }
-async function sessionExists(port, id) {
+async function sessionExists(port, id, client) {
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/session/${id}`);
+    const res = await requestWithClient(port, client, `/session/${id}`, void 0, {
+      allowStatuses: [404]
+    });
     if (res.status >= 200 && res.status < 300) return true;
     if (res.status === 404) return false;
     return null;
@@ -2950,9 +3531,22 @@ async function sessionExists(port, id) {
     return null;
   }
 }
-async function getSessionStatuses(port) {
+async function getOpenCodeSession(port, id, client) {
+  try {
+    const response = await requestWithClient(port, client, `/session/${id}`);
+    const body = await response.json();
+    return body && typeof body === "object" && !Array.isArray(body) ? body : null;
+  } catch (error2) {
+    console.error(
+      `[getOpenCodeSession] GET /session/${id} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function getSessionStatuses(port, client) {
+  if (client?.version === "v2") return null;
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/session/status`);
+    const res = await requestWithClient(port, client, "/session/status");
     if (!res.ok) {
       console.error(
         `[getSessionStatuses] GET /session/status returned HTTP ${res.status} (port ${port})`
@@ -2974,22 +3568,28 @@ async function getSessionStatuses(port) {
     return null;
   }
 }
-async function isSessionOngoing(port, id) {
-  const map = await getSessionStatuses(port);
+async function isSessionOngoing(port, id, client) {
+  if (client?.version === "v2") return isV2SessionOngoing(client, id);
+  const map = await getSessionStatuses(port, client);
   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()) {
-    url.searchParams.set("directory", directory.trim());
-  }
-  const response = await timedFetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({})
-  });
+async function createOpenCodeSession(port, directory, client) {
+  const path = new URL(`${opencodeBase(port)}/session`);
+  if (directory && directory.trim()) path.searchParams.set("directory", directory.trim());
+  const requestPath = `${path.pathname}${path.search}`;
+  const response = await requestWithClient(
+    port,
+    client,
+    requestPath,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({})
+    },
+    { allowStatuses: ALL_HTTP_STATUSES }
+  );
   if (!response.ok) {
     const text = await response.text().catch(() => "");
     throw new Error(`Failed to create session: HTTP ${response.status}${text ? `: ${text}` : ""}`);
@@ -2997,10 +3597,16 @@ async function createOpenCodeSession(port, directory) {
   const data = await response.json();
   return data.id;
 }
-async function getModelAttachmentCapability(port, model) {
+async function getModelAttachmentCapability(port, model, client) {
   const { model: baseModel } = splitModelVariant(model);
+  if (client?.version === "v2") {
+    console.error(
+      `[getModelAttachmentCapability] V2 provider capabilities are unavailable; using text-only fallback (port ${port})`
+    );
+    return null;
+  }
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/config/providers`);
+    const res = await requestWithClient(port, client, "/config/providers");
     if (!res.ok) {
       console.error(
         `[getModelAttachmentCapability] GET /config/providers returned HTTP ${res.status} (port ${port})`
@@ -3120,19 +3726,43 @@ function applyModelOptions(body, options) {
   }
   if (variant) body.variant = variant;
 }
+async function listOpenCodeQuestions(port, client) {
+  try {
+    const response = await requestWithClient(port, client, "/question");
+    const body = await response.json();
+    return Array.isArray(body) ? body : null;
+  } catch (error2) {
+    console.error(
+      `[listOpenCodeQuestions] GET /question failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
+async function listOpenCodePermissions(port, client) {
+  try {
+    const response = await requestWithClient(port, client, "/permission");
+    const body = await response.json();
+    return Array.isArray(body) ? body : null;
+  } catch (error2) {
+    console.error(
+      `[listOpenCodePermissions] GET /permission failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return null;
+  }
+}
 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, attachments) {
-  const before = await getSessionMessages(port, sessionId);
+async function sendPromptAsync(port, sessionId, content, options, attachments, client) {
+  const before = await getSessionMessages(port, sessionId, client);
   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 capable = await getModelAttachmentCapability(port, options?.model, client);
     const {
       parts: fileParts,
       outcomes,
@@ -3145,11 +3775,17 @@ async function sendPromptAsync(port, sessionId, content, options, attachments) {
     parts
   };
   applyModelOptions(body, options);
-  const res = await timedFetch(`${opencodeBase(port)}/session/${sessionId}/prompt_async`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
+  const res = await requestWithClient(
+    port,
+    client,
+    `/session/${sessionId}/prompt_async`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    },
+    { allowStatuses: ALL_HTTP_STATUSES }
+  );
   if (res.status < 200 || res.status >= 300) {
     const text = await res.text().catch(() => "");
     const { variant } = splitModelVariant(options?.model);
@@ -3160,7 +3796,7 @@ async function sendPromptAsync(port, sessionId, content, options, attachments) {
   const READ_BACK_ATTEMPTS = 5;
   const READ_BACK_DELAY_MS = 150;
   for (let attempt = 0; attempt < READ_BACK_ATTEMPTS; attempt++) {
-    const after = await getSessionMessages(port, sessionId);
+    const after = await getSessionMessages(port, sessionId, client);
     if (after) {
       let best = null;
       for (const m of after) {
@@ -3263,21 +3899,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 finiteNumber2(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: finiteNumber2(part.state.time?.start),
+        timeEnd: finiteNumber2(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 = finiteNumber2(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 +3977,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 +4012,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,9 +4163,73 @@ function hasRunningAssistantExcept(messages, exceptUserMessageId) {
     (m) => roleOf(m) === "assistant" && parentIdOf(m) !== exceptUserMessageId && isAssistantInFlight(m)
   );
 }
-async function hasAnyConfiguredProvider(port) {
+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, client) {
+  if (client?.version === "v2") {
+    const directory = await getOpenCodeDirectoryV2(client);
+    if (!directory) {
+      console.error(
+        `[hasAnyConfiguredProvider] V2 working directory was unavailable (port ${port})`
+      );
+      return null;
+    }
+    const path = `/api/integration?location%5Bdirectory%5D=${encodeURIComponent(directory)}`;
+    try {
+      const res = await client.request(path);
+      if (!res.ok) {
+        console.error(
+          `[hasAnyConfiguredProvider] GET ${path} returned HTTP ${res.status} (port ${port})`
+        );
+        return null;
+      }
+      const body = await res.json();
+      if (!body || typeof body !== "object" || Array.isArray(body) || !Array.isArray(body.data)) {
+        console.error(
+          `[hasAnyConfiguredProvider] GET ${path} body had no integration data array (port ${port})`
+        );
+        return null;
+      }
+      for (const integration of body.data) {
+        if (!integration || typeof integration !== "object" || Array.isArray(integration) || typeof integration.id !== "string" || !Array.isArray(integration.connections)) {
+          console.error(
+            `[hasAnyConfiguredProvider] GET ${path} body contained an invalid integration (port ${port})`
+          );
+          return null;
+        }
+      }
+      return body.data.some(
+        (integration) => Array.isArray(integration.connections) && integration.connections.length > 0
+      );
+    } catch (error2) {
+      console.error(
+        `[hasAnyConfiguredProvider] GET ${path} failed (port ${port}): ${error2 instanceof Error ? error2.message : String(error2)}`
+      );
+      return null;
+    }
+  }
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/config/providers`);
+    const res = await requestWithClient(port, client, "/config/providers");
     if (!res.ok) {
       console.error(
         `[hasAnyConfiguredProvider] GET /config/providers returned HTTP ${res.status} (port ${port})`
@@ -3489,9 +4258,84 @@ async function hasAnyConfiguredProvider(port) {
     return null;
   }
 }
-async function reloadProviderCache(port) {
+function sessionErrorReason2(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: sessionErrorReason2(propertiesRecord.error)
+  };
+}
+async function readSessionErrorStream(port, options, client) {
+  if (client?.version === "v2") return readV2SessionErrorStream(client, options);
+  let reader = null;
+  try {
+    const response = await (client?.request("/event", {
+      headers: { accept: "text/event-stream" },
+      signal: options.signal
+    }) ?? 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, client) {
+  if (client?.version === "v2") return;
   try {
-    const res = await timedFetch(`${opencodeBase(port)}/config`, {
+    const res = await requestWithClient(port, client, "/config", {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({})
@@ -3869,10 +4713,11 @@ var STRIP_RES = /* @__PURE__ */ new Set([
   "content-length"
 ]);
 var StreamForwarder = class {
-  constructor(ws, port, callbacks = {}) {
+  constructor(ws, port, callbacks = {}, options = {}) {
     this.ws = ws;
     this.port = port;
     this.callbacks = callbacks;
+    this.options = options;
   }
   inflight = /* @__PURE__ */ new Map();
   /**
@@ -3956,7 +4801,15 @@ var StreamForwarder = class {
     }
     const fwdHeaders = {};
     for (const [k, v] of Object.entries(headers ?? {})) {
-      if (!STRIP_REQ.has(k.toLowerCase())) fwdHeaders[k] = v;
+      const lower = k.toLowerCase();
+      if (STRIP_REQ.has(lower)) continue;
+      if (this.options.openCodePassword !== void 0 && this.options.openCodePassword !== null) {
+        if (lower === "authorization") continue;
+      }
+      fwdHeaders[k] = v;
+    }
+    if (this.options.openCodePassword !== void 0 && this.options.openCodePassword !== null) {
+      fwdHeaders.Authorization = buildOpenCodeBasicAuthHeader(this.options.openCodePassword);
     }
     this.inflight.set(sid, { pushBody, endBody, abort: () => ac.abort() });
     const body = bodyPromise ? await bodyPromise : void 0;
@@ -4069,6 +4922,7 @@ function connectTunnel(options) {
     agentId,
     authHeader,
     port,
+    openCodePassword,
     onConnected,
     onDisconnected,
     onError,
@@ -4086,11 +4940,16 @@ function connectTunnel(options) {
         Authorization: authHeader
       }
     });
-    const forwarder = new StreamForwarder(ws, port, {
-      onHead: () => onResponse?.(),
-      onDrainPing: () => onDrainPing?.(),
-      onUsageRearmPing: () => onUsageRearmPing?.()
-    });
+    const forwarder = new StreamForwarder(
+      ws,
+      port,
+      {
+        onHead: () => onResponse?.(),
+        onDrainPing: () => onDrainPing?.(),
+        onUsageRearmPing: () => onUsageRearmPing?.()
+      },
+      { openCodePassword }
+    );
     const connectionTimeout = setTimeout(() => {
       ws.close();
       reject(new Error("Connection timeout"));
@@ -4233,6 +5092,7 @@ var RunnerConnection = class {
           agentId: this.resolvedAgentId,
           authHeader: this.opts.getAuthHeader(),
           port: this.opts.port,
+          openCodePassword: this.opts.openCodePassword,
           onConnected: (agentId) => {
             this.reconnectAttempt = 0;
             this.reconnecting = false;
@@ -4384,7 +5244,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`);
@@ -4413,33 +5273,73 @@ function parseCodexUsageHeaders(headers) {
 function normalizeProbeModel(model) {
   return model.endsWith("-fast") ? model.slice(0, -"-fast".length) : model;
 }
-async function resolveProbeModels(port) {
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unsupportedProbeModels(reason, port) {
+  console.error(`[resolveProbeModels] ${reason} (port ${port})`);
+  return { status: "unsupported", reason };
+}
+async function resolveV1ProbeModels(client, port) {
   try {
-    const res = await withRequestTimeout(
-      fetch,
-      REQUEST_TIMEOUT_MS
-    )(`${opencodeBase(port)}/config/providers`);
-    if (!res.ok) {
-      console.error(
-        `[resolveProbeModels] GET /config/providers returned HTTP ${res.status} (port ${port})`
-      );
-      return [];
+    const response = await client.request("/config/providers");
+    const body = await response.json();
+    if (!isRecord2(body) || !Array.isArray(body.providers)) {
+      return unsupportedProbeModels("V1 provider response did not contain a providers array", port);
     }
-    const body = await res.json();
-    const provider = body?.providers?.find((candidate) => candidate?.id === "openai");
-    if (!provider || !provider.models || typeof provider.models !== "object") return [];
+    const provider = body.providers.find(
+      (candidate) => isRecord2(candidate) && candidate.id === "openai"
+    );
+    if (!provider || !isRecord2(provider.models)) return { status: "supported", models: [] };
+    const defaults2 = isRecord2(body.default) ? body.default : void 0;
     const candidates = [
-      ...typeof body?.default?.openai === "string" ? [body.default.openai] : [],
+      ...typeof defaults2?.openai === "string" ? [defaults2.openai] : [],
       ...Object.keys(provider.models)
     ].map(normalizeProbeModel);
-    return [...new Set(candidates)].slice(0, 4);
+    return { status: "supported", models: [...new Set(candidates)].slice(0, 4) };
   } catch (err) {
-    console.error(
-      `[resolveProbeModels] GET /config/providers failed (port ${port}): ${err instanceof Error ? err.message : String(err)}`
+    return unsupportedProbeModels(
+      `V1 GET /config/providers failed: ${err instanceof Error ? err.message : String(err)}`,
+      port
     );
-    return [];
   }
 }
+async function resolveV2ProbeModels(client, port) {
+  const directory = await getOpenCodeDirectoryV2(client);
+  if (!directory) {
+    return unsupportedProbeModels("V2 working directory could not be verified", port);
+  }
+  const path = `/api/provider?location%5Bdirectory%5D=${encodeURIComponent(directory)}`;
+  try {
+    const response = await client.request(path);
+    const body = await response.json();
+    if (!isRecord2(body) || !Array.isArray(body.data)) {
+      return unsupportedProbeModels(`V2 GET ${path} did not contain a provider data array`, port);
+    }
+    const provider = body.data.find(
+      (candidate) => isRecord2(candidate) && candidate.id === "openai"
+    );
+    if (!provider) return { status: "supported", models: [] };
+    if (!isRecord2(provider.models)) {
+      return unsupportedProbeModels(
+        "V2 provider response has no safe OpenAI model catalogue",
+        port
+      );
+    }
+    return {
+      status: "supported",
+      models: [...new Set(Object.keys(provider.models).map(normalizeProbeModel))].slice(0, 4)
+    };
+  } catch (err) {
+    return unsupportedProbeModels(
+      `V2 GET ${path} failed: ${err instanceof Error ? err.message : String(err)}`,
+      port
+    );
+  }
+}
+async function resolveProbeModels(port, client = createOpenCodeClient({ port, version: "v1" })) {
+  return client.version === "v2" ? resolveV2ProbeModels(client, port) : resolveV1ProbeModels(client, port);
+}
 function hasPrimaryHeaders(headers) {
   return [
     "x-codex-primary-used-percent",
@@ -4447,7 +5347,7 @@ function hasPrimaryHeaders(headers) {
     "x-codex-primary-reset-at"
   ].some((name) => headers.has(name));
 }
-async function getOpenAiUsage(port) {
+async function getOpenAiUsage(port, client) {
   const credentials2 = readOpenCodeChatGptCredentials();
   if (!credentials2) {
     throw new OpenAiUsageError(
@@ -4462,12 +5362,16 @@ async function getOpenAiUsage(port) {
     );
   }
   const subscription = parseChatGptIdentity(credentials2.accessToken);
-  const models = await resolveProbeModels(port);
-  if (models.length === 0) {
-    throw new OpenAiUsageError("No supported OpenAI probe model is available.", "no_probe_model");
+  const lookup = await resolveProbeModels(port, client);
+  if (lookup.status === "unsupported" || lookup.models.length === 0) {
+    const detail = lookup.status === "unsupported" ? ` ${lookup.reason}.` : "";
+    throw new OpenAiUsageError(
+      `No supported OpenAI probe model is available.${detail}`,
+      "no_probe_model"
+    );
   }
   let lastStatus;
-  for (const model of models) {
+  for (const model of lookup.models) {
     let res;
     try {
       res = await withRequestTimeout(fetch, REQUEST_TIMEOUT_MS)(CODEX_RESPONSES_URL, {
@@ -4566,13 +5470,6 @@ function resolveClaudeUsageReportingMode(flagValue, env) {
     envVar: "EVIDENT_CLAUDE_USAGE_REPORTING"
   });
 }
-function nextReportDelayMs(random = Math.random) {
-  return usageReportDelayMs(random);
-}
-var FIRST_REPORT_DELAY_MS = firstReportDelayMs();
-function claudeUsageFailureLogLevel(consecutiveFailures) {
-  return usageReportFailureLogLevel(consecutiveFailures);
-}
 
 // src/lib/openai-usage-reporting.ts
 function resolveOpenAiUsageReportingMode(flagValue, env) {
@@ -5228,6 +6125,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;
@@ -5289,6 +6190,7 @@ var ChannelDriver = class _ChannelDriver {
   maxActiveSessions;
   watcherStallMs;
   wedgeWarningIntervalMs;
+  openCodeClient;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
   /**
@@ -5368,6 +6270,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
@@ -5386,20 +6299,23 @@ var ChannelDriver = class _ChannelDriver {
    */
   readopted = /* @__PURE__ */ new Set();
   /**
-   * "Don't re-DISPATCH / re-attach this orphan again" (Bug 2/5). Set when a
-   * re-adopted running/orphan row's watcher hit its `processed_at`-anchored
-   * deadline (or an orphan whose window already elapsed): the still-`processing`
-   * server row would otherwise be re-adopted (and re-dispatched) on EVERY ~2s
-   * drain until the 15-min cron resets it — spamming new turns.
-   *
-   * CRITICAL (Bugbot #202): this suppresses ONLY the dispatch/re-attach paths, it
-   * does NOT suppress DONE delivery. A row parked here whose reply later COMPLETES
-   * in opencode must still be delivered via `markDone` on the next drain — so
-   * `readoptOne` computes `state` FIRST and this set is checked only on the
-   * non-done path. It is cleared once the row leaves the processing list (cron
-   * reset → it drains normally as `pending`), so it can never leak.
+   * Readopt give-up fence. Set when recovery declines to start or continue a turn
+   * for a row that is still `processing`, so the next drain does not re-dispatch or
+   * re-attach it before the cron safety net acts. It suppresses only non-done
+   * recovery paths; DONE delivery still runs. Clear it when
+   * `!stillProcessing.has(id)`, because leaving `processing` hands the row back to
+   * normal processing.
    */
   dontRedispatch = /* @__PURE__ */ new Set();
+  /**
+   * Untrackable-ack fence. Set after OpenCode accepts a prompt without returning a
+   * usable message id, because another POST could create a duplicate turn. Keep it
+   * fenced while the row is `processing` or `pending`; clear it only when the row
+   * is absent from both lists.
+   */
+  untrackableAck = /* @__PURE__ */ new Set();
+  /** Pending rows seen in the current drain, used to retain terminal dispatch fences. */
+  pendingMessageIds = /* @__PURE__ */ new Set();
   /**
    * "markDone for this row is TERMINALLY undeliverable" (Bug 4). Set ONLY when a
    * re-adopted DONE row's `markDone` returned a terminal 4xx (a status that will
@@ -5522,7 +6438,8 @@ var ChannelDriver = class _ChannelDriver {
    */
   attachmentsSkippedSignalled = /* @__PURE__ */ new Set();
   /**
-   * Cache of the opencode root directory (from `GET /path`). Resolved lazily on
+   * Cache of the opencode root directory from the selected client's location lookup.
+   * Resolved lazily on
    * first session creation so drain-created sessions are rooted at the project
    * directory and thus visible in `opencode web`'s session list. `undefined` =
    * not yet resolved; `null` = resolved-but-unavailable (don't keep retrying).
@@ -5551,6 +6468,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;
   /**
@@ -5609,6 +6533,11 @@ var ChannelDriver = class _ChannelDriver {
       config.fetchImpl ?? fetch,
       config.requestTimeoutMs ?? REQUEST_TIMEOUT_MS
     );
+    this.openCodeClient = config.openCodeClient ?? createOpenCodeClient({
+      port: config.port,
+      version: "v1",
+      fetchImpl: config.fetchImpl
+    });
     this.sleep = config.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     this.pausedPollIntervalMs = config.pausedPollIntervalMs ?? DEFAULT_PAUSED_POLL_INTERVAL_MS;
     this.pausedMaxWaitMs = config.pausedMaxWaitMs ?? DEFAULT_PAUSED_MAX_WAIT_MS;
@@ -5620,9 +6549,39 @@ var ChannelDriver = class _ChannelDriver {
     this.watcherStallMs = config.watcherStallMs ?? WATCHER_STALL_MS;
     this.wedgeWarningIntervalMs = config.wedgeWarningIntervalMs ?? WEDGE_WARNING_INTERVAL_MS;
   }
-  /** The IPv4-loopback base URL for the local `opencode serve`. */
-  get opencodeBase() {
-    return `http://127.0.0.1:${this.port}`;
+  get isV2() {
+    return this.openCodeClient.version === "v2";
+  }
+  async getSessionMessages(sessionId) {
+    return this.isV2 ? getV2SessionMessages(this.openCodeClient, sessionId) : fetchSessionMessages(this.port, sessionId, this.openCodeClient);
+  }
+  async getSubagentSessionMessages(sessionId) {
+    return this.isV2 ? getV2SessionMessages(this.openCodeClient, sessionId) : getSessionMessages(this.port, sessionId, this.openCodeClient);
+  }
+  async getTelemetrySubagentSessionMessages(sessionId) {
+    if (this.isV2) return getV2SessionMessages(this.openCodeClient, sessionId);
+    return fetchSessionMessages(this.port, sessionId, this.openCodeClient);
+  }
+  async listSessions() {
+    return this.isV2 ? listV2Sessions(this.openCodeClient) : listSessions(this.port, this.openCodeClient);
+  }
+  async sessionExists(sessionId) {
+    return this.isV2 ? v2SessionExists(this.openCodeClient, sessionId) : sessionExists(this.port, sessionId, this.openCodeClient);
+  }
+  async isSessionOngoing(sessionId) {
+    return this.isV2 ? isV2SessionOngoing(this.openCodeClient, sessionId) : isSessionOngoing(this.port, sessionId, this.openCodeClient);
+  }
+  async getOpenCodeDirectory() {
+    return this.isV2 ? getOpenCodeDirectoryV2(this.openCodeClient) : getOpenCodeDirectory(this.port, this.openCodeClient);
+  }
+  async createOpenCodeSession(directory) {
+    return this.isV2 ? createV2Session(this.openCodeClient, directory) : createOpenCodeSession(this.port, directory, this.openCodeClient);
+  }
+  async hasAnyConfiguredProvider() {
+    return hasAnyConfiguredProvider(this.port, this.openCodeClient);
+  }
+  async readOpenCodeSessionErrorStream(options) {
+    return this.isV2 ? readV2SessionErrorStream(this.openCodeClient, options) : readSessionErrorStream(this.port, options, this.openCodeClient);
   }
   /**
    * Drain all pending channel conversations once: poll → dispatch → register.
@@ -5700,6 +6659,7 @@ var ChannelDriver = class _ChannelDriver {
   async runDrain() {
     let dispatched = 0;
     try {
+      this.pendingMessageIds.clear();
       const conversations = await this.getPendingConversations();
       if (this.recycleRequestedFlag) {
         this.stop();
@@ -5765,6 +6725,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 +6806,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,7 +6882,9 @@ 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);
+    for (const message of messages) this.pendingMessageIds.add(message.id);
     let dispatched = 0;
     let skippedAlreadyDispatched = 0;
     if (refusedSessionId && messages.length > 0) {
@@ -5919,6 +6898,15 @@ var ChannelDriver = class _ChannelDriver {
         skippedAlreadyDispatched += 1;
         continue;
       }
+      if (this.untrackableAck.has(message.id)) {
+        this.log({
+          level: "warn",
+          message: `Message ${message.id.slice(0, 8)} is fenced after an untrackable OpenCode turn \u2014 skipping re-dispatch`,
+          conversation_id: conv.id,
+          message_id: message.id
+        });
+        break;
+      }
       const effectiveOpencodeMessageId = message.opencode_message_id ?? this.releasedOpencodeIds.get(message.id)?.opencodeMessageId ?? null;
       if (effectiveOpencodeMessageId) {
         const outcome = await this.resolveRedrive(
@@ -5947,15 +6935,55 @@ var ChannelDriver = class _ChannelDriver {
           conversation_id: conv.id,
           message_id: message.id
         });
-        const sendAttachments = this.buildSendAttachments(conv, message);
-        opencodeMessageId = await this.dispatchLocked(
+        const sendAttachments = this.isV2 ? void 0 : this.buildSendAttachments(conv, message);
+        if (this.isV2 && message.attachments && message.attachments.length > 0) {
+          this.signalAttachmentsSkipped(
+            conv.id,
+            message.id,
+            message.attachments.map((attachment, index) => ({
+              index,
+              mime: attachment.mime,
+              ...attachment.filename ? { filename: attachment.filename } : {},
+              status: "skipped"
+            })),
+            false
+          );
+        }
+        opencodeMessageId = this.isV2 ? await sendV2Prompt(this.openCodeClient, sessionId, message.content) : await this.dispatchLocked(
           sessionId,
-          () => sendPromptAsync(this.port, sessionId, message.content, options, sendAttachments)
+          () => sendPromptAsync(
+            this.port,
+            sessionId,
+            message.content,
+            options,
+            sendAttachments,
+            this.openCodeClient
+          )
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
+        if (this.isV2 && err instanceof OpenCodeV2PromptAckError) {
+          const errorMessage4 = err instanceof Error ? err.message : String(err);
+          this.untrackableAck.add(message.id);
+          this.log({
+            level: "error",
+            message: `V2 prompt dispatch for message ${message.id.slice(0, 8)} failed after a positive ack with no usable id: ${errorMessage4}`,
+            conversation_id: conv.id,
+            message_id: message.id
+          });
+          await this.markFailed(conv.id, message.id, null, errorMessage4).catch((markErr) => {
+            this.log({
+              level: "warn",
+              message: `markFailed PATCH for V2 dispatch failure on message ${message.id.slice(0, 8)} failed: ${markErr instanceof Error ? markErr.message : String(markErr)}`,
+              conversation_id: conv.id,
+              message_id: message.id
+            });
+            void this.postSignal(conv.id, message.id, "ack_untrackable");
+          });
+          break;
+        }
         this.dispatched.delete(message.id);
-        const exists = await sessionExists(this.port, sessionId);
+        const exists = await this.sessionExists(sessionId);
         if (exists === false) {
           this.sessions.delete(conv.id);
           this.log({
@@ -6004,6 +7032,9 @@ var ChannelDriver = class _ChannelDriver {
         break;
       }
       if (opencodeMessageId === null) {
+        if (this.isV2) {
+          throw new Error("V2 prompt dispatch completed without an acknowledged message id");
+        }
         const streak = this.recordUnconfirmedDispatch(message.id, sessionId);
         if (streak < MAX_IDENTICAL_REDRIVE_POLL_FAILURES) {
           this.log({
@@ -6151,29 +7182,38 @@ var ChannelDriver = class _ChannelDriver {
    */
   async pollSessionMessagesForRedrive(conv, message, sessionId) {
     try {
-      const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
-      if (!res.ok) {
-        const rawBody = await res.text();
-        const normalized = normalizeRedrivePollFailureBody(rawBody);
-        this.log({
-          level: "warn",
-          message: `Re-drive: polling session ${sessionId.slice(0, 8)} for message ${message.id.slice(0, 8)} returned HTTP ${res.status}${normalized ? `: ${normalized}` : ""} \u2014 treating as unreadable this tick`,
-          conversation_id: conv.id,
-          message_id: message.id
-        });
-        return { ok: false, signature: `HTTP ${res.status}${normalized ? `: ${normalized}` : ""}` };
+      if (this.isV2) {
+        const messages = await this.getSessionMessages(sessionId);
+        if (messages === null) {
+          this.log({
+            level: "warn",
+            message: `Re-drive: failed to poll V2 session ${sessionId.slice(0, 8)} for message ${message.id.slice(0, 8)} \u2014 treating as unreadable this tick`,
+            conversation_id: conv.id,
+            message_id: message.id
+          });
+          return { ok: false, signature: null };
+        }
+        return { ok: true, messages };
       }
-      const body = await res.json();
-      if (!Array.isArray(body)) {
+      const polledV1 = await pollSessionMessagesForRedrive(
+        this.port,
+        sessionId,
+        this.openCodeClient
+      );
+      if (!polledV1.ok) {
+        const normalized = normalizeRedrivePollFailureBody(polledV1.body);
         this.log({
           level: "warn",
-          message: `Re-drive: polling session ${sessionId.slice(0, 8)} for message ${message.id.slice(0, 8)} returned a non-array message body \u2014 treating as unreadable this tick`,
+          message: `Re-drive: polling session ${sessionId.slice(0, 8)} for message ${message.id.slice(0, 8)} returned ${polledV1.malformed ? "a non-array message body" : `HTTP ${polledV1.status ?? "a network error"}${normalized ? `: ${normalized}` : ""}`} \u2014 treating as unreadable this tick`,
           conversation_id: conv.id,
           message_id: message.id
         });
-        return { ok: false, signature: "non-array message body" };
+        return {
+          ok: false,
+          signature: polledV1.status === null && !polledV1.malformed ? null : polledV1.malformed ? "non-array message body" : `HTTP ${polledV1.status}${normalized ? `: ${normalized}` : ""}`
+        };
       }
-      return { ok: true, messages: body };
+      return { ok: true, messages: polledV1.messages };
     } catch (err) {
       this.log({
         level: "warn",
@@ -6232,11 +7272,11 @@ var ChannelDriver = class _ChannelDriver {
     }
     const state = messageRunState(messages, ocId ?? "");
     if (state === "failed" && isAbortedTerminalReply(messages, ocId ?? "")) {
-      const ongoing = await isSessionOngoing(this.port, sessionId);
+      const ongoing = await this.isSessionOngoing(sessionId);
       if (ongoing === false) {
         this.log({
           level: "info",
-          message: `Re-drive: message ${message.id.slice(0, 8)} carries an abort-shaped terminal error and session ${sessionId.slice(0, 8)} is not-ongoing per GET /session/status \u2014 restart orphan, re-dispatching instead of marking it permanently failed`,
+          message: `Re-drive: message ${message.id.slice(0, 8)} carries an abort-shaped terminal error and session ${sessionId.slice(0, 8)} is not-ongoing per the active-session status check \u2014 restart orphan, re-dispatching instead of marking it permanently failed`,
           conversation_id: conv.id,
           message_id: message.id
         });
@@ -6249,8 +7289,25 @@ var ChannelDriver = class _ChannelDriver {
       return this.settleRedrive(conv, sessionId, message, ocId, messages, state);
     }
     if (state === "running" || state === "queued") {
-      const ongoing = await isSessionOngoing(this.port, sessionId);
+      const ongoing = await this.isSessionOngoing(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 +7397,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 +7435,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);
@@ -6662,7 +7749,7 @@ var ChannelDriver = class _ChannelDriver {
       };
     }
     if (bound) {
-      const exists = await sessionExists(this.port, bound);
+      const exists = await this.sessionExists(bound);
       if (exists === false) {
         this.log({
           level: "debug",
@@ -6695,7 +7782,7 @@ var ChannelDriver = class _ChannelDriver {
    */
   async createAndBindSession(conversationId) {
     const directory = await this.resolveOpenCodeDirectory();
-    const sessionId = await createOpenCodeSession(this.port, directory);
+    const sessionId = await this.createOpenCodeSession(directory);
     this.sessions.set(conversationId, sessionId);
     await this.persistSession(conversationId, sessionId).catch((err) => {
       this.log({
@@ -6707,17 +7794,18 @@ var ChannelDriver = class _ChannelDriver {
     return sessionId;
   }
   /**
-   * Lazily resolve (and cache) opencode's root directory via `GET /path`.
+   * Lazily resolve (and cache) opencode's root directory via the selected client's
+   * location lookup.
    * Resolved once per driver: `undefined` until first lookup, then the directory
-   * string or `null` if unavailable (we don't keep retrying a missing `/path`).
+   * string or `null` if unavailable (we don't keep retrying a failed lookup).
    */
   async resolveOpenCodeDirectory() {
     if (this.opencodeDirectory !== void 0) return this.opencodeDirectory;
-    this.opencodeDirectory = await getOpenCodeDirectory(this.port);
+    this.opencodeDirectory = await this.getOpenCodeDirectory();
     if (!this.opencodeDirectory) {
       this.log({
         level: "warn",
-        message: "Could not determine opencode directory (GET /path) \u2014 new sessions may not appear in opencode web"
+        message: "Could not determine opencode directory (location lookup failed) \u2014 new sessions may not appear in opencode web"
       });
     }
     return this.opencodeDirectory;
@@ -6901,6 +7989,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`
@@ -7079,47 +8185,196 @@ var ChannelDriver = class _ChannelDriver {
         this.ensureWatcherRunning(sessionId);
         this.log({
           level: "warn",
-          message: `Watchdog: session ${sessionId.slice(0, 8)}'s watcher loop had not ticked in ${stalledForMs}ms \u2014 restarted under generation ${watcher.generation} (${watcher.consecutiveStallRestarts}/${MAX_WATCHER_STALL_RESTARTS})`,
-          conversation_id: watcher.conv.id
+          message: `Watchdog: session ${sessionId.slice(0, 8)}'s watcher loop had not ticked in ${stalledForMs}ms \u2014 restarted under generation ${watcher.generation} (${watcher.consecutiveStallRestarts}/${MAX_WATCHER_STALL_RESTARTS})`,
+          conversation_id: watcher.conv.id
+        });
+        for (const evidentMessageId of watcher.inFlight.keys()) {
+          void this.postSignal(watcher.conv.id, evidentMessageId, "watcher_recovered", {
+            recovery: "loop_stalled"
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Start (but do NOT await) the per-session watcher loop if it has in-flight
+   * work and is not already running. Single-flight per session. The loop is
+   * tracked on the watcher and cleared when it settles; it never rejects (fully
+   * guarded), so a failed poll/callback can never crash the run loop — the cron
+   * stays as the safety net.
+   *
+   * The generation started here (#1618) is captured in the `.finally` closure
+   * so a RETIRED loop settling late — after `reconcileWatchers` has already
+   * restarted this watcher under a newer generation — can neither null the new
+   * loop's handle nor delete a watcher that still has live work.
+   */
+  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);
+      return;
+    }
+    const generation = watcher.generation;
+    const loop = this.runWatcherLoop(sessionId, watcher, generation).finally(() => {
+      if (watcher.generation !== generation) return;
+      watcher.loop = null;
+      if (watcher.inFlight.size === 0) {
+        this.watchers.delete(sessionId);
+      }
+    });
+    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 this.readOpenCodeSessionErrorStream({
+          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 this.getSessionMessages(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
         });
-        for (const evidentMessageId of watcher.inFlight.keys()) {
-          void this.postSignal(watcher.conv.id, evidentMessageId, "watcher_recovered", {
-            recovery: "loop_stalled"
-          });
-        }
       }
+    } finally {
+      this.sessionErrorHandled.delete(inFlight.evidentMessageId);
     }
   }
-  /**
-   * Start (but do NOT await) the per-session watcher loop if it has in-flight
-   * work and is not already running. Single-flight per session. The loop is
-   * tracked on the watcher and cleared when it settles; it never rejects (fully
-   * guarded), so a failed poll/callback can never crash the run loop — the cron
-   * stays as the safety net.
-   *
-   * The generation started here (#1618) is captured in the `.finally` closure
-   * so a RETIRED loop settling late — after `reconcileWatchers` has already
-   * restarted this watcher under a newer generation — can neither null the new
-   * loop's handle nor delete a watcher that still has live work.
-   */
-  ensureWatcherRunning(sessionId) {
-    const watcher = this.watchers.get(sessionId);
-    if (!watcher) return;
-    if (watcher.loop) return;
-    if (watcher.inFlight.size === 0) {
-      this.watchers.delete(sessionId);
-      return;
-    }
-    const generation = watcher.generation;
-    const loop = this.runWatcherLoop(sessionId, watcher, generation).finally(() => {
-      if (watcher.generation !== generation) return;
-      watcher.loop = null;
-      if (watcher.inFlight.size === 0) {
-        this.watchers.delete(sessionId);
-      }
-    });
-    watcher.loop = loop;
-  }
   /**
    * The per-session polling loop (WI-3). Once per tick it:
    *   1. polls `GET /session/:id/message` once and, per in-flight message,
@@ -7127,7 +8382,8 @@ var ChannelDriver = class _ChannelDriver {
    *      markDone (done) exactly once per transition;
    *   2. applies the idle-path re-dispatch guard (a dispatched message that never
    *      APPEARS → re-dispatch — D1 obligation 2);
-   *   3. polls `/question` + `/permission` (scoped to the session) and surfaces
+   *   3. polls V1's global `/question` + `/permission`, or V2's
+   *      `/api/session/:id/form` + `/api/session/:id/permission`, and surfaces
    *      NEW ones via `reportInteraction`, carrying the PAUSED message's own
    *      `source_message_id`;
    *   4. drops messages that completed or timed out from the in-flight set.
@@ -7153,11 +8409,7 @@ var ChannelDriver = class _ChannelDriver {
         if (watcher.generation !== generation) return;
         let messages = null;
         try {
-          const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
-          if (res.ok) {
-            const body = await res.json();
-            messages = Array.isArray(body) ? body : null;
-          }
+          messages = await this.getSessionMessages(sessionId);
         } catch {
         }
         if (messages != null && messages.length > 0) {
@@ -7232,6 +8484,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 +8552,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 +8566,9 @@ var ChannelDriver = class _ChannelDriver {
             sessionId,
             error2,
             usage,
-            failure
+            failure,
+            usageAgentName,
+            subagentInvocations
           );
         } catch (err) {
           if (err instanceof ChannelAuthError) throw err;
@@ -7336,9 +8611,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
@@ -7365,7 +8642,7 @@ var ChannelDriver = class _ChannelDriver {
         inFlight.b2LastDescendantCheckMs = this.now();
         const [descendantOngoing, rootOngoing] = await Promise.all([
           this.isAnyDescendantSessionOngoing(sessionId),
-          isSessionOngoing(this.port, sessionId)
+          this.isSessionOngoing(sessionId)
         ]);
         if (isB2AbandonmentConfirmed({
           pinnedForMs,
@@ -7425,7 +8702,7 @@ var ChannelDriver = class _ChannelDriver {
         });
       }
       const pinnedForMs = this.now() - inFlight.ambiguousPinnedSinceMs;
-      const ongoing = await isSessionOngoing(this.port, sessionId);
+      const ongoing = await this.isSessionOngoing(sessionId);
       if (isAmbiguousFinishResolved({
         pinnedForMs,
         maxPinnedMs: AMBIGUOUS_FINISH_MAX_PINNED_MS,
@@ -7499,7 +8776,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 +8811,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 +8824,9 @@ var ChannelDriver = class _ChannelDriver {
           sessionId,
           inFlight.opencodeMessageId,
           title,
-          usage
+          usage,
+          usageAgentName,
+          subagentInvocations
         );
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
@@ -7600,7 +8885,7 @@ var ChannelDriver = class _ChannelDriver {
    */
   async readoptProcessing() {
     const rows = await this.getProcessingMessages();
-    if (this.dontRedispatch.size > 0 || this.doneUndeliverable.size > 0 || this.readoptPollUnresolvedSignalled.size > 0) {
+    if (this.dontRedispatch.size > 0 || this.untrackableAck.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,
@@ -7620,6 +8905,16 @@ var ChannelDriver = class _ChannelDriver {
           }
         }
       }
+      for (const id of [...this.untrackableAck]) {
+        if (!stillProcessing.has(id) && !this.pendingMessageIds.has(id)) {
+          this.untrackableAck.delete(id);
+          this.log({
+            level: "debug",
+            message: `Re-adopt: message ${id.slice(0, 8)} left processing and pending \u2014 cleared untrackable-ack fence`,
+            message_id: id
+          });
+        }
+      }
     }
     if (rows.length === 0) return;
     const bySession = /* @__PURE__ */ new Map();
@@ -7640,23 +8935,32 @@ var ChannelDriver = class _ChannelDriver {
     for (const [sessionId, sessionRows] of bySession) {
       let messages;
       try {
-        const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}/message`);
-        if (!res.ok) {
-          this.log({
-            level: "warn",
-            message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned HTTP ${res.status} \u2014 skipping this session this tick`
-          });
-          continue;
-        }
-        const body = await res.json();
-        if (!Array.isArray(body)) {
-          this.log({
-            level: "warn",
-            message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned a non-array message body \u2014 skipping this session this tick`
-          });
-          continue;
+        if (this.isV2) {
+          const snapshot = await this.getSessionMessages(sessionId);
+          if (snapshot === null) {
+            this.log({
+              level: "warn",
+              message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned an unreadable message snapshot \u2014 skipping this session this tick`
+            });
+            continue;
+          }
+          messages = snapshot;
+        } else {
+          const polled = await pollSessionMessagesForRedrive(
+            this.port,
+            sessionId,
+            this.openCodeClient
+          );
+          if (!polled.ok) {
+            const normalized = normalizeRedrivePollFailureBody(polled.body);
+            this.log({
+              level: "warn",
+              message: `Re-adopt: polling session ${sessionId.slice(0, 8)} returned ${polled.malformed ? "a non-array message body" : `HTTP ${polled.status ?? "a network error"}${normalized ? `: ${normalized}` : ""}`} \u2014 skipping this session this tick`
+            });
+            continue;
+          }
+          messages = polled.messages;
         }
-        messages = body;
       } catch (err) {
         this.log({
           level: "warn",
@@ -7665,7 +8969,7 @@ var ChannelDriver = class _ChannelDriver {
         continue;
       }
       const anyUntracked = sessionRows.some((row) => !this.isTracked(sessionId, row.id));
-      const sessionOngoing = anyUntracked ? await isSessionOngoing(this.port, sessionId) : null;
+      const sessionOngoing = anyUntracked ? await this.isSessionOngoing(sessionId) : null;
       for (const row of sessionRows) {
         await this.readoptOne(sessionId, row, messages, sessionOngoing);
       }
@@ -7712,7 +9016,7 @@ var ChannelDriver = class _ChannelDriver {
     if (restartAborted) {
       this.log({
         level: "info",
-        message: `Re-adopt: message ${row.id.slice(0, 8)} carries an abort-shaped terminal error and session ${sessionId.slice(0, 8)} is not-ongoing per GET /session/status \u2014 restart orphan, re-dispatching instead of marking it permanently failed`,
+        message: `Re-adopt: message ${row.id.slice(0, 8)} carries an abort-shaped terminal error and session ${sessionId.slice(0, 8)} is not-ongoing per the active-session status check \u2014 restart orphan, re-dispatching instead of marking it permanently failed`,
         conversation_id: row.conversation_id,
         message_id: row.id
       });
@@ -7720,6 +9024,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 +9038,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) {
@@ -7752,10 +9071,11 @@ var ChannelDriver = class _ChannelDriver {
       }
       await this.reportSubagentAuthFailures(row.conversation_id, ocId ?? "", row.id, messages);
       this.dontRedispatch.delete(row.id);
+      this.untrackableAck.delete(row.id);
       void this.postSignal(row.conversation_id, row.id, "readopt_failed");
       return;
     }
-    if (this.dontRedispatch.has(row.id)) {
+    if (this.dontRedispatch.has(row.id) || this.untrackableAck.has(row.id)) {
       this.log({
         level: "debug",
         message: `Re-adopt: message ${row.id.slice(0, 8)} already gave up \u2014 left to the cron; skipping until it leaves processing`,
@@ -7775,7 +9095,7 @@ var ChannelDriver = class _ChannelDriver {
           const finish = reply?.info?.finish ?? reply?.finish;
           this.log({
             level: "info",
-            message: `Re-adopt: message ${row.id.slice(0, 8)} has an ambiguous finish ("${finish ?? "(absent)"}") but session ${sessionId.slice(0, 8)} is confirmed not-ongoing per GET /session/status \u2014 delivering the existing reply instead of re-dispatching`,
+            message: `Re-adopt: message ${row.id.slice(0, 8)} has an ambiguous finish ("${finish ?? "(absent)"}") but session ${sessionId.slice(0, 8)} is confirmed not-ongoing per the active-session status check \u2014 delivering the existing reply instead of re-dispatching`,
             conversation_id: row.conversation_id,
             message_id: row.id
           });
@@ -7784,7 +9104,7 @@ var ChannelDriver = class _ChannelDriver {
         }
         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)`,
+          message: `Re-adopt: message ${row.id.slice(0, 8)} running/${shape} but session ${sessionId.slice(0, 8)} is not-ongoing per the active-session status check (absent/idle) \u2014 re-dispatching from scratch (status-gated recovery)`,
           conversation_id: row.conversation_id,
           message_id: row.id
         });
@@ -7794,7 +9114,7 @@ var ChannelDriver = class _ChannelDriver {
       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)`,
+          message: `Re-adopt: message ${row.id.slice(0, 8)} running/${shape} and session ${sessionId.slice(0, 8)} is ongoing per the active-session status check (busy/retry) \u2014 re-attaching watcher (no re-dispatch)`,
           conversation_id: row.conversation_id,
           message_id: row.id
         });
@@ -7802,7 +9122,7 @@ var ChannelDriver = class _ChannelDriver {
         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`,
+            message: `Re-adopt: message ${row.id.slice(0, 8)} running/b1 but the active-session status check 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
           });
@@ -7814,7 +9134,7 @@ var ChannelDriver = class _ChannelDriver {
         }
         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`,
+          message: `Re-adopt: message ${row.id.slice(0, 8)} running/${shape} but the active-session status check 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
         });
@@ -7864,7 +9184,7 @@ var ChannelDriver = class _ChannelDriver {
    * extracted (#1493 Task 2.4) so the ambiguous-finish guard above can call the
    * SAME delivery instead of duplicating it.
    *
-   * EVEN IF the row was previously parked in `dontRedispatch` (a give-up stops
+   * EVEN IF the row was previously parked by either recovery fence (a give-up stops
    * re-dispatch, not delivery — Bugbot #202). Guarded EXACTLY like the watcher's
    * `settleMessageDone`: auth re-throws; terminal → park in `doneUndeliverable` +
    * leave for cron; transient → log + leave for the next drain (the still-
@@ -7890,7 +9210,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) {
@@ -7916,6 +9251,7 @@ var ChannelDriver = class _ChannelDriver {
       await this.reportSubagentAuthFailures(row.conversation_id, ocId, row.id, messages);
     }
     this.dontRedispatch.delete(row.id);
+    this.untrackableAck.delete(row.id);
     void this.postSignal(row.conversation_id, row.id, "readopt_done");
   }
   /**
@@ -7979,19 +9315,90 @@ var ChannelDriver = class _ChannelDriver {
       conversation_id: row.conversation_id,
       message_id: row.id
     });
-    this.awaitingReadopt.add(row.id);
+    if (!this.isV2) this.awaitingReadopt.add(row.id);
     const readoptConv = this.convForRow(sessionId, row);
     const readoptMessage = this.queuedMessageForRow(row);
-    const sendAttachments = this.buildSendAttachments(readoptConv, readoptMessage);
+    const sendAttachments = this.isV2 ? void 0 : this.buildSendAttachments(readoptConv, readoptMessage);
+    if (this.isV2 && row.attachments && row.attachments.length > 0) {
+      this.signalAttachmentsSkipped(
+        row.conversation_id,
+        row.id,
+        row.attachments.map((attachment, index) => ({
+          index,
+          mime: attachment.mime,
+          ...attachment.filename ? { filename: attachment.filename } : {},
+          status: "skipped"
+        })),
+        false
+      );
+    }
     let ocId;
     try {
-      ocId = await this.dispatchLocked(
+      ocId = this.isV2 ? await sendV2Prompt(this.openCodeClient, sessionId, row.content) : await this.dispatchLocked(
         sessionId,
-        () => sendPromptAsync(this.port, sessionId, row.content, options, sendAttachments)
+        () => sendPromptAsync(
+          this.port,
+          sessionId,
+          row.content,
+          options,
+          sendAttachments,
+          this.openCodeClient
+        )
       );
     } catch (err) {
       this.awaitingReadopt.delete(row.id);
       if (err instanceof ChannelAuthError) throw err;
+      if (this.isV2) {
+        const errorMessage3 = err instanceof Error ? err.message : String(err);
+        const invalidPromptAck = err instanceof OpenCodeV2PromptAckError;
+        if (!invalidPromptAck) {
+          const exists = await this.sessionExists(sessionId);
+          if (exists === false) {
+            this.log({
+              level: "warn",
+              message: `Re-adopt: message ${row.id.slice(0, 8)} dispatch hit a session (${sessionId.slice(0, 8)}) that was deleted mid-dispatch \u2014 deferring to the next drain: ${errorMessage3}`,
+              conversation_id: row.conversation_id,
+              message_id: row.id
+            });
+            void this.postSignal(row.conversation_id, row.id, "readopt_orphan_unsent");
+            return;
+          }
+          if (exists === null) {
+            this.log({
+              level: "warn",
+              message: `Re-adopt: message ${row.id.slice(0, 8)} dispatch failed and session (${sessionId.slice(0, 8)}) existence could not be confirmed \u2014 deferring to the next drain: ${errorMessage3}`,
+              conversation_id: row.conversation_id,
+              message_id: row.id
+            });
+            void this.postSignal(row.conversation_id, row.id, "readopt_orphan_unsent");
+            return;
+          }
+        } else {
+          this.untrackableAck.add(row.id);
+        }
+        this.log({
+          level: "error",
+          message: `V2 re-adopt dispatch for message ${row.id.slice(0, 8)} failed: ${errorMessage3}`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+        await this.markFailed(row.conversation_id, row.id, sessionId, errorMessage3).catch(
+          (markErr) => {
+            this.log({
+              level: "warn",
+              message: `markFailed PATCH for V2 re-adopt dispatch failure on message ${row.id.slice(0, 8)} failed: ${markErr instanceof Error ? markErr.message : String(markErr)}`,
+              conversation_id: row.conversation_id,
+              message_id: row.id
+            });
+            if (invalidPromptAck) {
+              void this.postSignal(row.conversation_id, row.id, "ack_untrackable");
+            } else {
+              this.signalDispatchNotStarted(readoptConv, readoptMessage, "failure_unreported");
+            }
+          }
+        );
+        return;
+      }
       this.log({
         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)}`,
@@ -8002,6 +9409,17 @@ var ChannelDriver = class _ChannelDriver {
       return;
     }
     if (ocId === null) {
+      if (this.isV2) {
+        this.untrackableAck.add(row.id);
+        this.log({
+          level: "error",
+          message: `V2 re-adopt dispatch for message ${row.id.slice(0, 8)} completed without an acknowledged message id`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+        void this.postSignal(row.conversation_id, row.id, "ack_untrackable");
+        return;
+      }
       this.awaitingReadopt.delete(row.id);
       const streak = this.recordUnconfirmedDispatch(row.id, sessionId);
       if (streak >= MAX_IDENTICAL_REDRIVE_POLL_FAILURES) {
@@ -8123,12 +9541,13 @@ var ChannelDriver = class _ChannelDriver {
     this.dispatched.delete(evidentMessageId);
   }
   /**
-   * Poll `/question` + `/permission` (scoped to the session) and surface NEW ones
-   * via `reportInteraction` (Task 3.5), carrying the PAUSED message's own
-   * `source_message_id` so the server @mentions the correct person under
-   * concurrency. Dedups by interaction id across ticks (reused per-session sets).
+   * Poll V1's global `/question` + `/permission`, or V2's watched-session form and
+   * permission routes, and surface NEW ones via `reportInteraction` (Task 3.5),
+   * carrying the PAUSED message's own `source_message_id` so the server @mentions
+   * the correct person under concurrency. Dedups by interaction id across ticks
+   * (reused per-session sets).
    *
-   * The interaction is attributed to the in-flight message it paused on. opencode
+   * The interaction is attributed to the in-flight message it paused on. OpenCode
    * stamps a `messageID` on a permission (and `tool.messageID` on a question) =
    * the assistant message id, whose `parentID` is the user message id — but the
    * simplest robust attribution here is: the single in-flight message that is
@@ -8151,16 +9570,14 @@ var ChannelDriver = class _ChannelDriver {
     let permissionsPolledOk = true;
     let questions = [];
     try {
-      const res = await this.fetchImpl(`${this.opencodeBase}/question`);
-      if (res.ok) {
-        const body = await res.json();
-        if (Array.isArray(body)) {
-          questions = body;
-        } else {
-          questionsPolledOk = false;
-        }
+      if (this.isV2) {
+        const forms = await listV2Forms(this.openCodeClient, sessionId);
+        if (forms === null) questionsPolledOk = false;
+        else questions = forms;
       } else {
-        questionsPolledOk = false;
+        const listed = await listOpenCodeQuestions(this.port, this.openCodeClient);
+        if (listed === null) questionsPolledOk = false;
+        else questions = listed;
       }
     } catch {
       questionsPolledOk = false;
@@ -8180,16 +9597,14 @@ var ChannelDriver = class _ChannelDriver {
     }
     let permissions = [];
     try {
-      const res = await this.fetchImpl(`${this.opencodeBase}/permission`);
-      if (res.ok) {
-        const body = await res.json();
-        if (Array.isArray(body)) {
-          permissions = body;
-        } else {
-          permissionsPolledOk = false;
-        }
+      if (this.isV2) {
+        const listed = await listV2Permissions(this.openCodeClient, sessionId);
+        if (listed === null) permissionsPolledOk = false;
+        else permissions = listed;
       } else {
-        permissionsPolledOk = false;
+        const listed = await listOpenCodePermissions(this.port, this.openCodeClient);
+        if (listed === null) permissionsPolledOk = false;
+        else permissions = listed;
       }
     } catch {
       permissionsPolledOk = false;
@@ -8283,10 +9698,14 @@ var ChannelDriver = class _ChannelDriver {
     if (cached !== void 0) return cached;
     let parent = void 0;
     try {
-      const res = await this.fetchImpl(`${this.opencodeBase}/session/${sessionId}`);
-      if (res.ok) {
-        const body = await res.json();
-        parent = body && typeof body.parentID === "string" ? body.parentID : null;
+      if (this.isV2) {
+        const session = await getV2Session(this.openCodeClient, sessionId);
+        parent = null;
+        const candidate = session.parentID;
+        if (typeof candidate === "string") parent = candidate;
+      } else {
+        const body = await getOpenCodeSession(this.port, sessionId, this.openCodeClient);
+        parent = typeof body?.parentID === "string" ? body.parentID : body === null ? void 0 : null;
       }
     } catch {
       parent = void 0;
@@ -8294,6 +9713,164 @@ 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 messages2 = await this.getTelemetrySubagentSessionMessages(sessionId);
+          if (messages2 === null) {
+            this.log({
+              level: "warn",
+              message: `Best-effort subagent session fetch for message ${messageId.slice(0, 8)} and child session ${sessionId.slice(0, 8)} was unreadable \u2014 omitting invocation telemetry`,
+              message_id: messageId
+            });
+            return null;
+          }
+          return messages2;
+        } 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
@@ -8332,21 +9909,18 @@ var ChannelDriver = class _ChannelDriver {
     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 && !_ChannelDriver.OPENCODE_DEFAULT_TITLE_PREFIX.test(title)) {
-          this.sessionTitles.set(sessionId, title);
-          return title;
-        }
-        return null;
+      let title = "";
+      if (this.isV2) {
+        title = (await getV2Session(this.openCodeClient, sessionId)).title?.trim() ?? "";
+      } else {
+        const body = await getOpenCodeSession(this.port, sessionId, this.openCodeClient);
+        title = typeof body?.title === "string" ? body.title.trim() : "";
       }
-      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
-      });
+      if (title.length > 0 && !_ChannelDriver.OPENCODE_DEFAULT_TITLE_PREFIX.test(title)) {
+        this.sessionTitles.set(sessionId, title);
+        return title;
+      }
+      return null;
     } catch (err) {
       this.log({
         level: "debug",
@@ -8444,7 +10018,7 @@ var ChannelDriver = class _ChannelDriver {
    * `SessionStatus` only.
    */
   async isAnyDescendantSessionAlive(rootSessionId) {
-    const sessions = await listSessions(this.port);
+    const sessions = await this.listSessions();
     if (!sessions) {
       this.log({
         level: "warn",
@@ -8455,7 +10029,7 @@ var ChannelDriver = class _ChannelDriver {
     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);
+      const childMsgs = await this.getSubagentSessionMessages(candidate.id);
       if (isSessionActivelyGenerating(childMsgs)) {
         return true;
       }
@@ -8517,7 +10091,7 @@ var ChannelDriver = class _ChannelDriver {
    *              `isB2AbandonmentConfirmed`.
    */
   async isAnyDescendantSessionOngoing(rootSessionId) {
-    const sessions = await listSessions(this.port);
+    const sessions = await this.listSessions();
     if (!sessions) {
       this.log({
         level: "warn",
@@ -8534,7 +10108,7 @@ var ChannelDriver = class _ChannelDriver {
         continue;
       }
       if (membership === false) continue;
-      const ongoing = await isSessionOngoing(this.port, candidate.id);
+      const ongoing = await this.isSessionOngoing(candidate.id);
       if (ongoing === true) return true;
       if (ongoing === null) indeterminate = true;
     }
@@ -8777,7 +10351,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 +10367,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 +10396,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 +10405,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`.
@@ -8858,7 +10448,7 @@ var ChannelDriver = class _ChannelDriver {
     const classified = messageFailure(messages, userMessageId);
     if (classified != null) return classified;
     const reply = findLastAssistantReplyFor(messages, userMessageId);
-    const hasProvider = await hasAnyConfiguredProvider(this.port);
+    const hasProvider = await this.hasAnyConfiguredProvider();
     return applyZeroProviderFallback(
       classified,
       hasProvider,
@@ -8931,7 +10521,7 @@ var ChannelDriver = class _ChannelDriver {
     const succeededProviders = /* @__PURE__ */ new Set();
     for (const ref of refs) {
       try {
-        const childMessages = await getSessionMessages(this.port, ref.sessionId);
+        const childMessages = await this.getSubagentSessionMessages(ref.sessionId);
         if (childMessages === null) {
           this.log({
             level: "debug",
@@ -9262,6 +10852,7 @@ Port ${port} is already in use.`));
 
 // src/commands/ensure-opencode-v2.ts
 import chalk6 from "chalk";
+import ora3 from "ora";
 import { select as select3 } from "@inquirer/prompts";
 async function probeOpenCode2WithoutPassword(port) {
   try {
@@ -9287,11 +10878,7 @@ function unknownPasswordError(port) {
     `OpenCode V2 (opencode2) is already running on port ${port} with a password this runner doesn't know. Free the port or pass --port.`
   );
 }
-function v2SessionSupportIncompleteError() {
-  return new Error(
-    "OpenCode V2 (opencode2) session support is incomplete \u2014 see https://github.com/sroze/evident/issues/2075. Not starting a new opencode2 process."
-  );
-}
+var INTERACTIVE_START_TIMEOUT_MS2 = 3e4;
 async function ensureOpenCode2Running(ctx) {
   const initialHealth = await probeOpenCode2WithoutPassword(ctx.port);
   if (initialHealth.authFailed) {
@@ -9334,13 +10921,37 @@ Port ${port} is already in use.`));
     }
   }
   if (!ctx.interactive) {
-    throw v2SessionSupportIncompleteError();
+    ctx.log(`OpenCode V2 is not running on port ${port}. Starting it automatically...`);
+    const { child: proc, password } = await startOpenCode2(port, {
+      inheritStdio: ctx.inheritStdio
+    });
+    const health = await waitForOpenCode2Health(port, password, ctx.startTimeoutMs);
+    if (!health.healthy) {
+      return {
+        port,
+        process: proc,
+        version: null,
+        notReadyReason: `it did not become healthy within ${Math.round(ctx.startTimeoutMs / 1e3)}s`,
+        password
+      };
+    }
+    ctx.log(`OpenCode V2 started on port ${port}${health.version ? ` (v${health.version})` : ""}`);
+    return {
+      port,
+      process: proc,
+      version: health.version ?? null,
+      notReadyReason: null,
+      password
+    };
   }
-  console.log(chalk6.yellow(`
-${v2SessionSupportIncompleteError().message}`));
   const action = await select3({
     message: "OpenCode V2 is not running. What would you like to do?",
     choices: [
+      {
+        name: "Start OpenCode V2 for me",
+        value: "start",
+        description: `Run 'opencode2 serve --port ${port}'`
+      },
       {
         name: "Show me the command",
         value: "manual",
@@ -9361,6 +10972,25 @@ ${v2SessionSupportIncompleteError().message}`));
     blank();
     throw new Error("Please start OpenCode V2 manually");
   }
+  if (action === "start") {
+    const spinner = ora3("Starting OpenCode V2...").start();
+    const { child: proc, password } = await startOpenCode2(port, {
+      inheritStdio: ctx.inheritStdio
+    });
+    const health = await waitForOpenCode2Health(port, password, INTERACTIVE_START_TIMEOUT_MS2);
+    if (!health.healthy) {
+      spinner.fail("Failed to start OpenCode V2");
+      throw new Error("OpenCode V2 failed to start");
+    }
+    spinner.stop();
+    return {
+      port,
+      process: proc,
+      version: health.version ?? null,
+      notReadyReason: null,
+      password
+    };
+  }
   return {
     port,
     process: null,
@@ -10254,7 +11884,7 @@ async function driveChannels(state, driver) {
       lastSeenOpencodeAuthApplies = opencodeAuthApplies;
       if (opencodeAuthApplied) state.openaiUsageRearm?.();
       if (claudeCredentialApplied || opencodeAuthApplied) {
-        void reloadProviderCache(state.port).catch(
+        void reloadProviderCache(state.port, state.opencodeClient ?? void 0).catch(
           (error2) => logActivity(state, {
             type: "error",
             error: `OpenCode provider cache reload failed on port ${state.port}: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -10379,7 +12009,7 @@ function logSessionDbProvenanceMismatch(state, provenance, currentVersion, preBo
 async function runSweep(state, driver, config) {
   const mode = `age=${config.maxAgeMs ?? "\u2014"} count=${config.maxCount ?? "\u2014"}`;
   try {
-    const sessions = await listSessions(state.port);
+    const sessions = await listSessions(state.port, state.opencodeClient ?? void 0);
     if (sessions === null) {
       logActivity(state, {
         type: "info",
@@ -10409,7 +12039,7 @@ async function runSweep(state, driver, config) {
         });
         continue;
       }
-      if (await deleteSession(state.port, id)) deleted++;
+      if (await deleteSession(state.port, id, state.opencodeClient ?? void 0)) deleted++;
       else failed++;
     }
     const failedNote = failed > 0 ? `, failed ${failed}` : "";
@@ -10637,14 +12267,11 @@ function scheduleClaudeUsageReporting(state, options) {
     report: (usage) => reportClaudeUsage(state.agentId, state.authHeader, usage),
     isLocalCredentialProblem,
     forcedOnHint: "run `claude` to sign in",
-    firstDelayMs: () => FIRST_REPORT_DELAY_MS,
-    nextDelayMs: nextReportDelayMs,
-    failureLogLevel: claudeUsageFailureLogLevel
+    firstDelayMs: firstReportDelayMs,
+    nextDelayMs: usageReportDelayMs,
+    failureLogLevel: usageReportFailureLogLevel
   });
 }
-var RESOURCE_USAGE_BASE_REPORT_DELAY_MS = 10 * 6e4;
-var RESOURCE_USAGE_REPORT_DELAY_JITTER_FRACTION = 0.2;
-var RESOURCE_USAGE_FAILURE_REESCALATION_TICKS = 6;
 function scheduleResourceUsageReporting(state, options) {
   const { enabled, warnings } = resolveResourceUsageReportingEnabled(
     options.resourceUsageReporting,
@@ -10697,10 +12324,7 @@ function scheduleResourceUsageReporting(state, options) {
         consecutiveFailures++;
         logActivity(state, {
           type: "info",
-          level: reportFailureLogLevel(
-            consecutiveFailures,
-            RESOURCE_USAGE_FAILURE_REESCALATION_TICKS
-          ),
+          level: usageReportFailureLogLevel(consecutiveFailures),
           message: `Failed to report resource usage: ${result.error}${failureStreakSuffix(consecutiveFailures)}`
         });
       }
@@ -10709,20 +12333,11 @@ function scheduleResourceUsageReporting(state, options) {
       const message = error2 instanceof Error ? error2.message : String(error2);
       logActivity(state, {
         type: "info",
-        level: reportFailureLogLevel(
-          consecutiveFailures,
-          RESOURCE_USAGE_FAILURE_REESCALATION_TICKS
-        ),
+        level: usageReportFailureLogLevel(consecutiveFailures),
         message: `Resource usage reporting failed: ${message}${failureStreakSuffix(consecutiveFailures)}`
       });
     } finally {
-      state.resourceUsageTimer = setTimeout(
-        () => void tick(),
-        jitteredDelayMs(
-          RESOURCE_USAGE_BASE_REPORT_DELAY_MS,
-          RESOURCE_USAGE_REPORT_DELAY_JITTER_FRACTION
-        )
-      );
+      state.resourceUsageTimer = setTimeout(() => void tick(), usageReportDelayMs());
     }
   };
   state.resourceUsageTimer = setTimeout(() => void tick(), firstReportDelayMs());
@@ -10931,6 +12546,9 @@ async function run(options) {
     connected: false,
     opencodeConnected: false,
     opencodeVersion: null,
+    opencodeApiVersion: "v1",
+    opencodePassword: null,
+    opencodeClient: null,
     sessionDbProvenanceAnomaly: false,
     opencodeProcess: null,
     stopOpenCodeLogTail: null,
@@ -11085,7 +12703,7 @@ async function run(options) {
       console.log(chalk7.bold("Evident Run"));
       console.log(chalk7.dim("-".repeat(40)));
     }
-    const spinner = interactive && !state.json ? ora3("Validating runner...").start() : null;
+    const spinner = interactive && !state.json ? ora4("Validating runner...").start() : null;
     let validation = await getAgentInfo(state.agentId, state.authHeader);
     if (!validation.valid && validation.authFailed && interactive) {
       spinner?.fail("Authentication failed");
@@ -11206,7 +12824,7 @@ async function run(options) {
       logActivity(state, { type: "info", level: "warn", message: warning2 });
     }
     const preBootMigrationIds = readSessionDbMigrationIds(sessionDbPath());
-    const ocSpinner = interactive && !state.json ? ora3("Checking OpenCode...").start() : null;
+    const ocSpinner = interactive && !state.json ? ora4("Checking OpenCode...").start() : null;
     try {
       const oc = opencodeVersion === "v2" ? await ensureOpenCode2Running({
         port: state.port,
@@ -11226,6 +12844,19 @@ async function run(options) {
       state.port = oc.port;
       state.opencodeProcess = options.opencodePidFile ? null : oc.process;
       state.opencodeVersion = oc.version;
+      state.opencodeApiVersion = opencodeVersion;
+      let opencodePassword = null;
+      if (opencodeVersion === "v2" && "password" in oc) {
+        const value = oc.password;
+        if (typeof value === "string" || value === null) opencodePassword = value;
+      }
+      state.opencodePassword = opencodePassword;
+      const openCodeClient = createOpenCodeClient({
+        port: state.port,
+        version: state.opencodeApiVersion,
+        password: state.opencodePassword
+      });
+      state.opencodeClient = openCodeClient;
       if (options.opencodePidFile && oc.process?.pid !== void 0) {
         try {
           writeFileSync6(options.opencodePidFile, `${oc.process.pid}
@@ -11262,15 +12893,19 @@ async function run(options) {
         const message = `OpenCode is not ready on port ${state.port}: ${oc.notReadyReason}. The runner will still come online, but messages will fail until opencode answers \u2014 raise the wait with --opencode-start-timeout <seconds> (env ${OPENCODE_START_TIMEOUT_ENV}).`;
         logActivity(state, { type: "info", level: "warn", message });
       } else {
-        const versionWarning = buildOpenCodeVersionWarning(state.opencodeVersion);
+        const versionWarning = buildOpenCodeVersionWarning(
+          state.opencodeVersion,
+          state.opencodeApiVersion
+        );
         if (versionWarning) {
           log2(state, versionWarning, "warn");
           if (state.interactive && !state.json) {
             logActivity(state, { type: "info", level: "warn", message: versionWarning });
           }
         }
+        await reloadProviderCache(state.port, state.opencodeClient ?? void 0);
         const noProviderWarning = buildNoProviderWarning(
-          await hasAnyConfiguredProvider(state.port)
+          await hasAnyConfiguredProvider(state.port, state.opencodeClient ?? void 0)
         );
         if (noProviderWarning) {
           log2(state, noProviderWarning, "warn");
@@ -11393,11 +13028,12 @@ async function run(options) {
       });
       log2(state, `Started litestream replication with config ${options.litestreamConfig}`);
     }
-    const tunnelSpinner = interactive && !state.json ? ora3("Connecting tunnel...").start() : null;
+    const tunnelSpinner = interactive && !state.json ? ora4("Connecting tunnel...").start() : null;
     const channelDriver = new ChannelDriver({
       agentId: state.agentId,
       port: state.port,
       apiUrl: getApiUrlConfig(),
+      openCodeClient: state.opencodeClient ?? void 0,
       getAuthHeader: () => state.authHeader,
       conversationFilter: state.conversationFilter,
       stuckQueuedMs: CHANNEL_STUCK_QUEUED_MS,
@@ -11423,6 +13059,7 @@ async function run(options) {
       agentId: state.agentId,
       getAuthHeader: () => state.authHeader,
       port: state.port,
+      openCodePassword: state.opencodePassword,
       isRunning: () => state.running,
       events: {
         onConnected: (agentId, isReconnect) => {
@@ -11447,7 +13084,11 @@ async function run(options) {
           emitAgentConnected(state.agentId, {
             port: state.port,
             cli_version: getCliVersion(),
-            opencode_version: state.opencodeVersion
+            opencode_version: reportedOpenCodeVersion({
+              version: state.opencodeVersion,
+              major: state.opencodeApiVersion,
+              connected: state.opencodeConnected
+            })
           });
           if (!isReconnect) tunnelSpinner?.succeed("Tunnel connected");
           if (state.interactive) displayStatus(state);
@@ -11563,7 +13204,7 @@ async function run(options) {
         state.openaiUsageTimer = timer;
       },
       fetchUsage: async () => {
-        const usage = await getOpenAiUsage(state.port);
+        const usage = await getOpenAiUsage(state.port, state.opencodeClient ?? void 0);
         if (usage.subscription === null) {
           logActivity(state, {
             type: "info",