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

package/dist/tui.js

@@ -347,19 +347,39 @@ function createStatusWatch() {
 }
 function createFillMemory() {
   const held = /* @__PURE__ */ new Map();
+  const hold = (key, turn, fill) => {
+    const entry = held.get(key);
+    if (entry && entry.turn === turn) {
+      entry.fill = Math.max(entry.fill, fill);
+      return entry.fill;
+    }
+    if (!entry && held.size >= STATUS_WATCH_CAP) {
+      const oldest = held.keys().next().value;
+      if (oldest !== void 0) held.delete(oldest);
+    }
+    held.set(key, { turn, fill });
+    return fill;
+  };
   return {
-    hold(sessionID, turn, fill) {
-      const entry = held.get(sessionID);
-      if (entry && entry.turn === turn) {
-        entry.fill = Math.max(entry.fill, fill);
-        return entry.fill;
-      }
-      if (!entry && held.size >= STATUS_WATCH_CAP) {
-        const oldest = held.keys().next().value;
-        if (oldest !== void 0) held.delete(oldest);
-      }
-      held.set(sessionID, { turn, fill });
-      return fill;
+    hold,
+    /**
+     * The same hold for a whole estimate: its fill and both edges of its band,
+     * each at its highest this turn, so neither the lit cells nor the band's
+     * reach ever step back while the total rises. The total is not held: it
+     * is the text, and the text says what the model says now. Each edge at
+     * its highest stays on its side of the fill, because it is on that side
+     * at every moment (elapsed over a longer total, and over a shorter one).
+     */
+    holdEstimate(sessionID, turn, estimate) {
+      const fill = hold(sessionID, turn, estimate.fill);
+      if (!estimate.band) return { ...estimate, fill };
+      const sure = hold(`${sessionID}\0sure`, turn, estimate.band.sure);
+      const maybe = hold(`${sessionID}\0maybe`, turn, estimate.band.maybe);
+      return {
+        ...estimate,
+        fill,
+        band: { ...estimate.band, sure: Math.min(sure, fill), maybe: Math.max(maybe, fill) }
+      };
     }
   };
 }
@@ -372,6 +392,53 @@ function estimateCells(estimate, width = BAR_WIDTH) {
   if (estimate.over) return width;
   return Math.min(width - 1, Math.max(0, Math.round(estimate.fill * width)));
 }
+function estimateBandCells(estimate, width = BAR_WIDTH) {
+  const likely = estimateCells(estimate, width);
+  if (estimate.over || !estimate.band) return { sure: likely, likely, band: likely };
+  const sure = Math.min(likely, Math.max(0, Math.round(estimate.band.sure * width)));
+  const band = Math.max(likely, Math.min(width, Math.round(estimate.band.maybe * width)));
+  return { sure, likely, band };
+}
+var TURN_PROGRESS_SLACK_MS = 1e3;
+function liveOutput(record, startedAt) {
+  if (!record || startedAt === void 0) return void 0;
+  return record.turn >= startedAt - TURN_PROGRESS_SLACK_MS ? record.out : void 0;
+}
+function floorByChildren(estimate, elapsedMs, children) {
+  if (estimate.over) return estimate;
+  let median = 0;
+  let low = 0;
+  let high = 0;
+  for (const child of children) {
+    const own = child.estimate;
+    if (child.state !== "running" || !own || own.over) continue;
+    const left = (ms) => Math.max(0, ms - child.elapsedMs);
+    median = Math.max(median, left(own.totalMs));
+    low = Math.max(low, left(own.band?.lowMs ?? own.totalMs));
+    high = Math.max(high, left(own.band?.highMs ?? own.totalMs));
+  }
+  const elapsed = Math.max(0, elapsedMs);
+  const totalMs = Math.max(estimate.totalMs, elapsed + median);
+  const band = estimate.band;
+  if (totalMs === estimate.totalMs && (!band || band.lowMs >= elapsed + low && band.highMs >= elapsed + high)) {
+    return estimate;
+  }
+  const fill = totalMs > 0 ? elapsed / totalMs : 0;
+  if (!band) return { ...estimate, totalMs, fill };
+  const lowMs = Math.min(totalMs, Math.max(band.lowMs, elapsed + low));
+  const highMs = Math.max(totalMs, band.highMs, elapsed + high);
+  return {
+    ...estimate,
+    totalMs,
+    fill,
+    band: {
+      lowMs,
+      highMs,
+      sure: highMs > 0 ? elapsed / highMs : 0,
+      maybe: lowMs > 0 ? Math.min(1, elapsed / lowMs) : 0
+    }
+  };
+}
 function formatElapsed(ms) {
   const seconds = Math.max(0, Math.floor(ms / 1e3));
   if (seconds < 60) return `${seconds}s`;
@@ -388,13 +455,20 @@ function layoutProgressLine(view, lead, width = SIDEBAR_ROW_WIDTH, frame = 0) {
     { text: " ", role: "muted" }
   ];
   const estimate = !ended && !view.plan ? view.estimate : void 0;
-  const filled = ended ? BAR_WIDTH : view.plan ? filledCells(view.plan) : estimate ? estimateCells(estimate) : void 0;
-  const litRole = ended ? endedRole : estimate?.over ? "bar-over" : "bar-done";
   const bar = [];
-  if (filled !== void 0) {
-    for (let cell = 0; cell < BAR_WIDTH; cell += 1) {
-      bar.push(cell < filled ? { text: BAR_DONE, role: litRole } : { text: BAR_TODO, role: "bar-track" });
-    }
+  const cellsOf = (segment) => {
+    for (let cell = 0; cell < BAR_WIDTH; cell += 1) bar.push(segment(cell));
+  };
+  if (ended) {
+    cellsOf(() => ({ text: BAR_DONE, role: endedRole }));
+  } else if (view.plan) {
+    const filled = filledCells(view.plan);
+    cellsOf((cell) => cell < filled ? { text: BAR_DONE, role: "bar-done" } : { text: BAR_TODO, role: "bar-track" });
+  } else if (estimate) {
+    const cells3 = estimateBandCells(estimate);
+    cellsOf(
+      (cell) => estimate.over ? { text: BAR_DONE, role: "bar-over" } : cell < cells3.sure ? { text: BAR_DONE, role: "bar-done" } : cell < cells3.likely ? { text: BAR_DONE, role: "bar-likely" } : cell < cells3.band ? { text: BAR_TODO, role: "bar-band" } : { text: BAR_TODO, role: "bar-track" }
+    );
   }
   const required = [];
   if (view.plan) {
@@ -489,25 +563,86 @@ function createSpawnRecordReader(file = spawnRecordStorePath) {
 }
 
 // src/turn-history.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+
+// src/turn-progress-store.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-var MAX_TURN_SAMPLES = 48;
-var TURN_SAMPLE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-var MIN_TURN_SAMPLES = 3;
-var CHARS_BANDWIDTH = Math.log(4);
-var OTHER_EFFORT_WEIGHT = 0.5;
-var MIN_EFFORT_RATIO_SAMPLES = 2;
-var CHARS_FLOOR = 50;
+var MAX_TURN_PROGRESS = 64;
+var TURN_PROGRESS_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var TAG = /^[0-9a-f]{8}$/;
 var pathOverride2 = null;
-function turnHistoryStorePath() {
+function turnProgressStorePath() {
   if (pathOverride2) return pathOverride2;
   const stateRoot = process.env.XDG_STATE_HOME || join2(homedir2(), ".local", "state");
-  return join2(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
+  return join2(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 readEntries2(file, now) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync2(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 createTurnProgressReader(file = turnProgressStorePath) {
+  let identity = "";
+  let cached = /* @__PURE__ */ new Map();
+  return {
+    read(now = Date.now()) {
+      const path = file();
+      let next = "";
+      try {
+        const stats = statSync2(path);
+        next = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
+      } catch {
+        next = "missing";
+      }
+      if (next !== identity) {
+        identity = next;
+        cached = next === "missing" ? /* @__PURE__ */ new Map() : readEntries2(path, now);
+      }
+      return cached;
+    }
+  };
+}
+
+// src/turn-history.ts
+var MAX_TURN_SAMPLES = 48;
+var TURN_SAMPLE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var SESSION_TAG = /^[0-9a-f]{8}$/;
+var pathOverride3 = null;
+function turnHistoryStorePath() {
+  if (pathOverride3) return pathOverride3;
+  const stateRoot = process.env.XDG_STATE_HOME || join3(homedir3(), ".local", "state");
+  return join3(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,
@@ -535,6 +670,13 @@ function isSample(value) {
   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) {
@@ -543,13 +685,16 @@ function cleanSample(sample) {
     ...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) {
+function readEntries3(file, now) {
   const out = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    const parsed = JSON.parse(readFileSync3(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;
@@ -570,28 +715,62 @@ function createTurnHistoryReader(file = turnHistoryStorePath) {
       const path = file();
       let next = "";
       try {
-        const stats = statSync2(path);
+        const stats = statSync3(path);
         next = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
       } catch {
         next = "missing";
       }
       if (next !== identity) {
         identity = next;
-        cached = next === "missing" ? /* @__PURE__ */ new Map() : readEntries2(path, now);
+        cached = next === "missing" ? /* @__PURE__ */ new Map() : readEntries3(path, now);
       }
       return cached;
     }
   };
 }
-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];
+
+// 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;
   }
-  return values[order[order.length - 1]];
+  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;
@@ -601,7 +780,21 @@ function charsWeight(a, b) {
 function effortWeight(a, b) {
   return a === void 0 || b === void 0 || a === b ? 1 : OTHER_EFFORT_WEIGHT;
 }
-function effortScales(samples, charsWeights, effort) {
+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();
@@ -615,7 +808,7 @@ function effortScales(samples, charsWeights, effort) {
   if (!own || own.length < MIN_EFFORT_RATIO_SAMPLES) return scales;
   const medianOf = (indices) => weightedMedian(
     indices.map((index) => samples[index].ms),
-    indices.map((index) => charsWeights[index])
+    indices.map((index) => weights[index])
   );
   const ownMedian = medianOf(own);
   for (const [other, indices] of groups) {
@@ -625,39 +818,260 @@ function effortScales(samples, charsWeights, effort) {
   }
   return scales;
 }
-function estimateTurn(samples, input) {
-  const usable = samples.filter((sample) => Number.isFinite(sample.ms) && sample.ms >= 0);
-  if (usable.length < MIN_TURN_SAMPLES) return void 0;
-  const elapsed = Math.max(0, input.elapsedMs);
-  const charsWeights = usable.map((sample) => charsWeight(input.chars, sample.chars));
-  const scales = effortScales(usable, charsWeights, input.effort);
-  const scaled = usable.map((sample, index) => ({
-    ms: sample.ms * (sample.effort !== void 0 ? scales.get(sample.effort) ?? 1 : 1),
-    calls: sample.calls,
-    weight: charsWeights[index] * effortWeight(input.effort, sample.effort)
-  }));
-  const survivors = scaled.filter(
-    (sample) => sample.ms > elapsed && (sample.calls === void 0 || input.calls === void 0 || sample.calls >= input.calls)
-  );
-  if (survivors.length === 0) {
-    const usual = weightedMedian(
-      scaled.map((sample) => sample.ms),
-      scaled.map((sample) => sample.weight)
+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)
     );
-    return { totalMs: usual, fill: 1, over: true };
+    if (kept.length < own.length && kept.length >= MIN_CONDITIONED_SAMPLES) {
+      fit = shrink(moments(kept), usual, CONDITIONED_KAPPA) ?? usual;
+    }
   }
-  const residual = weightedMedian(
-    survivors.map((sample) => sample.ms - elapsed),
-    survivors.map((sample) => sample.weight)
-  );
-  const totalMs = elapsed + residual;
-  return { totalMs, fill: totalMs > 0 ? elapsed / totalMs : 0, over: false };
+  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/account-usage.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync4, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 var UNTIMED_READING_TTL_MS = 5 * 60 * 60 * 1e3;
 var USAGE_READING_MAX_AGE_MS = 8 * 24 * 60 * 60 * 1e3;
 var MAX_USAGE_ACCOUNTS = 32;
@@ -665,11 +1079,11 @@ var NAME = /^[a-z0-9_-]{1,64}$/;
 var STATUS = /^[a-z_]{1,32}$/;
 var TIER = /^[A-Za-z0-9][A-Za-z0-9 ]{0,23}$/;
 var MAX_RESETS_TEXT = 80;
-var pathOverride3 = null;
+var pathOverride4 = null;
 function accountUsageStorePath() {
-  if (pathOverride3) return pathOverride3;
-  const stateRoot = process.env.XDG_STATE_HOME || join3(homedir3(), ".local", "state");
-  return join3(stateRoot, "opencode-claude-code-plugin", "account-usage.json");
+  if (pathOverride4) return pathOverride4;
+  const stateRoot = process.env.XDG_STATE_HOME || join4(homedir4(), ".local", "state");
+  return join4(stateRoot, "opencode-claude-code-plugin", "account-usage.json");
 }
 function finite(value) {
   return typeof value === "number" && Number.isFinite(value);
@@ -714,7 +1128,7 @@ function readKnown(parsed) {
 function parseStore(file, now) {
   const out = emptyStore();
   try {
-    const parsed = JSON.parse(readFileSync3(file, "utf8"));
+    const parsed = JSON.parse(readFileSync4(file, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return out;
     out.known = readKnown(parsed);
     const accounts = parsed.accounts;
@@ -748,7 +1162,7 @@ function createAccountUsageReader(file = accountUsageStorePath) {
     const path = file();
     let next = "";
     try {
-      const stats = statSync3(path);
+      const stats = statSync4(path);
       next = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
     } catch {
       next = "missing";
@@ -911,6 +1325,65 @@ function accountUsageLines(usage, now, width = SIDEBAR_ROW_WIDTH, known = /* @__
   });
 }
 
+// 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 readPluginNotice(type, data) {
+  if (type !== NOTICE_EVENT_TYPE) return void 0;
+  if (!data || typeof data !== "object") return void 0;
+  const { id, level, message } = data;
+  if (typeof id !== "string" || id.length === 0) return void 0;
+  if (level !== "warn" && level !== "error") return void 0;
+  if (typeof message !== "string" || message.trim().length === 0) return void 0;
+  return { id, level, message: toastMessage(message) };
+}
+var MAX_SEEN_NOTICES = 256;
+function createNoticeToaster(show) {
+  const seen = /* @__PURE__ */ new Set();
+  return (type, data) => {
+    const notice = readPluginNotice(type, data);
+    if (!notice || seen.has(notice.id)) return false;
+    seen.add(notice.id);
+    if (seen.size > MAX_SEEN_NOTICES) {
+      const oldest = seen.values().next().value;
+      if (oldest !== void 0) seen.delete(oldest);
+    }
+    try {
+      show(notice);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+
 // src/tui.ts
 var SUBAGENTS_TUI_PLUGIN_ID = "opencode-claude-code-plugin.subagents";
 var SECTION_ORDER = 900;
@@ -930,6 +1403,8 @@ var ROLE_COLOR = {
   effort: "effort",
   "effort-faded": "effortFaded",
   "bar-done": "barDone",
+  "bar-likely": "barLikely",
+  "bar-band": "barBand",
   // Past every recorded turn: the warning colour, which the effort already takes.
   "bar-over": "effort",
   "bar-track": "barTrack",
@@ -971,6 +1446,9 @@ function createSidebar(host) {
   let recordMap = attempt(() => records.read(), /* @__PURE__ */ new Map());
   const history = createTurnHistoryReader();
   let historyMap = attempt(() => history.read(), /* @__PURE__ */ new Map());
+  let turnModel = attempt(() => buildTurnModel(historyMap), void 0);
+  const liveProgress = createTurnProgressReader();
+  let progressMap = attempt(() => liveProgress.read(), /* @__PURE__ */ new Map());
   const [recordVersion, setRecordVersion] = createSignal(0);
   const watch = createStatusWatch();
   const fills = createFillMemory();
@@ -989,10 +1467,12 @@ function createSidebar(host) {
       const next = attempt(() => records.read(), recordMap);
       const nextHistory = attempt(() => history.read(), historyMap);
       if (next !== recordMap || nextHistory !== historyMap) {
+        if (nextHistory !== historyMap) turnModel = attempt(() => buildTurnModel(nextHistory), turnModel);
         recordMap = next;
         historyMap = nextHistory;
         setRecordVersion((value) => value + 1);
       }
+      progressMap = attempt(() => liveProgress.read(), progressMap);
       setNow(Date.now());
     }
     setUsage(attempt(() => usageReader.read(), usage()));
@@ -1020,21 +1500,23 @@ function createSidebar(host) {
     }
   };
   const progressOf = (sessionID) => attempt(() => host.progress(sessionID), EMPTY_SOURCE);
-  const estimateFor = (sessionID, measure, view, agentFallback) => {
-    if (view.state !== "running") return view;
+  const estimateFor = (sessionID, measure, view, agentFallback, children = []) => {
+    if (view.state !== "running" || !turnModel) return view;
     const record = recordMap.get(sessionID);
     if (!record?.model) return view;
-    const samples = historyMap.get(turnHistoryKey(record.agent ?? agentFallback, record.model));
-    if (!samples) return view;
-    const estimate = estimateTurn(samples, {
+    const tag = sessionTag(sessionID);
+    const estimate = turnModel.estimate(turnHistoryKey(record.agent ?? agentFallback, record.model), {
       elapsedMs: view.elapsedMs,
       chars: measure.chars,
       effort: record.effort,
-      calls: measure.calls
+      calls: measure.calls,
+      out: liveOutput(tag ? progressMap.get(tag) : void 0, measure.startedAt),
+      session: tag,
+      now: Date.now()
     });
     if (!estimate) return view;
     const turn = measure.startedAt ?? 0;
-    return { ...view, estimate: { ...estimate, fill: fills.hold(sessionID, turn, estimate.fill) } };
+    return { ...view, estimate: fills.holdEstimate(sessionID, turn, floorByChildren(estimate, view.elapsedMs, children)) };
   };
   const deriveView = (sessionID) => {
     recordVersion();
@@ -1047,11 +1529,13 @@ function createSidebar(host) {
       now: clock
     });
     const lines = /* @__PURE__ */ new Map();
+    const waitedOn = [];
     for (const row of rows) {
       if (row.state !== "running" || !row.sessionID) continue;
       const measure2 = measureProgress(progressOf(row.sessionID));
-      const line = rowProgress(measure2, { started: row.started, now: clock });
-      lines.set(row.sessionID, estimateFor(row.sessionID, measure2, line, row.agent));
+      const line = estimateFor(row.sessionID, measure2, rowProgress(measure2, { started: row.started, now: clock }), row.agent);
+      lines.set(row.sessionID, line);
+      if (!row.background) waitedOn.push(line);
     }
     const status = gathered.status(sessionID);
     const memory = watch.observe(sessionID, status, clock);
@@ -1062,7 +1546,7 @@ function createSidebar(host) {
       stoppedAt: gathered.stoppedAt(sessionID) ?? memory.stoppedAt,
       now: clock
     });
-    const progress = session ? estimateFor(sessionID, measure, session) : void 0;
+    const progress = session ? estimateFor(sessionID, measure, session, void 0, waitedOn) : void 0;
     return { rows, lines, progress };
   };
   const styled = (segment) => {
@@ -1319,6 +1803,8 @@ function registerV1(api) {
         effortFaded: mix(theme.warning ?? muted, muted, 0.45),
         hover: theme.backgroundElement,
         barDone: theme.success ?? theme.accent,
+        barLikely: mix(theme.success ?? theme.accent, muted, 0.45),
+        barBand: mix(muted, theme.success ?? theme.accent, 0.3),
         barTrack: mix(muted, theme.backgroundPanel ?? theme.backgroundElement, 0.5),
         fraction: theme.text,
         tool: theme.info ?? theme.accent,
@@ -1438,6 +1924,8 @@ function setupV2(context) {
         effortFaded: mix(theme.text.feedback.warning?.base ?? muted, muted, 0.45),
         hover: theme.background.raised.base,
         barDone: theme.text.feedback.success.base ?? accent,
+        barLikely: mix(theme.text.feedback.success.base ?? accent, muted, 0.45),
+        barBand: mix(muted, theme.text.feedback.success.base ?? accent, 0.3),
         barTrack: mix(muted, theme.background.base ?? theme.background.raised.base, 0.5),
         fraction: theme.text.base,
         tool: theme.text.feedback.info?.base ?? accent,
@@ -1525,8 +2013,21 @@ function setupV2(context) {
     }),
     void 0
   );
+  const toastNotice = createNoticeToaster(
+    (notice) => context.ui.toast?.show({
+      title: TOAST_TITLE,
+      message: notice.message,
+      variant: notice.level === "error" ? "error" : "warning",
+      duration: TOAST_DURATION_MS
+    })
+  );
+  const stopNotices = attempt(
+    () => context.data.listen?.((event) => void toastNotice(event?.details?.type, event?.details?.data)),
+    void 0
+  );
   return () => {
     if (release) attempt(release, void 0);
+    if (stopNotices) attempt(stopNotices, void 0);
     sidebar.dispose();
   };
 }