@khalilgharbaoui/opencode-claude-code-plugin 0.57.2 → 0.59.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/claude-code-language-model.ts
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/ids.ts
 import { randomInt } from "crypto";
@@ -272,6 +272,8 @@ var MAX_TOASTED_MESSAGES = 200;
 var toastBurstLimit = 3;
 var toastBurstWindowMs = 2e3;
 var activeSink = null;
+var activeNotifier = null;
+var bufferedNotices = [];
 var bufferedEntries = [];
 var droppedBeforeSink = 0;
 var toastedMessages = /* @__PURE__ */ new Set();
@@ -296,6 +298,13 @@ function setLogSink(sink) {
     });
   }
 }
+function setToastNotifier(notifier) {
+  activeNotifier = notifier;
+  if (!notifier) return;
+  const pending2 = bufferedNotices;
+  bufferedNotices = [];
+  for (const entry of pending2) maybeToast(entry, notifier);
+}
 function routeToSink(entry) {
   if (!activeSink) {
     if (bufferedEntries.length >= MAX_BUFFERED_SINK_ENTRIES) {
@@ -314,18 +323,34 @@ function deliverToSink(entry) {
     sink.log(entry);
   } catch {
   }
+  maybeToast(entry, (toast) => sink.toast(toast));
+}
+function maybeToast(entry, send) {
   if (entry.level !== "warn" && entry.level !== "error") return;
   if (toastedMessages.has(entry.message)) return;
   if (toastedMessages.size < MAX_TOASTED_MESSAGES) toastedMessages.add(entry.message);
   if (!allowToastNow()) return;
-  sendToast(sink, entry);
+  sendToast(send, entry);
 }
-function sendToast(sink, entry) {
+function sendToast(send, entry) {
   try {
-    sink.toast(entry);
+    send(entry);
   } catch {
   }
 }
+function toastTarget() {
+  const sink = activeSink;
+  if (sink) return (entry) => sink.toast(entry);
+  return activeNotifier;
+}
+function routeToNotifier(entry) {
+  const notifier = activeNotifier;
+  if (notifier) {
+    maybeToast(entry, notifier);
+    return;
+  }
+  if (bufferedNotices.length < MAX_BUFFERED_SINK_ENTRIES) bufferedNotices.push(entry);
+}
 function allowToastNow() {
   const now = Date.now();
   if (now - burstWindowStart >= toastBurstWindowMs) {
@@ -347,10 +372,11 @@ function armBurstSummary() {
     const suppressed = burstSuppressed;
     burstSuppressed = 0;
     if (suppressed <= 0) return;
-    const sink = activeSink;
-    if (!sink) return;
-    const message = `${suppressed} more claude-code warning(s) were not shown; the full text is in opencode's log`;
-    sendToast(sink, { level: "warn", message, line: fmt("WARN", message) });
+    const target = toastTarget();
+    if (!target) return;
+    const where = activeSink ? "opencode's log" : "the plugin log file";
+    const message = `${suppressed} more claude-code warning(s) were not shown; the full text is in ${where}`;
+    sendToast(target, { level: "warn", message, line: fmt("WARN", message) });
   }, toastBurstWindowMs);
   burstSummaryTimer.unref?.();
 }
@@ -366,6 +392,7 @@ function emit(level, msg, data) {
       routeToSink({ level, message: msg, data, line });
     } else {
       console.error(line);
+      if (level === "warn" || level === "error") routeToNotifier({ level, message: msg, data, line });
     }
   }
   writeToFile(line);
@@ -6374,10 +6401,71 @@ function watchChildSession(sessionID) {
   });
   return () => answer;
 }
