@khalilgharbaoui/opencode-claude-code-plugin 0.57.1 → 0.58.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";
@@ -9635,6 +9635,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 +10815,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 +10937,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 +11153,7 @@ async function gatherDoctorReport(options) {
     hookFailures: snapshotHookFailures(),
     planUsage,
     accountUsage: snapshotAccountUsage(),
+    turnEstimate: assessTurnEstimate(),
     backgroundSubagents: {
       gate: snapshotBackgroundSubagentGate(),
       ledgers: snapshotBackgroundTasks(),
@@ -11629,9 +12286,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 +13470,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 +13952,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 +13972,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 +14008,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,133 +14028,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";
-}
-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;
-  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 } : {},
-    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";
@@ -13559,13 +14089,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;
@@ -13574,7 +14104,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;
@@ -13685,7 +14215,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;
     }
@@ -13726,8 +14256,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);
@@ -13743,9 +14273,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) });
@@ -14675,6 +15205,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,
@@ -15744,6 +16275,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;
       }
@@ -16023,6 +16558,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,
@@ -17150,8 +17686,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;
@@ -17442,7 +17984,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,
@@ -18513,6 +19055,21 @@ var ClaudeCodeLanguageModel = class {
                   ms: endedAt - start.at,
                   chars: start.chars,
                   effort: reasoningEffort,
+                  // 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, 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
                 });
               }
@@ -18967,7 +19524,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",
@@ -19010,7 +19567,7 @@ function readTierFromConfigDir(configDir, allowLegacyFallback) {
 function readOauthAccount(file) {
   let raw;
   try {
-    raw = readFileSync12(file, "utf8");
+    raw = readFileSync13(file, "utf8");
   } catch {
     return void 0;
   }
@@ -19047,14 +19604,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";
@@ -19062,20 +19619,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(
@@ -19096,19 +19653,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;
@@ -19117,8 +19674,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"
@@ -19153,7 +19710,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 {
@@ -19161,11 +19718,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;
   }
@@ -19181,13 +19738,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) {