+var eventRunStates = /* @__PURE__ */ new Map();
+var MAX_EVENT_RUN_STATES = 512;
+var openEventFeeds = 0;
+function openSessionRunEventFeed() {
+  openEventFeeds += 1;
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    openEventFeeds = Math.max(0, openEventFeeds - 1);
+    eventRunStates.clear();
+  };
+}
+function noteSessionRunEvent(event) {
+  if (openEventFeeds === 0 || !event || typeof event !== "object") return;
+  const { type, data } = event;
+  if (typeof type !== "string" || !data || typeof data !== "object") return;
+  const sessionID = data.sessionID;
+  if (typeof sessionID !== "string" || !sessionID || sessionID === "default") return;
+  if (type === "session.deleted") {
+    eventRunStates.delete(sessionID);
+    return;
+  }
+  let next;
+  switch (type) {
+    case "session.execution.started":
+      next = "busy";
+      break;
+    case "session.execution.succeeded":
+    case "session.execution.failed":
+    case "session.execution.interrupted":
+    case "session.idle":
+      next = "idle";
+      break;
+    case "session.status": {
+      const status = data.status?.type;
+      if (typeof status === "string") next = status === "idle" ? "idle" : "busy";
+      break;
+    }
+  }
+  if (!next) return;
+  eventRunStates.delete(sessionID);
+  eventRunStates.set(sessionID, next);
+  while (eventRunStates.size > MAX_EVENT_RUN_STATES) {
+    const oldest = eventRunStates.keys().next().value;
+    if (oldest === void 0) break;
+    eventRunStates.delete(oldest);
+  }
+}
+function sessionRunStateFromEvents(sessionID) {
+  if (openEventFeeds === 0) return "unknown";
+  return eventRunStates.get(sessionID) ?? "unknown";
+}
+function busySessionsFromEvents() {
+  if (openEventFeeds === 0) return void 0;
+  const busy = {};
+  for (const [sessionID, state] of eventRunStates) {
+    if (state === "busy") busy[sessionID] = { type: "busy" };
+  }
+  return busy;
+}
 async function fetchSessionRunState(sessionID, directory) {
   if (!sessionID || sessionID === "default") return "unknown";
   const status = opencodeClient?.session?.status;
-  if (!status) return "unknown";
+  if (!status) return sessionRunStateFromEvents(sessionID);
   try {
     const dir = directory ?? await fetchSessionDirectory(sessionID);
     const res = await status.call(
@@ -7734,6 +7822,27 @@ function deleteActiveProcessesForSession(sessionID) {
   forgetDispatchChoicesForSession(sessionID);
   return released;
 }
+var STOPPED_TURN_MESSAGE = "opencode stopped the turn while it was running its proxy tool calls";
+function releaseParkedProxyCallsForSession(sessionID, reason = STOPPED_TURN_MESSAGE) {
+  if (!sessionID || sessionID === "default") return [];
+  const released = [];
+  for (const [key, ap] of [...activeProcesses]) {
+    const owned = ap.opencodeSessionID === sessionID || describeSessionKey(key).session === sessionID;
+    if (!owned) continue;
+    if (ap.lineEmitter.listenerCount("line") > 0) continue;
+    if (getPendingProxyCalls(key).length === 0) continue;
+    log.info("opencode stopped the turn at a proxy tool boundary; releasing pending calls", {
+      sessionKey: key,
+      sessionID
+    });
+    void interruptTurn(ap).then((idle) => {
+      log.info("interrupt sent for aborted turn", { sk: key, idle });
+    });
+    rejectAllPendingProxyCallsForSession(key, new Error(reason));
+    released.push(key);
+  }
+  return released;
+}
 function killAllActiveProcesses() {
   const keys = [...activeProcesses.keys()];
   for (const key of keys) deleteActiveProcess(key);
@@ -8373,17 +8482,14 @@ async function fetchAsideHistory(client, sessionID, question) {
     return [];
   }
 }
-async function handleBtwCommand(client, input, options = {}) {
+async function runBtwCommand(client, input, options = {}) {
   const question = input.arguments.trim();
-  if (!question) {
-    showToast(client, { title: "btw", message: SIDE_QUESTION_USAGE, variant: "warning", duration: 6e3 });
-    throw new BtwHandledError("/btw needs a question.");
-  }
+  if (!question) return "bare";
   const active = await waitForAsideProcess(client, input.sessionID, options);
   const transport = active?.asideTransport;
   if (!active || !transport) {
     if (active) log.info("btw: process has no aside transport, leaving it to the turn", { sessionID: input.sessionID });
-    return;
+    return "release";
   }
   let busy = false;
   let inlineDone = false;
@@ -8444,7 +8550,7 @@ async function handleBtwCommand(client, input, options = {}) {
       }
     );
   }
-  if (!busy) return;
+  if (!busy) return "release";
   const started2 = Date.now();
   const outcome = await Promise.race([
     inlineDelivered,
@@ -8457,18 +8563,46 @@ async function handleBtwCommand(client, input, options = {}) {
       sessionID: input.sessionID,
       waitedMs: Date.now() - started2
     });
-    throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
+    return "inline";
   }
   log.info("btw: turn over, releasing the /btw message", {
     sessionID: input.sessionID,
     idle: outcome === "idle",
     waitedMs: Date.now() - started2
   });
+  return outcome === "timeout" ? "timeout" : "release";
+}
+async function handleBtwCommand(client, input, options = {}) {
+  const outcome = await runBtwCommand(client, input, options);
+  if (outcome === "bare") {
+    showToast(client, { title: "btw", message: SIDE_QUESTION_USAGE, variant: "warning", duration: 6e3 });
+    throw new BtwHandledError("/btw needs a question.");
+  }
+  if (outcome === "inline") throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
   if (outcome === "timeout") {
     showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
     throw new BtwHandledError(BTW_TURN_TOO_LONG_MESSAGE);
   }
 }
+async function askBtwThenRelease(client, input, release2, options = {}) {
+  let outcome;
+  try {
+    outcome = await runBtwCommand(client, input, options);
+  } catch (error) {
+    log.warn("btw: the early aside failed; sending the /btw message as it is", {
+      sessionID: input.sessionID,
+      error: errorText(error)
+    });
+    outcome = "failed";
+  }
+  if (outcome === "inline") return outcome;
+  try {
+    await release2();
+  } catch (error) {
+    log.warn("btw: could not send the /btw message", { sessionID: input.sessionID, error: errorText(error) });
+  }
+  return outcome;
+}
 
 // src/budget-ledger.ts
 var BUDGET_MARKER = "\u258C **budget:**";
@@ -8638,7 +8772,9 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "automatic account switch skipped an account whose runtime could not be prepared",
   "background dispatch refused by maxBackgroundSubagents",
   "btw: a turn is running but no claude process appeared for it",
+  "btw: could not send the /btw message",
   "btw: early aside failed; the message will ask again",
+  "btw: the early aside failed; sending the /btw message as it is",
   "budget option refused: not a positive number of dollars",
   "budgetWarnAt refused: expected percentages between 0 and 100",
   "cannot interrupt this transport; waiting for the turn to end",
@@ -8727,7 +8863,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "no configured account could take this turn; it ends here",
   "no proxyTools entry was recognised; nothing will be proxied this turn",
   "no stdout after envelope write; respawning claude process to resume conversation",
-  "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction",
+  "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction, and stopped turns keep their proxy calls until the next message",
   "opencode's stored OAuth token for this MCP server has expired, so the bridged server carries no credential; re-authenticate it in opencode",
   "pending proxy call arrived after stream close; rejecting",
   'permissionMode "plan" is enforced: claude cannot edit files or run commands, and --dangerously-skip-permissions is deliberately not passed so it stays that way. Headless Claude Code is not offered an ExitPlanMode tool, so nothing releases plan mode mid-session; approving a plan in chat does not unlock writes. Leaving plan mode means changing the config and restarting opencode.',
@@ -9635,6 +9771,625 @@ async function fetchPlanUsage(cliPath, options = {}) {
   }
 }
 
+// src/turn-history.ts
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync6, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join11 } from "path";
+
+// src/turn-progress-store.ts
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync5, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
+var MAX_TURN_PROGRESS = 64;
+var TURN_PROGRESS_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var TAG = /^[0-9a-f]{8}$/;
+var pathOverride4 = null;
+function turnProgressStorePath() {
+  if (pathOverride4) return pathOverride4;
+  const stateRoot = process.env.XDG_STATE_HOME || join10(homedir10(), ".local", "state");
+  return join10(stateRoot, "opencode-claude-code-plugin", "turn-progress.json");
+}
+function isProgress(value) {
+  const record = value;
+  if (!record || typeof record !== "object" || Array.isArray(record)) return false;
+  const count = (field) => typeof field === "number" && Number.isFinite(field) && field >= 0;
+  return count(record.turn) && count(record.out) && count(record.at);
+}
+function readEntries(file, now) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync6(file, "utf8"));
+    const entries = parsed && typeof parsed === "object" ? parsed.turns : null;
+    if (!entries || typeof entries !== "object") return out;
+    const cutoff = now - TURN_PROGRESS_MAX_AGE_MS;
+    const valid = Object.entries(entries).filter((entry) => TAG.test(entry[0]) && isProgress(entry[1])).filter(([, record]) => record.at >= cutoff).sort((a, b) => a[1].at - b[1].at).slice(-MAX_TURN_PROGRESS);
+    for (const [tag, record] of valid) out.set(tag, { turn: record.turn, out: Math.round(record.out), at: record.at });
+  } catch {
+  }
+  return out;
+}
+function recordTurnProgress(tag, progress, now = Date.now()) {
+  const record = { turn: progress.turn, out: progress.out, at: now };
+  if (!TAG.test(tag) || !isProgress(record)) return false;
+  const file = turnProgressStorePath();
+  const merged = readEntries(file, now);
+  merged.delete(tag);
+  merged.set(tag, { ...record, out: Math.round(record.out) });
+  const kept = [...merged.entries()].slice(-MAX_TURN_PROGRESS);
+  try {
+    mkdirSync6(join10(file, ".."), { recursive: true, mode: 448 });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync6(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
+    renameSync5(tmp, file);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+// src/turn-history.ts
+var MAX_TURN_SAMPLES = 48;
+var MAX_TURN_KEYS = 64;
+var TURN_SAMPLE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var SESSION_TAG = /^[0-9a-f]{8}$/;
+var pathOverride5 = null;
+function turnHistoryStorePath() {
+  if (pathOverride5) return pathOverride5;
+  const stateRoot = process.env.XDG_STATE_HOME || join11(homedir11(), ".local", "state");
+  return join11(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
+}
+function turnHistoryKey(agent, model) {
+  return `${agent || "main"}/${model}`;
+}
+function sessionTag(sessionID) {
+  if (!sessionID || sessionID === "default") return void 0;
+  let hash = 2166136261;
+  for (let index = 0; index < sessionID.length; index += 1) {
+    hash ^= sessionID.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+var INJECTED_BLOCKS = [
+  /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+  /<dcp-system-reminder>[\s\S]*?<\/dcp-system-reminder>/g,
+  /<dcp-message-id>[\s\S]*?<\/dcp-message-id>/g
+];
+function promptChars(texts) {
+  if (texts.length === 0) return void 0;
+  let total = 0;
+  for (const text of texts) {
+    let stripped = text;
+    for (const block of INJECTED_BLOCKS) stripped = stripped.replace(block, "");
+    total += stripped.trim().length;
+  }
+  return total;
+}
+function textsOf(content) {
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+  const texts = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object" || part.type !== "text") continue;
+    const text = part.text;
+    if (typeof text === "string") texts.push(text);
+  }
+  return texts;
+}
+function newestPromptChars(prompt) {
+  for (let index = prompt.length - 1; index >= 0; index -= 1) {
+    if (prompt[index].role === "user") return promptChars(textsOf(prompt[index].content));
+  }
+  return void 0;
+}
+function toolResultParts(message) {
+  if (!Array.isArray(message.content)) return [];
+  return message.content.filter(
+    (part) => !!part && typeof part === "object" && part.type === "tool-result"
+  );
+}
+function startsTurn(prompt, pendingToolCallIds) {
+  const last = prompt[prompt.length - 1];
+  if (!last || last.role !== "user") return false;
+  const before = prompt[prompt.length - 2];
+  if (before === void 0 || before.role !== "tool") return true;
+  if (!pendingToolCallIds) return false;
+  return toolResultParts(before).every((part) => typeof part.toolCallId !== "string" || !pendingToolCallIds.has(part.toolCallId));
+}
+function turnToolCalls(prompt, from) {
+  let start = 0;
+  if (from !== void 0 && from >= 0 && from <= prompt.length) {
+    start = from;
+  } else {
+    for (let index = prompt.length - 1; index >= 0; index -= 1) {
+      if (prompt[index].role !== "user") continue;
+      const before = prompt[index - 1];
+      if (before === void 0 || before.role !== "tool") {
+        start = index;
+        break;
+      }
+    }
+  }
+  let calls = 0;
+  for (let index = start; index < prompt.length; index += 1) {
+    const message = prompt[index];
+    if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (part && typeof part === "object" && part.type === "tool-call") calls += 1;
+    }
+  }
+  return calls;
+}
+function lastToolResultFailed(prompt, from) {
+  for (let index = prompt.length - 1; index >= Math.max(0, from); index -= 1) {
+    const message = prompt[index];
+    if (message.role === "user") continue;
+    if (message.role !== "tool") return false;
+    const parts = toolResultParts(message);
+    const newest = parts[parts.length - 1];
+    const output = newest?.output;
+    const type = output && typeof output === "object" ? output.type : void 0;
+    return type === "error-text" || type === "error-json" || type === "execution-denied";
+  }
+  return false;
+}
+var MAX_TURN_STARTS = 256;
+var turnStarts = /* @__PURE__ */ new Map();
+function markTurnStart(key, start) {
+  turnStarts.delete(key);
+  if (turnStarts.size >= MAX_TURN_STARTS) {
+    const oldest = turnStarts.keys().next().value;
+    if (oldest !== void 0) turnStarts.delete(oldest);
+  }
+  turnStarts.set(key, {
+    at: start.at,
+    ...start.chars !== void 0 ? { chars: start.chars } : {},
+    ...start.promptLength !== void 0 ? { promptLength: start.promptLength } : {},
+    ...start.session !== void 0 ? { session: start.session } : {}
+  });
+}
+function noteTurnOutput(key, tokens, now = Date.now()) {
+  const start = turnStarts.get(key);
+  if (!start || !Number.isFinite(tokens) || tokens < 0) return;
+  start.out = (start.out ?? 0) + tokens;
+  if (start.session) recordTurnProgress(start.session, { turn: start.at, out: start.out }, now);
+}
+function takeTurnStart(key) {
+  const start = turnStarts.get(key);
+  turnStarts.delete(key);
+  return start;
+}
+function isSample(value) {
+  const sample = value;
+  if (!sample || typeof sample !== "object" || Array.isArray(sample)) return false;
+  if (typeof sample.ms !== "number" || !Number.isFinite(sample.ms) || sample.ms < 0) return false;
+  if (typeof sample.at !== "number" || !Number.isFinite(sample.at)) return false;
+  if (sample.chars !== void 0 && (typeof sample.chars !== "number" || !Number.isFinite(sample.chars) || sample.chars < 0)) {
+    return false;
+  }
+  if (sample.effort !== void 0 && typeof sample.effort !== "string") return false;
+  if (sample.calls !== void 0 && (typeof sample.calls !== "number" || !Number.isFinite(sample.calls) || sample.calls < 0)) {
+    return false;
+  }
+  if (sample.out !== void 0 && (typeof sample.out !== "number" || !Number.isFinite(sample.out) || sample.out < 0)) {
+    return false;
+  }
+  if (sample.failed !== void 0 && typeof sample.failed !== "boolean") return false;
+  if (sample.session !== void 0 && (typeof sample.session !== "string" || !SESSION_TAG.test(sample.session))) {
+    return false;
+  }
+  return true;
+}
+function cleanSample(sample) {
+  return {
+    ms: Math.round(sample.ms),
+    ...sample.chars !== void 0 ? { chars: Math.round(sample.chars) } : {},
+    ...sample.effort ? { effort: sample.effort } : {},
+    ...sample.calls !== void 0 ? { calls: Math.round(sample.calls) } : {},
+    ...sample.out !== void 0 ? { out: Math.round(sample.out) } : {},
+    ...sample.failed ? { failed: true } : {},
+    ...sample.session ? { session: sample.session } : {},
+    at: sample.at
+  };
+}
+function readEntries2(file, now) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync7(file, "utf8"));
+    const entries = parsed && typeof parsed === "object" ? parsed.turns : null;
+    if (!entries || typeof entries !== "object") return out;
+    const cutoff = now - TURN_SAMPLE_MAX_AGE_MS;
+    for (const [key, value] of Object.entries(entries)) {
+      if (!key || !Array.isArray(value)) continue;
+      const samples = value.filter(isSample).filter((sample) => sample.at >= cutoff).sort((a, b) => a.at - b.at).slice(-MAX_TURN_SAMPLES).map(cleanSample);
+      if (samples.length > 0) out.set(key, samples);
+    }
+  } catch {
+  }
+  return out;
+}
+function bounded2(history) {
+  const newest = (samples) => samples[samples.length - 1]?.at ?? 0;
+  return new Map([...history.entries()].sort((a, b) => newest(a[1]) - newest(b[1])).slice(-MAX_TURN_KEYS));
+}
+function recordTurnSample(key, sample) {
+  if (!key || !isSample(sample)) return false;
+  const file = turnHistoryStorePath();
+  const merged = readEntries2(file, sample.at);
+  const samples = [...merged.get(key) ?? [], cleanSample(sample)].sort((a, b) => a.at - b.at).slice(-MAX_TURN_SAMPLES);
+  merged.set(key, samples);
+  const kept = bounded2(merged);
+  try {
+    mkdirSync7(join11(file, ".."), { recursive: true, mode: 448 });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync7(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
+    renameSync6(tmp, file);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function createTurnHistoryReader(file = turnHistoryStorePath) {
+  let identity = "";
+  let cached2 = /* @__PURE__ */ new Map();
+  return {
+    read(now = Date.now()) {
+      const path15 = file();
+      let next = "";
+      try {
+        const stats = statSync6(path15);
+        next = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
+      } catch {
+        next = "missing";
+      }
+      if (next !== identity) {
+        identity = next;
+        cached2 = next === "missing" ? /* @__PURE__ */ new Map() : readEntries2(path15, now);
+      }
+      return cached2;
+    }
+  };
+}
+
+// src/turn-model.ts
+var MIN_TURN_SAMPLES = 3;
+var CHARS_BANDWIDTH = Math.log(4);
+var OTHER_EFFORT_WEIGHT = 0.5;
+var MIN_EFFORT_RATIO_SAMPLES = 2;
+var RECENCY_HALF_LIFE_MS = 7 * 24 * 60 * 60 * 1e3;
+var MIN_CONDITIONED_SAMPLES = 1;
+var SHRINKAGE_KAPPA = 2;
+var CONDITIONED_KAPPA = 1;
+var DEFAULT_LOG_SIGMA = 0.8;
+var MIN_LOG_SIGMA = 0.2;
+var MAX_LOG_SIGMA = 1.6;
+var CALIBRATION_PRIOR_RESIDUALS = 12;
+var MAX_ASSESSED_PER_KEY = 16;
+var MAX_CALIBRATION_RESIDUALS = 512;
+var GRID_LOW = -8;
+var GRID_HIGH = 8;
+var GRID_STEP = 0.04;
+var CHARS_FLOOR = 50;
+function normalCdf(z) {
+  if (!Number.isFinite(z)) return z > 0 ? 1 : 0;
+  const x = Math.abs(z);
+  const t = 1 / (1 + 0.2316419 * x);
+  const poly = t * (0.31938153 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
+  const tail = Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI) * poly;
+  return z >= 0 ? 1 - tail : tail;
+}
+function normalQuantile(p) {
+  const q = Math.min(1 - 1e-12, Math.max(1e-12, p));
+  const a = [-39.69683028665376, 220.9460984245205, -275.9285104469687, 138.357751867269, -30.66479806614716, 2.506628277459239];
+  const b = [-54.47609879822406, 161.5858368580409, -155.6989798598866, 66.80131188771972, -13.28068155288572];
+  const c = [-0.007784894002430293, -0.3223964580411365, -2.400758277161838, -2.549732539343734, 4.374664141464968, 2.938163982698783];
+  const d = [0.007784695709041462, 0.3224671290700398, 2.445134137142996, 3.754408661907416];
+  const low = 0.02425;
+  if (q < low || q > 1 - low) {
+    const r2 = Math.sqrt(-2 * Math.log(q < low ? q : 1 - q));
+    const x = (((((c[0] * r2 + c[1]) * r2 + c[2]) * r2 + c[3]) * r2 + c[4]) * r2 + c[5]) / ((((d[0] * r2 + d[1]) * r2 + d[2]) * r2 + d[3]) * r2 + 1);
+    return q < low ? x : -x;
+  }
+  const r = q - 0.5;
+  const s = r * r;
+  return (((((a[0] * s + a[1]) * s + a[2]) * s + a[3]) * s + a[4]) * s + a[5]) * r / (((((b[0] * s + b[1]) * s + b[2]) * s + b[3]) * s + b[4]) * s + 1);
+}
+function charsWeight(a, b) {
+  if (a === void 0 || b === void 0) return 1;
+  const distance = Math.log((a + CHARS_FLOOR) / (b + CHARS_FLOOR)) / CHARS_BANDWIDTH;
+  return Math.exp(-0.5 * distance * distance);
+}
+function effortWeight(a, b) {
+  return a === void 0 || b === void 0 || a === b ? 1 : OTHER_EFFORT_WEIGHT;
+}
+function recencyWeight(now, at) {
+  const age = Math.max(0, now - at);
+  return Math.pow(0.5, age / RECENCY_HALF_LIFE_MS);
+}
+function weightedMedian(values, weights) {
+  const order = values.map((_, index) => index).sort((a, b) => values[a] - values[b]);
+  const total = order.reduce((sum, index) => sum + weights[index], 0);
+  let cumulative = 0;
+  for (const index of order) {
+    cumulative += weights[index];
+    if (cumulative >= total / 2) return values[index];
+  }
+  return values[order[order.length - 1]];
+}
+function effortScales(samples, weights, effort) {
+  const scales = /* @__PURE__ */ new Map();
+  if (effort === void 0) return scales;
+  const groups = /* @__PURE__ */ new Map();
+  samples.forEach((sample, index) => {
+    if (sample.effort === void 0) return;
+    const group = groups.get(sample.effort) ?? [];
+    group.push(index);
+    groups.set(sample.effort, group);
+  });
+  const own = groups.get(effort);
+  if (!own || own.length < MIN_EFFORT_RATIO_SAMPLES) return scales;
+  const medianOf = (indices) => weightedMedian(
+    indices.map((index) => samples[index].ms),
+    indices.map((index) => weights[index])
+  );
+  const ownMedian = medianOf(own);
+  for (const [other, indices] of groups) {
+    if (other === effort || indices.length < MIN_EFFORT_RATIO_SAMPLES) continue;
+    const otherMedian = medianOf(indices);
+    if (ownMedian > 0 && otherMedian > 0) scales.set(other, ownMedian / otherMedian);
+  }
+  return scales;
+}
+function usableSamples(samples) {
+  return samples.filter((sample) => Number.isFinite(sample.ms) && sample.ms >= 0 && !sample.failed);
+}
+function prepare(samples, input, now) {
+  const usable = usableSamples(samples);
+  const base = usable.map((sample) => charsWeight(input.chars, sample.chars) * recencyWeight(now, sample.at));
+  const scales = effortScales(usable, base, input.effort);
+  return usable.map((sample, index) => {
+    const ms = sample.ms * (sample.effort !== void 0 ? scales.get(sample.effort) ?? 1 : 1);
+    return {
+      ms,
+      y: Math.log(Math.max(1, ms)),
+      weight: base[index] * effortWeight(input.effort, sample.effort),
+      calls: sample.calls,
+      out: sample.out,
+      sameEffort: input.effort === void 0 || sample.effort === void 0 || input.effort === sample.effort,
+      session: sample.session
+    };
+  });
+}
+function moments(set) {
+  let sumW = 0;
+  let sumW2 = 0;
+  let sumWY = 0;
+  for (const sample of set) {
+    sumW += sample.weight;
+    sumW2 += sample.weight * sample.weight;
+    sumWY += sample.weight * sample.y;
+  }
+  if (!(sumW > 0)) return void 0;
+  const mean = sumWY / sumW;
+  let sumWD = 0;
+  for (const sample of set) sumWD += sample.weight * (sample.y - mean) * (sample.y - mean);
+  const n = sumW * sumW / sumW2;
+  const variance = n > 1 ? sumWD / sumW * (n / (n - 1)) : 0;
+  return { mean, variance, n };
+}
+function shrink(own, prior, kappa = SHRINKAGE_KAPPA, meanKappa = kappa) {
+  if (!own) return prior;
+  const priorMu = prior?.mu ?? own.mean;
+  const priorVariance = prior ? prior.sigma * prior.sigma : DEFAULT_LOG_SIGMA * DEFAULT_LOG_SIGMA;
+  const mu = (own.n * own.mean + meanKappa * priorMu) / (own.n + meanKappa);
+  const variance = (own.n * own.variance + kappa * priorVariance) / (own.n + kappa);
+  return { mu, sigma: Math.min(MAX_LOG_SIGMA, Math.max(MIN_LOG_SIGMA, Math.sqrt(Math.max(0, variance)))) };
+}
+function agentPool(history, key, effort, now) {
+  const slash = key.indexOf("/");
+  if (slash < 0) return { count: 0, n: 0 };
+  const prefix = key.slice(0, slash + 1);
+  const pool = [];
+  for (const [other, samples] of history) {
+    if (other === key || !other.startsWith(prefix)) continue;
+    pool.push(...prepare(samples, { effort }, now));
+  }
+  const measured = moments(pool);
+  return { fit: shrink(measured, void 0), count: pool.length, n: measured?.n ?? 0 };
+}
+function fitKey(own, pool, input) {
+  if (own.length + pool.count < MIN_TURN_SAMPLES) return void 0;
+  const poolPull = pool.fit ? SHRINKAGE_KAPPA * pool.n / (pool.n + SHRINKAGE_KAPPA) : SHRINKAGE_KAPPA;
+  const key = shrink(moments(own), pool.fit, SHRINKAGE_KAPPA, poolPull);
+  if (!key) return void 0;
+  const mine = input.session === void 0 ? [] : own.filter((sample) => sample.session === input.session);
+  const usual = mine.length > 0 ? shrink(moments(mine), key) ?? key : key;
+  const calls = input.calls !== void 0 && input.calls > 0 ? input.calls : void 0;
+  const out = input.out !== void 0 && input.out > 0 ? input.out : void 0;
+  let fit = usual;
+  if (calls !== void 0 || out !== void 0) {
+    const kept = own.filter(
+      (sample) => (calls === void 0 || sample.calls === void 0 || sample.calls >= calls) && (out === void 0 || sample.out === void 0 || !sample.sameEffort || sample.out >= out)
+    );
+    if (kept.length < own.length && kept.length >= MIN_CONDITIONED_SAMPLES) {
+      fit = shrink(moments(kept), usual, CONDITIONED_KAPPA) ?? usual;
+    }
+  }
+  const maxMs = own.length > 0 ? own.reduce((longest, sample) => Math.max(longest, sample.ms), 0) : Number.POSITIVE_INFINITY;
+  return { fit, usual, maxMs };
+}
+var NORMAL_CALIBRATION = { count: 0, weight: 0, cdf: normalCdf, quantile: normalQuantile };
+function weightedQuantile(sorted, total, q) {
+  let cumulative = 0;
+  let previous;
+  for (const entry of sorted) {
+    const at = (cumulative + entry.weight / 2) / total;
+    cumulative += entry.weight;
+    if (at >= q) {
+      if (!previous) return entry.value;
+      return previous.value + (q - previous.at) / (at - previous.at) * (entry.value - previous.value);
+    }
+    previous = { value: entry.value, at };
+  }
+  return sorted[sorted.length - 1].value;
+}
+function calibrationFrom(residuals, weights) {
+  const entries = residuals.map((value, index) => ({ value, weight: weights?.[index] ?? 1 })).filter((entry) => Number.isFinite(entry.value) && Number.isFinite(entry.weight) && entry.weight > 0).slice(-MAX_CALIBRATION_RESIDUALS);
+  if (entries.length === 0) return NORMAL_CALIBRATION;
+  let total = 0;
+  let squares = 0;
+  let sum = 0;
+  for (const entry of entries) {
+    total += entry.weight;
+    squares += entry.weight * entry.weight;
+    sum += entry.weight * entry.value;
+  }
+  const n = total * total / squares;
+  const mean = sum / total;
+  let deviation = 0;
+  for (const entry of entries) deviation += entry.weight * (entry.value - mean) * (entry.value - mean);
+  const sd = n > 1 ? Math.sqrt(deviation / total * (n / (n - 1))) : 0;
+  const sorted = [...entries].sort((a, b) => a.value - b.value);
+  const iqr = weightedQuantile(sorted, total, 0.75) - weightedQuantile(sorted, total, 0.25);
+  const spreads = [sd, iqr / 1.349].filter((spread2) => spread2 > 0);
+  const spread = spreads.length > 0 ? Math.min(...spreads) : 1;
+  const width = Math.max(0.1, 0.9 * spread * Math.pow(n, -0.2));
+  const weight = n / (n + CALIBRATION_PRIOR_RESIDUALS);
+  const size = Math.round((GRID_HIGH - GRID_LOW) / GRID_STEP) + 1;
+  const table = new Float64Array(size);
+  for (let index = 0; index < size; index += 1) {
+    const z = GRID_LOW + index * GRID_STEP;
+    let kernel = 0;
+    for (const entry of entries) kernel += entry.weight * normalCdf((z - entry.value) / width);
+    table[index] = weight * (kernel / total) + (1 - weight) * normalCdf(z);
+  }
+  return {
+    count: entries.length,
+    weight,
+    cdf(z) {
+      if (Number.isNaN(z)) return 0.5;
+      const position = (Math.min(GRID_HIGH, Math.max(GRID_LOW, z)) - GRID_LOW) / GRID_STEP;
+      const index = Math.min(size - 2, Math.floor(position));
+      return table[index] + (position - index) * (table[index + 1] - table[index]);
+    },
+    quantile(p) {
+      if (!(p > table[0])) return GRID_LOW;
+      if (!(p < table[size - 1])) return GRID_HIGH;
+      let low = 0;
+      let high = size - 1;
+      while (high - low > 1) {
+        const mid = low + high >> 1;
+        if (table[mid] < p) low = mid;
+        else high = mid;
+      }
+      const span = table[high] - table[low];
+      return GRID_LOW + (low + (span > 0 ? (p - table[low]) / span : 1)) * GRID_STEP;
+    }
+  };
+}
+function quantileMs(fit, calibration, truncatedAtMs, q) {
+  const passed = truncatedAtMs > 0 ? calibration.cdf((Math.log(truncatedAtMs) - fit.mu) / fit.sigma) : 0;
+  return Math.exp(fit.mu + fit.sigma * calibration.quantile(passed + q * (1 - passed)));
+}
+var EMPTY_HISTORY = /* @__PURE__ */ new Map();
+function buildTurnModel(history = EMPTY_HISTORY, now = Date.now()) {
+  const pools = /* @__PURE__ */ new Map();
+  const poolFor = (key, effort) => {
+    const id = `${key}\0${effort ?? ""}`;
+    let pool = pools.get(id);
+    if (!pool) {
+      pool = agentPool(history, key, effort, now);
+      pools.set(id, pool);
+    }
+    return pool;
+  };
+  const assessed = /* @__PURE__ */ new Map();
+  const residuals = [];
+  const residualWeights = [];
+  for (const [key, samples] of history) {
+    const usable = usableSamples(samples);
+    if (usable.length < 2) continue;
+    const rows = [];
+    for (const held of usable.slice(-MAX_ASSESSED_PER_KEY)) {
+      const input = { chars: held.chars, effort: held.effort, session: held.session };
+      const own = prepare(
+        usable.filter((sample) => sample !== held),
+        input,
+        now
+      );
+      const fitted = fitKey(own, poolFor(key, held.effort), input);
+      if (!fitted) continue;
+      rows.push({ ms: held.ms, fit: fitted.fit });
+      residuals.push((Math.log(Math.max(1, held.ms)) - fitted.fit.mu) / fitted.fit.sigma);
+      residualWeights.push(recencyWeight(now, held.at));
+    }
+    if (rows.length > 0) assessed.set(key, rows);
+  }
+  const calibration = calibrationFrom(residuals, residualWeights);
+  const estimate = (key, input) => {
+    const at = input.now ?? now;
+    const own = prepare(history.get(key) ?? [], input, at);
+    const fitted = fitKey(own, poolFor(key, input.effort), input);
+    if (!fitted) return void 0;
+    const elapsed = Math.max(0, Number.isFinite(input.elapsedMs) ? input.elapsedMs : 0);
+    if (elapsed > fitted.maxMs) {
+      return { totalMs: quantileMs(fitted.usual, calibration, 0, 0.5), fill: 1, over: true };
+    }
+    const totalMs = Math.max(elapsed, quantileMs(fitted.fit, calibration, elapsed, 0.5));
+    const lowMs = Math.min(totalMs, Math.max(elapsed, quantileMs(fitted.fit, calibration, elapsed, 0.25)));
+    const highMs = Math.max(totalMs, quantileMs(fitted.fit, calibration, elapsed, 0.75));
+    return {
+      totalMs,
+      fill: totalMs > 0 ? elapsed / totalMs : 0,
+      over: false,
+      band: {
+        lowMs,
+        highMs,
+        sure: highMs > 0 ? elapsed / highMs : 0,
+        maybe: lowMs > 0 ? Math.min(1, elapsed / lowMs) : 0
+      }
+    };
+  };
+  const assess = () => {
+    const keys = [];
+    for (const [key, samples] of history) {
+      const usable = usableSamples(samples);
+      const failed = samples.filter((sample) => sample.failed).length;
+      if (usable.length === 0 && failed === 0) continue;
+      const durations = usable.map((sample) => sample.ms).sort((a, b) => a - b);
+      const typicalMs = durations.length > 0 ? durations[Math.floor((durations.length - 1) / 2)] : 0;
+      const rows = assessed.get(key) ?? [];
+      const misses = [];
+      let over = 0;
+      let inBand = 0;
+      for (const row of rows) {
+        const expected = Math.exp(row.fit.mu + row.fit.sigma * calibration.quantile(0.5));
+        const low = Math.exp(row.fit.mu + row.fit.sigma * calibration.quantile(0.25));
+        const high = Math.exp(row.fit.mu + row.fit.sigma * calibration.quantile(0.75));
+        misses.push(Math.abs(Math.log(Math.max(1, row.ms) / expected)));
+        if (row.ms > expected) over += 1;
+        if (row.ms >= low && row.ms <= high) inBand += 1;
+      }
+      misses.sort((a, b) => a - b);
+      keys.push({
+        key,
+        turns: usable.length,
+        failed,
+        typicalMs,
+        assessed: rows.length,
+        ...rows.length > 0 ? {
+          missFactor: Math.exp(misses[Math.floor((misses.length - 1) / 2)]),
+          overShare: over / rows.length,
+          inBandShare: inBand / rows.length
+        } : {}
+      });
+    }
+    keys.sort((a, b) => b.turns - a.turns || a.key.localeCompare(b.key));
+    return { keys, residuals: residuals.length, calibrationWeight: calibration.weight };
+  };
+  return { estimate, calibration, assess };
+}
+
 // src/stale-build.ts
 import * as fs7 from "fs";
 import * as path10 from "path";
@@ -10196,6 +10951,12 @@ function formatDoctorReport(report) {
     lines.push("");
     lines.push(...formatAccountUsage(report.accountUsage));
   }
+  if (report.turnEstimate) {
+    lines.push("");
+    lines.push("**Progress estimate**");
+    lines.push("");
+    lines.push(...formatTurnEstimate(report.turnEstimate));
+  }
   lines.push("");
   lines.push("**Background subagents**");
   lines.push("");
@@ -10312,6 +11073,37 @@ function formatAccountUsage(usage, now = Date.now()) {
     ...rows
   ];
 }
+function formatTurnEstimate(assessment) {
+  if (assessment.keys.length === 0) {
+    return [
+      `No turns recorded yet. The server half records one per served turn in \`turn-history.json\`; the sidebar draws a bar once an agent has ${MIN_TURN_SAMPLES} under one model, or that many across its other models.`
+    ];
+  }
+  const percent = (share) => share === void 0 ? "n/a" : `${Math.round(share * 100)}%`;
+  const lines = [
+    assessment.residuals === 0 ? "No leave-one-out error to calibrate on yet, so the band is the normal curve's." : `The band is calibrated on ${assessment.residuals} leave-one-out error${assessment.residuals === 1 ? "" : "s"}, which weigh ${percent(assessment.calibrationWeight)} against the normal curve: the curve counts as ${CALIBRATION_PRIOR_RESIDUALS}, so the measured spread takes over as they accrue.`,
+    "",
+    "| agent/model | turns | failed | typical | assessed | off by | outran | in band |",
+    "|---|---|---|---|---|---|---|---|"
+  ];
+  for (const key of assessment.keys) {
+    lines.push(
+      `| ${tableCell(key.key)} | ${key.turns} | ${key.failed} | ${key.turns > 0 ? formatAge(key.typicalMs) : "n/a"} | ${key.assessed} | ${key.missFactor === void 0 ? "n/a" : `\xD7${key.missFactor.toFixed(1)}`} | ${percent(key.overShare)} | ${percent(key.inBandShare)} |`
+    );
+  }
+  lines.push("");
+  lines.push(
+    "Each turn is estimated at its start from the rest of its record. `off by` is the typical factor between that estimate and what the turn took, either way (\xD71.5 is 50% off); `outran` is the share that took longer than estimated, and half is unbiased; `in band` is the share that ended inside the band the bar draws, and half is calibrated. A turn that ended on a failed tool is counted under `failed` and never read."
+  );
+  return lines;
+}
+function assessTurnEstimate() {
+  try {
+    return buildTurnModel(createTurnHistoryReader().read()).assess();
+  } catch {
+    return void 0;
+  }
+}
 function formatBackgroundSubagents(state) {
   const lines = [];
   if (state.running) {
@@ -10497,6 +11289,7 @@ async function gatherDoctorReport(options) {
     hookFailures: snapshotHookFailures(),
     planUsage,
     accountUsage: snapshotAccountUsage(),
+    turnEstimate: assessTurnEstimate(),
     backgroundSubagents: {
       gate: snapshotBackgroundSubagentGate(),
       ledgers: snapshotBackgroundTasks(),
@@ -11629,9 +12422,9 @@ async function resolveSkillPluginDirs(opts) {
 // src/claude-session-wrapper.ts
 import { EventEmitter as EventEmitter4 } from "events";
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync4, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync4, writeFileSync as writeFileSync9 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 
 // src/claude-session-bun.ts
 import * as os6 from "os";
@@ -12813,8 +13606,8 @@ ${text2}`
 }
 function stageImage(data, extension) {
   try {
-    const file = join14(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
-    writeFileSync7(file, data, { mode: 384, flag: "wx" });
+    const file = join16(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
+    writeFileSync9(file, data, { mode: 384, flag: "wx" });
     return file;
   } catch (err) {
     log.warn("interactive transport could not stage an image", {
@@ -13295,17 +14088,17 @@ function spawnInteractiveProcess(opts) {
 }
 
 // src/spawn-record-store.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync9, renameSync as renameSync5, statSync as statSync8, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join15 } from "path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync11, renameSync as renameSync7, statSync as statSync10, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join17 } from "path";
 var MAX_SPAWN_RECORDS = 256;
 var SPAWN_RECORD_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-var pathOverride4 = null;
+var pathOverride6 = null;
 var lastWritten = /* @__PURE__ */ new Map();
 function spawnRecordStorePath() {
-  if (pathOverride4) return pathOverride4;
-  const stateRoot = process.env.XDG_STATE_HOME || join15(homedir12(), ".local", "state");
-  return join15(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
+  if (pathOverride6) return pathOverride6;
+  const stateRoot = process.env.XDG_STATE_HOME || join17(homedir14(), ".local", "state");
+  return join17(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
 }
 function isRecord5(value) {
   const record = value;
@@ -13315,10 +14108,10 @@ function isRecord5(value) {
   if (!ok(record.model) || !ok(record.effort) || !ok(record.account) || !ok(record.agent)) return false;
   return !!record.model;
 }
-function readEntries(file) {
+function readEntries3(file) {
   const out = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(readFileSync9(file, "utf8"));
+    const parsed = JSON.parse(readFileSync11(file, "utf8"));
     const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
     if (!entries || typeof entries !== "object") return out;
     const cutoff = Date.now() - SPAWN_RECORD_MAX_AGE_MS;
@@ -13351,18 +14144,18 @@ ${record.account ?? ""}
 ${record.agent ?? ""}`;
   if (lastWritten.get(sessionID) === fingerprint) return false;
   const file = spawnRecordStorePath();
-  const merged = readEntries(file);
+  const merged = readEntries3(file);
   merged.delete(sessionID);
   merged.set(sessionID, record);
   const cutoff = now - SPAWN_RECORD_MAX_AGE_MS;
   const kept = [...merged.entries()].filter(([, entry]) => entry.at >= cutoff).sort((a, b) => a[1].at - b[1].at).slice(-MAX_SPAWN_RECORDS);
   try {
-    mkdirSync7(join15(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync9(join17(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync8(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
+    writeFileSync10(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
       mode: 384
     });
-    renameSync5(tmp, file);
+    renameSync7(tmp, file);
   } catch {
     return false;
   }
@@ -13371,157 +14164,6 @@ ${record.agent ?? ""}`;
   return true;
 }
 
-// src/turn-history.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync as renameSync6, statSync as statSync9, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join16 } from "path";
-var MAX_TURN_SAMPLES = 48;
-var MAX_TURN_KEYS = 64;
-var TURN_SAMPLE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-var CHARS_BANDWIDTH = Math.log(4);
-var pathOverride5 = null;
-function turnHistoryStorePath() {
-  if (pathOverride5) return pathOverride5;
-  const stateRoot = process.env.XDG_STATE_HOME || join16(homedir13(), ".local", "state");
-  return join16(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
-}
-function turnHistoryKey(agent, model) {
-  return `${agent || "main"}/${model}`;
-}
-var INJECTED_BLOCKS = [
-  /<system-reminder>[\s\S]*?<\/system-reminder>/g,
-  /<dcp-system-reminder>[\s\S]*?<\/dcp-system-reminder>/g,
-  /<dcp-message-id>[\s\S]*?<\/dcp-message-id>/g
-];
-function promptChars(texts) {
-  if (texts.length === 0) return void 0;
-  let total = 0;
-  for (const text of texts) {
-    let stripped = text;
-    for (const block of INJECTED_BLOCKS) stripped = stripped.replace(block, "");
-    total += stripped.trim().length;
-  }
-  return total;
-}
-function textsOf(content) {
-  if (typeof content === "string") return [content];
-  if (!Array.isArray(content)) return [];
-  const texts = [];
-  for (const part of content) {
-    if (!part || typeof part !== "object" || part.type !== "text") continue;
-    const text = part.text;
-    if (typeof text === "string") texts.push(text);
-  }
-  return texts;
-}
-function newestPromptChars(prompt) {
-  for (let index = prompt.length - 1; index >= 0; index -= 1) {
-    if (prompt[index].role === "user") return promptChars(textsOf(prompt[index].content));
-  }
-  return void 0;
-}
-function startsTurn(prompt) {
-  const last = prompt[prompt.length - 1];
-  if (!last || last.role !== "user") return false;
-  const before = prompt[prompt.length - 2];
-  return before === void 0 || before.role !== "tool";
-}
-function turnToolCalls(prompt) {
-  let start = 0;
-  for (let index = prompt.length - 1; index >= 0; index -= 1) {
-    if (prompt[index].role !== "user") continue;
-    const before = prompt[index - 1];
-    if (before === void 0 || before.role !== "tool") {
-      start = index;
-      break;
-    }
-  }
-  let calls = 0;
-  for (let index = start; index < prompt.length; index += 1) {
-    const message = prompt[index];
-    if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
-    for (const part of message.content) {
-      if (part && typeof part === "object" && part.type === "tool-call") calls += 1;
-    }
-  }
-  return calls;
-}
-var MAX_TURN_STARTS = 256;
-var turnStarts = /* @__PURE__ */ new Map();
-function markTurnStart(key, at, chars) {
-  turnStarts.delete(key);
-  if (turnStarts.size >= MAX_TURN_STARTS) {
-    const oldest = turnStarts.keys().next().value;
-    if (oldest !== void 0) turnStarts.delete(oldest);
-  }
-  turnStarts.set(key, { at, ...chars !== void 0 ? { chars } : {} });
-}
-function takeTurnStart(key) {
-  const start = turnStarts.get(key);
-  turnStarts.delete(key);
-  return start;
-}
-function isSample(value) {
-  const sample = value;
-  if (!sample || typeof sample !== "object" || Array.isArray(sample)) return false;
-  if (typeof sample.ms !== "number" || !Number.isFinite(sample.ms) || sample.ms < 0) return false;
-  if (typeof sample.at !== "number" || !Number.isFinite(sample.at)) return false;
-  if (sample.chars !== void 0 && (typeof sample.chars !== "number" || !Number.isFinite(sample.chars) || sample.chars < 0)) {
-    return false;
-  }
-  if (sample.effort !== void 0 && typeof sample.effort !== "string") return false;
-  if (sample.calls !== void 0 && (typeof sample.calls !== "number" || !Number.isFinite(sample.calls) || sample.calls < 0)) {
-    return false;
-  }
-  return true;
-}
-function cleanSample(sample) {
-  return {
-    ms: Math.round(sample.ms),
-    ...sample.chars !== void 0 ? { chars: Math.round(sample.chars) } : {},
-    ...sample.effort ? { effort: sample.effort } : {},
-    ...sample.calls !== void 0 ? { calls: Math.round(sample.calls) } : {},
-    at: sample.at
-  };
-}
-function readEntries2(file, now) {
-  const out = /* @__PURE__ */ new Map();
-  try {
-    const parsed = JSON.parse(readFileSync10(file, "utf8"));
-    const entries = parsed && typeof parsed === "object" ? parsed.turns : null;
-    if (!entries || typeof entries !== "object") return out;
-    const cutoff = now - TURN_SAMPLE_MAX_AGE_MS;
-    for (const [key, value] of Object.entries(entries)) {
-      if (!key || !Array.isArray(value)) continue;
-      const samples = value.filter(isSample).filter((sample) => sample.at >= cutoff).sort((a, b) => a.at - b.at).slice(-MAX_TURN_SAMPLES).map(cleanSample);
-      if (samples.length > 0) out.set(key, samples);
-    }
-  } catch {
-  }
-  return out;
-}
-function bounded2(history) {
-  const newest = (samples) => samples[samples.length - 1]?.at ?? 0;
-  return new Map([...history.entries()].sort((a, b) => newest(a[1]) - newest(b[1])).slice(-MAX_TURN_KEYS));
-}
-function recordTurnSample(key, sample) {
-  if (!key || !isSample(sample)) return false;
-  const file = turnHistoryStorePath();
-  const merged = readEntries2(file, sample.at);
-  const samples = [...merged.get(key) ?? [], cleanSample(sample)].sort((a, b) => a.at - b.at).slice(-MAX_TURN_SAMPLES);
-  merged.set(key, samples);
-  const kept = bounded2(merged);
-  try {
-    mkdirSync8(join16(file, ".."), { recursive: true, mode: 448 });
-    const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync9(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
-    renameSync6(tmp, file);
-  } catch {
-    return false;
-  }
-  return true;
-}
-
 // src/account-transcript.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { constants as fsConstants } from "fs";
@@ -13583,13 +14225,13 @@ function dedupe2(dirs) {
 }
 
 // src/prompts.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir14 } from "os";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir15 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join17 } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join18 } from "path";
 function readPromptFileIfPresent(path15) {
   try {
-    const content = readFileSync11(path15, "utf8").trim();
+    const content = readFileSync12(path15, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -13598,7 +14240,7 @@ function readPromptFileIfPresent(path15) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join17(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join18(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -13709,7 +14351,7 @@ var CLAUDE_NATIVE_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLA
 function userAuthoredInstructions(forwarded, opts = {}) {
   const readFile3 = opts.readFile ?? ((path15) => {
     try {
-      return readFileSync11(path15, "utf8");
+      return readFileSync12(path15, "utf8");
     } catch {
       return null;
     }
@@ -13750,8 +14392,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join17(homedir14(), ".config");
-  const globalAgents = readPromptFileIfPresent(join17(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join18(homedir15(), ".config");
+  const globalAgents = readPromptFileIfPresent(join18(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -13767,9 +14409,9 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path15 = join17(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path15 = join18(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync10(path15, content, { encoding: "utf8", mode: 384 });
+    writeFileSync11(path15, content, { encoding: "utf8", mode: 384 });
     return path15;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
@@ -14699,6 +15341,7 @@ function createTurnState(init) {
     toolCallsById: /* @__PURE__ */ new Map(),
     toolCallEmittedIds: /* @__PURE__ */ new Set(),
     toolCallAnsweredIds: /* @__PURE__ */ new Set(),
+    lastCliToolResultError: void 0,
     resultMeta: {},
     lastCallUsage: void 0,
     resultFailure: void 0,
@@ -15768,6 +16411,10 @@ ${plan}
       if (state.gotPartialEvents && msg.type === "message_delta" && typeof msg.delta?.stop_reason === "string") {
         state.lastStopReason = msg.delta.stop_reason;
       }
+      if (msg.type === "message_delta") {
+        const output = msg.usage?.output_tokens;
+        if (typeof output === "number") noteTurnOutput(state.sessionKey, output);
+      }
       if (msg.type === "assistant" && msg.message && typeof msg.message.stop_reason === "string") {
         state.lastStopReason = msg.message.stop_reason;
       }
@@ -16047,6 +16694,7 @@ ${plan}
             const toolCall = state.toolCallsById.get(block2.tool_use_id) ?? adoptOpenCliToolCall(state, ctx, block2.tool_use_id);
             if (toolCall) {
               const isError = block2.is_error === true;
+              state.lastCliToolResultError = isError;
               state.controller.enqueue({
                 type: "tool-result",
                 toolCallId: block2.tool_use_id,
@@ -16552,12 +17200,6 @@ var ClaudeCodeLanguageModel = class {
       this.config.provider
     );
   }
-  controlRequestBehaviorForTool(toolName) {
-    return controlRequestBehaviorForTool(this.config, toolName);
-  }
-  writeControlResponse(proc, requestId, response) {
-    writeControlResponse(proc, requestId, response);
-  }
   /**
    * Handle Claude stream-json control requests (`can_use_tool`, etc.) and
    * respond via stdin with a matching `control_response`.
@@ -16606,9 +17248,6 @@ var ClaudeCodeLanguageModel = class {
       thinkingDisplay: process.env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES === void 0 ? "summarized" : void 0
     };
   }
-  latestUserText(prompt) {
-    return latestUserText(prompt);
-  }
   synthesizeTitle(prompt) {
     return synthesizeTitle(prompt);
   }
@@ -17174,8 +17813,14 @@ var ClaudeCodeLanguageModel = class {
         account: (this.config.failoverAccounts?.length ?? 0) > 1 ? failover.target ?? sourceAccount : void 0,
         agent: this.getOpencodeAgent(options)
       });
-      if (startsTurn(options.prompt)) {
-        markTurnStart(sk, turnStartedAt, newestPromptChars(options.prompt));
+      const parked = new Set(getPendingProxyCalls(sk).map((call) => call.toolCallId));
+      if (startsTurn(options.prompt, parked)) {
+        markTurnStart(sk, {
+          at: turnStartedAt,
+          chars: newestPromptChars(options.prompt),
+          promptLength: options.prompt.length,
+          session: sessionTag(affinity)
+        });
       }
     }
     const hasPriorConversation = options.prompt.filter((m) => m.role === "user" || m.role === "assistant").length > 1;
@@ -17466,7 +18111,7 @@ var ClaudeCodeLanguageModel = class {
     let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
-      const transcriptPath2 = (id, dir) => join18(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id, dir) => join19(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
@@ -18540,7 +19185,18 @@ var ClaudeCodeLanguageModel = class {
                   // The turn's tool calls, counted as the TUI counts its tool
                   // parts (h #g250): the earlier steps' from the prompt, this
                   // step's own from what it emitted.
-                  calls: turnToolCalls(options.prompt) + state.toolCallEmittedIds.size,
+                  calls: turnToolCalls(options.prompt, start.promptLength) + state.toolCallEmittedIds.size,
+                  // The output its API calls generated, summed as the live
+                  // channel wrote it, so a running turn is compared with the
+                  // record in the same unit (h #g251).
+                  out: start.out,
+                  // A turn whose newest tool result was an error ended on a
+                  // failure (h #g251): this step's own CLI-executed results
+                  // are newer than the prompt's, so they answer first.
+                  failed: state.lastCliToolResultError ?? lastToolResultFailed(options.prompt, start.promptLength ?? 0),
+                  // The conversation, as a hash of its id: the estimate's
+                  // session level (h #g251).
+                  session: sessionTag(affinity),
                   at: endedAt
                 });
               }
@@ -18766,38 +19422,40 @@ var ClaudeCodeLanguageModel = class {
                 dropped: unattended.dropped
               });
               let partialText = false;
-              {
+              const narration = [];
+              for (const line of unattended.lines) {
+                try {
+                  const outer = JSON.parse(line);
+                  const msg = outer.type === "stream_event" && outer.event ? outer.event : outer;
+                  let text = "";
+                  if (msg.type === "content_block_delta" && msg.delta?.type === "text_delta") {
+                    text = msg.delta.text ?? "";
+                    partialText = true;
+                  } else if (msg.type === "assistant") {
+                    if (!partialText) text = (msg.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+                    partialText = false;
+                  } else if (msg.type === "result") {
+                    state.unattendedTurnEnded = true;
+                    for (const entry of state.activeProcess.pendingProxyCompletions?.values() ?? []) {
+                      if (isPendingProxyCallChannelClosed(entry.call)) entry.recoveryRequired = true;
+                    }
+                    if (outer.session_id) setClaudeSessionId(sk, outer.session_id);
+                    if (msg.is_error && msg.result) text = msg.result;
+                  }
+                  if (text) narration.push(text);
+                } catch {
+                }
+              }
+              if (narration.length > 0 || unattended.dropped > 0) {
                 const replayId = state.startTextBlock();
                 controller.enqueue({
                   type: "text-delta",
                   id: replayId,
                   delta: formatUnattendedReplayNote(unattended.dropped)
                 });
-                for (const line of unattended.lines) {
-                  try {
-                    const outer = JSON.parse(line);
-                    const msg = outer.type === "stream_event" && outer.event ? outer.event : outer;
-                    let text = "";
-                    if (msg.type === "content_block_delta" && msg.delta?.type === "text_delta") {
-                      text = msg.delta.text ?? "";
-                      partialText = true;
-                    } else if (msg.type === "assistant") {
-                      if (!partialText) text = (msg.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
-                      partialText = false;
-                    } else if (msg.type === "result") {
-                      state.unattendedTurnEnded = true;
-                      for (const entry of state.activeProcess.pendingProxyCompletions?.values() ?? []) {
-                        if (isPendingProxyCallChannelClosed(entry.call)) entry.recoveryRequired = true;
-                      }
-                      if (outer.session_id) setClaudeSessionId(sk, outer.session_id);
-                      if (msg.is_error && msg.result) text = msg.result;
-                    }
-                    if (text) controller.enqueue({ type: "text-delta", id: state.currentTextId ?? state.startTextBlock(), delta: text });
-                  } catch {
-                  }
-                }
+                for (const text of narration) controller.enqueue({ type: "text-delta", id: replayId, delta: text });
+                state.endTextBlock();
               }
-              state.endTextBlock();
               clearFallbackTimer(state);
               state.hasReceivedContent = false;
             }
@@ -18995,7 +19653,7 @@ var ClaudeCodeLanguageModel = class {
 };
 
 // src/account-tier.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 import path14 from "path";
 var ORGANIZATION_TYPE_LABELS = {
   claude_max: "Max",
@@ -19038,7 +19696,7 @@ function readTierFromConfigDir(configDir, allowLegacyFallback) {
 function readOauthAccount(file) {
   let raw;
   try {
-    raw = readFileSync12(file, "utf8");
+    raw = readFileSync13(file, "utf8");
   } catch {
     return void 0;
   }
@@ -19075,14 +19733,14 @@ function registerSidebarAccounts(accounts) {
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync13,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync14,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "fs";
-import { homedir as homedir15 } from "os";
-import { dirname as dirname7, join as join19, resolve as resolve6 } from "path";
+import { homedir as homedir16 } from "os";
+import { dirname as dirname7, join as join20, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -19090,20 +19748,20 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join19(xdg, "opencode") : null,
-    join19(homedir15(), ".cache", "opencode"),
-    join19(homedir15(), "Library", "Caches", "opencode")
+    xdg ? join20(xdg, "opencode") : null,
+    join20(homedir16(), ".cache", "opencode"),
+    join20(homedir16(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join19(homedir15(), ".config");
-  return join19(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join20(homedir16(), ".config");
+  return join20(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync5(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync13(cfg, "utf8"));
+    const json = JSON.parse(readFileSync14(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -19124,19 +19782,19 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync13(join19(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync14(join20(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join19(homedir15(), ".local", "state");
-  return join19(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join20(homedir16(), ".local", "state");
+  return join20(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync13(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync14(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -19145,8 +19803,8 @@ function markerVersion() {
 function writeMarker(version) {
   const file = markerPath();
   try {
-    mkdirSync9(dirname7(file), { recursive: true, mode: 448 });
-    writeFileSync11(
+    mkdirSync10(dirname7(file), { recursive: true, mode: 448 });
+    writeFileSync12(
       file,
       JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
       "utf8"
@@ -19181,7 +19839,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(cacheRoot)) return;
-  const stalePath = join19(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join20(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -19189,11 +19847,11 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join19(stalePath, "package.json");
+  const pkgJsonPath = join20(stalePath, "package.json");
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync13(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync14(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -19209,13 +19867,13 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join19(cacheRoot, "package.json");
+  const cachePkgJson = join20(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync13(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync14(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
-      writeFileSync11(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      writeFileSync12(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
       log.info("cleanup-stale: pruned dep from cache package.json");
     }
   } catch (err) {
@@ -19225,11 +19883,42 @@ function cleanupOne(cacheRoot, ourDir) {
   }
 }
 
-// src/tui-log-sink.ts
-var LOG_SERVICE_NAME = "opencode-claude-code";
+// src/plugin-notice.ts
+var NOTICE_RPC_ID = "opencode-claude-code-plugin";
+var NOTICE_EVENT = "notice";
+var NOTICE_EVENT_TYPE = `rpc.${NOTICE_RPC_ID}.${NOTICE_EVENT}`;
+var NOTICE_RPC_DEFINITION = {
+  id: NOTICE_RPC_ID,
+  methods: {},
+  events: {
+    [NOTICE_EVENT]: {
+      schema: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          level: { type: "string", enum: ["warn", "error"] },
+          message: { type: "string" }
+        },
+        required: ["id", "level", "message"],
+        additionalProperties: false
+      }
+    }
+  }
+};
 var TOAST_TITLE = "claude-code";
 var TOAST_DURATION_MS = 1e4;
 var MAX_TOAST_CHARS = 240;
+function toastMessage(message) {
+  const flat = message.replace(/\s+/g, " ").trim();
+  if (flat.length <= MAX_TOAST_CHARS) return flat;
+  return `${flat.slice(0, MAX_TOAST_CHARS - 1)}\u2026`;
+}
+function pluginNotice(id, level, message) {
+  return { id, level, message: toastMessage(message) };
+}
+
+// src/tui-log-sink.ts
+var LOG_SERVICE_NAME = "opencode-claude-code";
 var APP_LOG_LEVEL = {
   debug: "debug",
   info: "info",
@@ -19237,11 +19926,6 @@ var APP_LOG_LEVEL = {
   warn: "warn",
   error: "error"
 };
-function toastMessage(message) {
-  const flat = message.replace(/\s+/g, " ").trim();
-  if (flat.length <= MAX_TOAST_CHARS) return flat;
-  return `${flat.slice(0, MAX_TOAST_CHARS - 1)}\u2026`;
-}
 function appLogBody(entry) {
   return {
     service: LOG_SERVICE_NAME,
@@ -19291,6 +19975,9 @@ function registerOpencodeLogSink(client) {
   return true;
 }
 
+// src/v2.ts
+import { randomUUID as randomUUID8 } from "crypto";
+
 // src/v2-client.ts
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
@@ -19580,24 +20267,89 @@ function deletedSessionIdV2(event) {
   const id = event.data?.sessionID;
   return typeof id === "string" && id.length > 0 ? id : void 0;
 }
-async function releaseDeletedSessions(subscribe, signal) {
+function stoppedSessionIdV2(event) {
+  if (!event || event.type !== "session.execution.interrupted") return void 0;
+  if (event.data?.reason !== "user") return void 0;
+  const id = event.data?.sessionID;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+async function followSessionEvents(subscribe, signal) {
+  const closeFeed = openSessionRunEventFeed();
   try {
     for await (const event of subscribe({ signal })) {
       if (signal.aborted) break;
-      const sessionID = deletedSessionIdV2(event);
-      if (!sessionID) continue;
-      const released = deleteActiveProcessesForSession(sessionID);
-      if (released.length > 0) {
-        log.info("released claude state for deleted session", { sessionID, released });
+      noteSessionRunEvent(event);
+      const deleted = deletedSessionIdV2(event);
+      if (deleted) {
+        const released = deleteActiveProcessesForSession(deleted);
+        if (released.length > 0) {
+          log.info("released claude state for deleted session", { sessionID: deleted, released });
+        }
+        continue;
       }
+      const stopped = stoppedSessionIdV2(event);
+      if (stopped) releaseParkedProxyCallsForSession(stopped);
     }
   } catch (err) {
     if (!signal.aborted) {
-      log.warn("opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction", {
-        error: err instanceof Error ? err.message : String(err)
-      });
+      log.warn(
+        "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction, and stopped turns keep their proxy calls until the next message",
+        { error: err instanceof Error ? err.message : String(err) }
+      );
     }
+  } finally {
+    closeFeed();
+  }
+}
+var noticeEmitters = /* @__PURE__ */ new Set();
+var NOTICE_PROCESS_TAG = randomUUID8().slice(0, 8);
+var noticeCounter = 0;
+function emitNotice(entry) {
+  if (entry.level !== "warn" && entry.level !== "error") return;
+  noticeCounter += 1;
+  const notice = pluginNotice(`${NOTICE_PROCESS_TAG}-${noticeCounter}`, entry.level, entry.message);
+  for (const emit2 of noticeEmitters) emit2(notice);
+}
+async function registerNoticeChannel(ctx) {
+  const rpc = ctx.rpc;
+  if (typeof rpc?.register !== "function") return void 0;
+  let registration;
+  try {
+    registration = await rpc.register(NOTICE_RPC_DEFINITION, {});
+  } catch (err) {
+    log.debug("opencode 2 refused the notice channel; warnings stay in the plugin log", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
   }
+  const emitter2 = (notice) => {
+    try {
+      void Promise.resolve(registration.events.emit(NOTICE_EVENT, { ...notice })).catch(() => void 0);
+    } catch {
+    }
+  };
+  noticeEmitters.add(emitter2);
+  setToastNotifier(emitNotice);
+  return {
+    dispose: async () => {
+      noticeEmitters.delete(emitter2);
+      if (noticeEmitters.size === 0) setToastNotifier(null);
+      await registration.dispose();
+    }
+  };
+}
+function v2BtwClient(shim) {
+  const shimSession = shim.session;
+  const messages = shimSession?.messages;
+  const status = async () => ({ data: busySessionsFromEvents() ?? {} });
+  return {
+    session: {
+      ...typeof messages === "function" ? { messages: (options) => messages.call(shimSession, options) } : {},
+      get status() {
+        return busySessionsFromEvents() === void 0 ? void 0 : status;
+      }
+    }
+  };
 }
 function createV2Setup(deps) {
   return async (ctx) => {
@@ -19608,9 +20360,13 @@ function createV2Setup(deps) {
       return () => void 0;
     }
     ensureProcessExitCleanup();
-    setOpencodeClient(createV1ClientShim(ctx));
+    const shim = createV1ClientShim(ctx);
+    setOpencodeClient(shim);
     const directory = ctx.location?.directory;
     setOpencodeProjectDirectory(isUsableDirectory(directory) ? directory : void 0);
+    const registrations = [];
+    const noticeChannel = await registerNoticeChannel(ctx);
+    if (noticeChannel) registrations.push(noticeChannel);
     if (deps.buildAgentRegistry) {
       try {
         const config = deps.loadConfig(directory ?? process.cwd());
@@ -19630,7 +20386,6 @@ function createV2Setup(deps) {
       }
     }
     const planned = /* @__PURE__ */ new Map();
-    const registrations = [];
     registrations.push(
       await ctx.provider.transform((editor) => {
         const seed = editor.get(BASE_PROVIDER_ID);
@@ -19686,6 +20441,7 @@ function createV2Setup(deps) {
       })
     );
     const prompt = ctx.session.prompt;
+    const btwClient = v2BtwClient(shim);
     if (ctx.command?.transform && typeof prompt === "function") {
       const send = (input, command, delivery) => prompt.call(ctx.session, {
         ...input.prompt,
@@ -19703,7 +20459,15 @@ function createV2Setup(deps) {
           editor.add({
             name: "btw",
             description: BTW_COMMAND_DESCRIPTION,
-            execute: (input) => send(input, "btw", "queue")
+            execute: (input) => {
+              void askBtwThenRelease(
+                btwClient,
+                { command: "btw", sessionID: input.sessionID, arguments: input.prompt.text ?? "" },
+                () => send(input, "btw", "queue"),
+                deps.btwWaitOptions
+              );
+              return Promise.resolve();
+            }
           });
         })
       );
@@ -19724,7 +20488,7 @@ function createV2Setup(deps) {
     }
     const events = new AbortController();
     if (typeof ctx.event?.subscribe === "function") {
-      void releaseDeletedSessions(ctx.event.subscribe.bind(ctx.event), events.signal);
+      void followSessionEvents(ctx.event.subscribe.bind(ctx.event), events.signal);
     }
     log.info("claude-code plugin set up for opencode 2", {
       opencode: ctx.app?.version,