@khalilgharbaoui/opencode-claude-code-plugin 0.55.0 → 0.57.0

package/dist/tui.js

@@ -8,13 +8,14 @@ var FINISHED_TTL_MS = 10 * 6e4;
 var FINISHED_KEEP = 3;
 var STARTING_GRACE_MS = 1e4;
 var SIDEBAR_ROW_WIDTH = 36;
+var ROW_INDENT = " ";
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var TITLE_SUFFIX = /\s*\(@([^)\s]+) subagent\)\s*$/;
 function parseChildTitle(title) {
-  const text2 = (title ?? "").trim();
-  const match = TITLE_SUFFIX.exec(text2);
-  if (!match) return { description: text2 };
-  return { description: text2.slice(0, match.index).trim(), agent: match[1] };
+  const text3 = (title ?? "").trim();
+  const match = TITLE_SUFFIX.exec(text3);
+  if (!match) return { description: text3 };
+  return { description: text3.slice(0, match.index).trim(), agent: match[1] };
 }
 function text(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
@@ -81,6 +82,12 @@ function subagentLabel(record, part) {
   const account = record?.model ? text(record.account) : accountFromProvider(askedProvider);
   return [model, effort, account].filter(Boolean).join(" \xB7 ");
 }
+function formatCost(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+  if (value < 5e-3) return "<$0.01";
+  const digits = [2, 1, 0].map((places) => value.toFixed(places)).find((text3) => text3.length <= 4);
+  return `$${digits ?? value.toFixed(0)}`;
+}
 function truncate(value, width) {
   const chars = Array.from(value.replace(/\s+/g, " ").trim());
   if (width <= 0) return "";
@@ -157,6 +164,7 @@ function rowFor(input, child, parsed, part, completion) {
   if (state !== "running" && finished === void 0) {
     finished = input.stoppedAt(child.id) ?? child.updated ?? started;
   }
+  const cost = input.cost?.(child.id);
   return {
     sessionID: child.id,
     agent: parsed.agent ?? (part ? partAgent(part) : void 0) ?? text(child.agent) ?? "subagent",
@@ -165,6 +173,7 @@ function rowFor(input, child, parsed, part, completion) {
     state,
     label: subagentLabel(input.record(child.id), part),
     effort: text(input.record(child.id)?.effort),
+    ...cost !== void 0 ? { cost } : {},
     started,
     finished
   };
@@ -193,15 +202,29 @@ function layoutRow(row, width = SIDEBAR_ROW_WIDTH, frame = 0) {
     first.push({ text: marker, role: "muted" });
   }
   const second = [];
-  if (row.label) {
-    const pieces = truncate(row.label, width - 2).split(" \xB7 ");
+  const content = width - ROW_INDENT.length;
+  const pieces = row.label ? truncate(row.label, content).split(" \xB7 ") : [];
+  const labelWidth = pieces.reduce((sum, piece) => sum + Array.from(piece).length, 0) + 3 * Math.max(0, pieces.length - 1);
+  const cost = formatCost(row.cost);
+  const costWidth = cost ? Array.from(cost).length : 0;
+  let joiner;
+  if (cost) {
+    if (pieces.length === 0) joiner = costWidth <= content ? "" : void 0;
+    else if (labelWidth + 3 + costWidth <= content) joiner = " \xB7 ";
+    else if (labelWidth + 1 + costWidth <= content) joiner = " ";
+  }
+  if (pieces.length > 0 || joiner !== void 0) {
     const effortAt = row.effort ? pieces.indexOf(row.effort) : -1;
-    second.push({ text: "  ", role: "muted" });
+    second.push({ text: ROW_INDENT, role: "muted" });
     pieces.forEach((piece, index) => {
       if (index > 0) second.push({ text: " \xB7 ", role: "muted" });
       const role = index !== effortAt ? "muted" : finished ? "effort-faded" : "effort";
       second.push({ text: piece, role });
     });
+    if (cost && joiner !== void 0) {
+      if (joiner) second.push({ text: joiner, role: "muted" });
+      second.push({ text: cost, role: "cost" });
+    }
   }
   return { first, second };
 }
@@ -210,6 +233,199 @@ function collapsedSummary(rows) {
   return running > 0 ? `${running} running` : `${rows.length} done`;
 }
 
+// src/progress-line.ts
+var BAR_WIDTH = 10;
+var PROGRESS_LINGER_MS = 15e3;
+var BAR_DONE = "\u25B0";
+var BAR_TODO = "\u25B1";
+function text2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function cells(value) {
+  return Array.from(value).length;
+}
+function turnMessages(messages, isUser) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (isUser(messages[index])) return index === 0 ? messages : messages.slice(index);
+  }
+  return messages;
+}
+function measureProgress(source) {
+  const messages = source.messages;
+  let turnStart = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index].role === "user") {
+      turnStart = index;
+      break;
+    }
+  }
+  let calls = 0;
+  let tool;
+  let failed = false;
+  for (let index = turnStart + 1; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message.role !== "assistant") continue;
+    failed = message.error === true;
+    for (const call of message.tools) {
+      calls += 1;
+      const running = call.status === "running" || call.status === "pending";
+      tool = running ? text2(call.name) : void 0;
+    }
+  }
+  let total = 0;
+  let done = 0;
+  for (const todo of source.todos) {
+    if (todo.status === "cancelled") continue;
+    total += 1;
+    if (todo.status === "completed") done += 1;
+  }
+  return {
+    plan: total > 0 ? { done, total } : void 0,
+    startedAt: turnStart >= 0 ? messages[turnStart].created : void 0,
+    chars: turnStart >= 0 ? messages[turnStart].chars : void 0,
+    calls,
+    tool,
+    failed
+  };
+}
+function sessionProgress(measure, input) {
+  const startedAt = measure.startedAt ?? input.busySince;
+  if (input.status === "busy") {
+    return {
+      state: "running",
+      plan: measure.plan,
+      elapsedMs: Math.max(0, input.now - (startedAt ?? input.now)),
+      calls: measure.calls,
+      tool: measure.tool
+    };
+  }
+  if (input.stoppedAt === void 0) return void 0;
+  if (startedAt !== void 0 && input.stoppedAt < startedAt) return void 0;
+  if (input.now - input.stoppedAt > PROGRESS_LINGER_MS) return void 0;
+  return {
+    state: measure.failed ? "error" : "done",
+    plan: measure.plan,
+    elapsedMs: Math.max(0, input.stoppedAt - (startedAt ?? input.stoppedAt)),
+    calls: measure.calls,
+    tool: void 0
+  };
+}
+function rowProgress(measure, input) {
+  const startedAt = measure.startedAt ?? input.started;
+  return {
+    state: "running",
+    plan: measure.plan,
+    elapsedMs: Math.max(0, input.now - startedAt),
+    calls: measure.calls,
+    tool: measure.tool
+  };
+}
+var STATUS_WATCH_CAP = 256;
+function createStatusWatch() {
+  const seen = /* @__PURE__ */ new Map();
+  return {
+    observe(sessionID, status, now) {
+      let entry = seen.get(sessionID);
+      if (!entry) {
+        entry = { status: "unknown" };
+        if (seen.size >= STATUS_WATCH_CAP) {
+          const oldest = seen.keys().next().value;
+          if (oldest !== void 0) seen.delete(oldest);
+        }
+        seen.set(sessionID, entry);
+      }
+      if (status === "busy" && entry.status !== "busy") {
+        entry.busySince = now;
+        entry.stoppedAt = void 0;
+      } else if (status === "idle" && entry.status === "busy") {
+        entry.stoppedAt = now;
+      }
+      if (status !== "unknown") entry.status = status;
+      return { busySince: entry.busySince, stoppedAt: entry.stoppedAt };
+    }
+  };
+}
+function createFillMemory() {
+  const held = /* @__PURE__ */ new Map();
+  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;
+    }
+  };
+}
+function filledCells(plan, width = BAR_WIDTH) {
+  if (plan.total <= 0 || plan.done <= 0) return 0;
+  if (plan.done >= plan.total) return width;
+  return Math.min(width - 1, Math.max(1, Math.round(plan.done / plan.total * width)));
+}
+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 formatElapsed(ms) {
+  const seconds = Math.max(0, Math.floor(ms / 1e3));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const pad2 = (value) => String(value).padStart(2, "0");
+  if (minutes < 60) return `${minutes}m${pad2(seconds % 60)}s`;
+  return `${Math.floor(minutes / 60)}h${pad2(minutes % 60)}m`;
+}
+function layoutProgressLine(view, lead, width = SIDEBAR_ROW_WIDTH, frame = 0) {
+  const ended = view.state !== "running";
+  const endedRole = view.state === "error" ? "error" : "done";
+  const leadSegments = lead === "indent" ? [{ text: ROW_INDENT, role: "muted" }] : [
+    view.state === "running" ? { text: SPINNER_FRAMES[frame % SPINNER_FRAMES.length], role: "spinner" } : { text: view.state === "done" ? "\u2713" : "\u2717", role: endedRole },
+    { 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 required = [];
+  if (view.plan) {
+    required.push({ text: `${view.plan.done}/${view.plan.total}`, role: ended ? "muted" : "fraction" });
+    required.push({ text: formatElapsed(view.elapsedMs), role: "muted" });
+  } else if (estimate) {
+    required.push({
+      text: `${formatElapsed(view.elapsedMs)}/~${formatElapsed(estimate.totalMs)}`,
+      role: estimate.over ? "estimate-over" : "estimate"
+    });
+  } else {
+    required.push({ text: formatElapsed(view.elapsedMs), role: "muted" });
+  }
+  const calls = !view.plan && !estimate && view.calls > 0 ? { text: `${view.calls} call${view.calls === 1 ? "" : "s"}`, role: "muted" } : void 0;
+  const tool = !ended && view.tool ? { text: view.tool, role: "tool" } : void 0;
+  const budget = width - leadSegments.reduce((sum, segment) => sum + cells(segment.text), 0) - (bar.length > 0 ? BAR_WIDTH + 2 : 0);
+  const widthOf = (pieces2) => pieces2.reduce((sum, piece) => sum + cells(piece.text), 0) + 3 * Math.max(0, pieces2.length - 1);
+  let pieces = [...required, ...calls ? [calls] : [], ...tool ? [tool] : []];
+  if (widthOf(pieces) > budget && calls) pieces = [...required, ...tool ? [tool] : []];
+  if (widthOf(pieces) > budget && tool) {
+    const room = budget - widthOf(required) - 3;
+    pieces = room >= 2 ? [...required, { text: truncate(tool.text, room), role: "tool" }] : required;
+  }
+  const tail = bar.length > 0 ? [{ text: "  ", role: "muted" }] : [];
+  pieces.forEach((piece, index) => {
+    if (index > 0) tail.push({ text: " \xB7 ", role: "muted" });
+    tail.push(piece);
+  });
+  return { lead: leadSegments, bar, tail };
+}
+
 // src/spawn-record-store.ts
 import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
 import { homedir } from "os";
@@ -226,7 +442,7 @@ function isRecord(value) {
   if (!record || typeof record !== "object" || Array.isArray(record)) return false;
   if (typeof record.at !== "number" || !Number.isFinite(record.at)) return false;
   const ok = (field) => field === void 0 || typeof field === "string";
-  if (!ok(record.model) || !ok(record.effort) || !ok(record.account)) return false;
+  if (!ok(record.model) || !ok(record.effort) || !ok(record.account) || !ok(record.agent)) return false;
   return !!record.model;
 }
 function readEntries(file) {
@@ -242,6 +458,7 @@ function readEntries(file) {
         model: record.model,
         ...record.effort ? { effort: record.effort } : {},
         ...record.account ? { account: record.account } : {},
+        ...record.agent ? { agent: record.agent } : {},
         at: record.at
       });
     }
@@ -271,12 +488,420 @@ function createSpawnRecordReader(file = spawnRecordStorePath) {
   };
 }
 
+// src/turn-history.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 CHARS_FLOOR = 50;
+var pathOverride2 = null;
+function turnHistoryStorePath() {
+  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");
+}
+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 text3 of texts) {
+    let stripped = text3;
+    for (const block of INJECTED_BLOCKS) stripped = stripped.replace(block, "");
+    total += stripped.trim().length;
+  }
+  return total;
+}
+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(readFileSync2(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 createTurnHistoryReader(file = turnHistoryStorePath) {
+  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;
+    }
+  };
+}
+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 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 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 weights = usable.map(
+    (sample) => charsWeight(input.chars, sample.chars) * effortWeight(input.effort, sample.effort)
+  );
+  const survivors = usable.map((sample, index) => ({ ms: sample.ms, weight: weights[index] })).filter((sample) => sample.ms > elapsed);
+  if (survivors.length === 0) {
+    const usual = weightedMedian(usable.map((sample) => sample.ms), weights);
+    return { totalMs: usual, fill: 1, over: true };
+  }
+  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 };
+}
+
+// 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";
+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;
+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;
+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");
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function validEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const entry = value;
+  if (!finite(entry.observedAt)) return null;
+  if (typeof entry.status !== "string" || !STATUS.test(entry.status)) return null;
+  if (entry.utilization !== null && !finite(entry.utilization)) return null;
+  if (entry.resetsAt !== void 0 && !finite(entry.resetsAt)) return null;
+  if (entry.resetsText !== void 0 && (typeof entry.resetsText !== "string" || entry.resetsText.length > MAX_RESETS_TEXT)) {
+    return null;
+  }
+  const noted = Array.isArray(entry.noted) ? [...new Set(entry.noted.filter((t) => finite(t) && t > 0 && t <= 100))].sort(
+    (a, b) => a - b
+  ) : [];
+  return {
+    utilization: entry.utilization,
+    ...entry.resetsAt === void 0 ? {} : { resetsAt: entry.resetsAt },
+    ...entry.resetsText === void 0 ? {} : { resetsText: entry.resetsText },
+    status: entry.status,
+    observedAt: entry.observedAt,
+    noted
+  };
+}
+var emptyStore = () => ({ usage: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map() });
+function readKnown(parsed) {
+  const out = /* @__PURE__ */ new Map();
+  const known = parsed.known;
+  if (!known || typeof known !== "object" || Array.isArray(known)) return out;
+  for (const [account, raw] of Object.entries(known)) {
+    if (out.size >= MAX_USAGE_ACCOUNTS) break;
+    if (!NAME.test(account) || !raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const record = raw;
+    if (!finite(record.at)) continue;
+    const tier = typeof record.tier === "string" && TIER.test(record.tier) ? record.tier : void 0;
+    out.set(account, { ...tier ? { tier } : {}, at: record.at });
+  }
+  return out;
+}
+function parseStore(file, now) {
+  const out = emptyStore();
+  try {
+    const parsed = JSON.parse(readFileSync3(file, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return out;
+    out.known = readKnown(parsed);
+    const accounts = parsed.accounts;
+    if (!accounts || typeof accounts !== "object" || Array.isArray(accounts)) return out;
+    const cutoff = now - USAGE_READING_MAX_AGE_MS;
+    for (const [account, windows] of Object.entries(accounts)) {
+      if (!NAME.test(account) || !windows || typeof windows !== "object") continue;
+      const kept = /* @__PURE__ */ new Map();
+      for (const [window, raw] of Object.entries(windows)) {
+        if (!NAME.test(window)) continue;
+        const entry = validEntry(raw);
+        if (entry && entry.observedAt >= cutoff) kept.set(window, entry);
+      }
+      if (kept.size > 0) out.usage.set(account, kept);
+    }
+  } catch {
+  }
+  return out;
+}
+function isReadingCurrent(entry, now = Date.now()) {
+  if (entry.resetsAt !== void 0) return entry.resetsAt > now;
+  return now - entry.observedAt < UNTIMED_READING_TTL_MS;
+}
+function usagePercent(utilization) {
+  return Math.round(utilization * 1e3) / 10;
+}
+function createAccountUsageReader(file = accountUsageStorePath) {
+  let identity = "";
+  let store = emptyStore();
+  const refresh = () => {
+    const path = file();
+    let next = "";
+    try {
+      const stats = statSync3(path);
+      next = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
+    } catch {
+      next = "missing";
+    }
+    if (next !== identity) {
+      identity = next;
+      store = next === "missing" ? emptyStore() : parseStore(path, Date.now());
+    }
+  };
+  return {
+    read() {
+      refresh();
+      return store.usage;
+    },
+    /** The accounts registered at startup, with their tiers: the same map while the file is unchanged. */
+    known() {
+      refresh();
+      return store.known;
+    }
+  };
+}
+
+// src/account-sidebar.ts
+var WARNING_PERCENT = 75;
+var NO_READING_TEXT = "no reading yet";
+var RESET_WORD = "resets ";
+var SEPARATOR = " \xB7 ";
+var SHORT_WINDOWS = {
+  five_hour: "5h",
+  seven_day: "7d",
+  seven_day_opus: "7d opus",
+  seven_day_sonnet: "7d sonnet",
+  seven_day_overage_included: "7d extra",
+  overage: "extra"
+};
+function shortWindowName(window) {
+  if (window === "unknown") return "";
+  return SHORT_WINDOWS[window] ?? window.replace(/_/g, " ");
+}
+var pad = (value) => String(value).padStart(2, "0");
+function sameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function formatResetClock(resetsAt, now, year = true) {
+  const when = new Date(resetsAt);
+  const clock = `${pad(when.getHours())}:${pad(when.getMinutes())}`;
+  if (sameDay(when, new Date(now))) return clock;
+  const date = `${pad(when.getMonth() + 1)}-${pad(when.getDate())} ${clock}`;
+  return year ? `${when.getFullYear()}-${date}` : date;
+}
+function resetSpellings(entry, now) {
+  if (entry.resetsAt !== void 0) {
+    const full = formatResetClock(entry.resetsAt, now);
+    if (sameDay(new Date(entry.resetsAt), new Date(now))) return [`${RESET_WORD}${full}`];
+    return [`${RESET_WORD}${full}`, full, formatResetClock(entry.resetsAt, now, false)];
+  }
+  if (entry.resetsText) return [`${RESET_WORD}${entry.resetsText}`, entry.resetsText];
+  return [];
+}
+function rank(entry) {
+  if (entry.status === "rejected") return 1e3;
+  if (entry.utilization === null) return -1;
+  return usagePercent(entry.utilization);
+}
+function pressingWindow(windows, now) {
+  let best;
+  for (const [window, entry] of windows) {
+    if (!isReadingCurrent(entry, now)) continue;
+    if (!best || rank(entry) > rank(best[1])) best = [window, entry];
+  }
+  return best;
+}
+var cells2 = (value) => Array.from(value).length;
+var segmentsCells = (segments) => segments.reduce((sum, segment) => sum + cells2(segment.text), 0);
+function levelRole(state) {
+  return state === "limited" ? "error" : state === "warning" ? "effort" : "muted";
+}
+function fitSegments(segments, budget) {
+  const out = [];
+  let used = 0;
+  for (const segment of segments) {
+    const length = cells2(segment.text);
+    if (used + length <= budget) {
+      out.push(segment);
+      used += length;
+      continue;
+    }
+    if (segment.text !== SEPARATOR) {
+      const cut = truncate(segment.text, budget - used);
+      if (cut) out.push({ ...segment, text: cut });
+    }
+    break;
+  }
+  return out;
+}
+function tailSegments(draft, spelling, withTier) {
+  if (draft.state === "none") {
+    const out2 = [];
+    if (withTier && draft.tier) out2.push({ text: SEPARATOR, role: "muted" }, { text: draft.tier, role: "tier" });
+    out2.push({ text: SEPARATOR, role: "muted" }, { text: NO_READING_TEXT, role: "muted" });
+    return out2;
+  }
+  const out = [
+    { text: SEPARATOR, role: "muted" },
+    { text: draft.level, role: levelRole(draft.state) }
+  ];
+  const reset = draft.spellings[Math.min(spelling, draft.spellings.length - 1)];
+  if (reset) {
+    out.push({ text: SEPARATOR, role: "muted" });
+    if (reset.startsWith(RESET_WORD)) {
+      out.push({ text: RESET_WORD, role: "muted" }, { text: reset.slice(RESET_WORD.length), role: "reset" });
+    } else {
+      out.push({ text: reset, role: "reset" });
+    }
+  }
+  return out;
+}
+function accountUsageLines(usage, now, width = SIDEBAR_ROW_WIDTH, known = /* @__PURE__ */ new Map()) {
+  const drafts = [];
+  const names = [.../* @__PURE__ */ new Set([...usage.keys(), ...known.keys()])].sort();
+  for (const account of names) {
+    const name = truncate(account, Math.max(1, Math.floor(width / 2)));
+    const windows = usage.get(account);
+    const pressing = windows ? pressingWindow(windows, now) : void 0;
+    if (!pressing) {
+      if (!known.has(account)) continue;
+      drafts.push({
+        account,
+        window: "",
+        state: "none",
+        name,
+        level: "",
+        tier: known.get(account)?.tier,
+        spellings: []
+      });
+      continue;
+    }
+    const [window, entry] = pressing;
+    const state = entry.status === "rejected" ? "limited" : entry.utilization !== null && usagePercent(entry.utilization) >= WARNING_PERCENT ? "warning" : "ok";
+    const short = shortWindowName(window);
+    const level = state === "limited" ? "limited" : entry.utilization === null ? `${short ? `${short} ` : ""}ok` : `${short ? `${short} ` : ""}${Math.round(usagePercent(entry.utilization))}%`;
+    drafts.push({ account, window, state, name, level, spellings: resetSpellings(entry, now) });
+  }
+  const budget = (draft) => Math.max(0, width - cells2(draft.name));
+  const spelt = drafts.filter((draft) => draft.state !== "none");
+  const last = Math.max(0, ...spelt.map((draft) => draft.spellings.length - 1));
+  let spelling = 0;
+  while (spelling < last && spelt.some((draft) => segmentsCells(tailSegments(draft, spelling, true)) > budget(draft))) {
+    spelling += 1;
+  }
+  return drafts.map((draft) => {
+    const full = tailSegments(draft, spelling, true);
+    const tail = segmentsCells(full) <= budget(draft) ? full : tailSegments(draft, spelling, false);
+    return {
+      account: draft.account,
+      window: draft.window,
+      state: draft.state,
+      segments: [{ text: draft.name, role: "agent" }, ...fitSegments(tail, budget(draft))]
+    };
+  });
+}
+
 // src/tui.ts
 var SUBAGENTS_TUI_PLUGIN_ID = "opencode-claude-code-plugin.subagents";
 var SECTION_ORDER = 900;
 var SPINNER_INTERVAL_MS = 100;
 var REFRESH_INTERVAL_MS = 1500;
+var PROGRESS_TICK_MS = 1e3;
+var FRAME_WRAP = SPINNER_FRAMES.length * 600;
 var TASK_TOOLS = /* @__PURE__ */ new Set(["task", "subagent"]);
+var ROLE_COLOR = {
+  spinner: "spinner",
+  done: "done",
+  error: "error",
+  agent: "text",
+  description: "text",
+  muted: "muted",
+  effort: "effort",
+  "effort-faded": "effortFaded",
+  "bar-done": "barDone",
+  // Past every recorded turn: the warning colour, which the effort already takes.
+  "bar-over": "effort",
+  "bar-track": "barTrack",
+  fraction: "fraction",
+  estimate: "fraction",
+  "estimate-over": "effort",
+  tool: "tool",
+  cost: "cost",
+  tier: "tier",
+  reset: "reset"
+};
 function attempt(fn, fallback) {
   try {
     return fn();
@@ -296,64 +921,131 @@ function mix(a, b, weight) {
   );
 }
 function roleColor(colors, role) {
-  switch (role) {
-    case "spinner":
-      return colors.spinner;
-    case "done":
-      return colors.done;
-    case "error":
-      return colors.error;
-    case "effort":
-      return colors.effort;
-    case "effort-faded":
-      return colors.effortFaded;
-    case "agent":
-    case "description":
-      return colors.text;
-    default:
-      return colors.muted;
-  }
+  return colors[ROLE_COLOR[role] ?? "muted"];
 }
+var EMPTY_SOURCE = { messages: [], todos: [] };
+var EMPTY_VIEW = { rows: [], lines: /* @__PURE__ */ new Map() };
 function createSidebar(host) {
   const [frame, setFrame] = createSignal(0);
   const [now, setNow] = createSignal(Date.now());
   const records = createSpawnRecordReader();
   let recordMap = attempt(() => records.read(), /* @__PURE__ */ new Map());
+  const history = createTurnHistoryReader();
+  let historyMap = attempt(() => history.read(), /* @__PURE__ */ new Map());
   const [recordVersion, setRecordVersion] = createSignal(0);
+  const watch = createStatusWatch();
+  const fills = createFillMemory();
+  const usageReader = createAccountUsageReader();
+  const [usage, setUsage] = createSignal(attempt(() => usageReader.read(), /* @__PURE__ */ new Map()));
+  const [known, setKnown] = createSignal(attempt(() => usageReader.known(), /* @__PURE__ */ new Map()));
+  const [usageNow, setUsageNow] = createSignal(Date.now());
   const sectionsRunning = /* @__PURE__ */ new Set();
   const sectionsShowing = /* @__PURE__ */ new Set();
+  const sectionsMounted = /* @__PURE__ */ new Set();
   let spinner;
   let refresh;
+  let refreshPeriod = 0;
+  const refreshTick = () => {
+    if (sectionsShowing.size > 0) {
+      const next = attempt(() => records.read(), recordMap);
+      const nextHistory = attempt(() => history.read(), historyMap);
+      if (next !== recordMap || nextHistory !== historyMap) {
+        recordMap = next;
+        historyMap = nextHistory;
+        setRecordVersion((value) => value + 1);
+      }
+      setNow(Date.now());
+    }
+    setUsage(attempt(() => usageReader.read(), usage()));
+    setKnown(attempt(() => usageReader.known(), known()));
+    const minute = Math.floor(Date.now() / 6e4) * 6e4;
+    if (minute !== usageNow()) setUsageNow(minute);
+  };
   const syncClocks = () => {
     if (sectionsRunning.size > 0 && !spinner) {
-      spinner = setInterval(() => setFrame((value) => (value + 1) % SPINNER_FRAMES.length), SPINNER_INTERVAL_MS);
+      spinner = setInterval(() => setFrame((value) => (value + 1) % FRAME_WRAP), SPINNER_INTERVAL_MS);
     } else if (sectionsRunning.size === 0 && spinner) {
       clearInterval(spinner);
       spinner = void 0;
     }
-    if (sectionsShowing.size > 0 && !refresh) {
-      refresh = setInterval(() => {
-        const next = attempt(() => records.read(), recordMap);
-        if (next !== recordMap) {
-          recordMap = next;
-          setRecordVersion((value) => value + 1);
-        }
-        setNow(Date.now());
-      }, REFRESH_INTERVAL_MS);
-    } else if (sectionsShowing.size === 0 && refresh) {
+    const wanted = sectionsShowing.size > 0 || sectionsMounted.size > 0;
+    const period = sectionsRunning.size > 0 ? PROGRESS_TICK_MS : REFRESH_INTERVAL_MS;
+    if (wanted && (!refresh || refreshPeriod !== period)) {
+      if (refresh) clearInterval(refresh);
+      refreshPeriod = period;
+      refresh = setInterval(refreshTick, period);
+    } else if (!wanted && refresh) {
       clearInterval(refresh);
       refresh = void 0;
+      refreshPeriod = 0;
     }
   };
-  const deriveRows = (parentID) => {
+  const progressOf = (sessionID) => attempt(() => host.progress(sessionID), EMPTY_SOURCE);
+  const estimateFor = (sessionID, measure, view, agentFallback) => {
+    if (view.state !== "running") 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, { elapsedMs: view.elapsedMs, chars: measure.chars, effort: record.effort });
+    if (!estimate) return view;
+    const turn = measure.startedAt ?? 0;
+    return { ...view, estimate: { ...estimate, fill: fills.hold(sessionID, turn, estimate.fill) } };
+  };
+  const deriveView = (sessionID) => {
     recordVersion();
-    return deriveSubagentRows({
-      ...host.gather(parentID),
+    now();
+    const clock = Date.now();
+    const gathered = host.gather(sessionID);
+    const rows = deriveSubagentRows({
+      ...gathered,
       record: (id) => recordMap.get(id),
-      now: now()
+      now: clock
+    });
+    const lines = /* @__PURE__ */ new Map();
+    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 status = gathered.status(sessionID);
+    const memory = watch.observe(sessionID, status, clock);
+    const measure = measureProgress(progressOf(sessionID));
+    const session = sessionProgress(measure, {
+      status,
+      busySince: memory.busySince,
+      stoppedAt: gathered.stoppedAt(sessionID) ?? memory.stoppedAt,
+      now: clock
+    });
+    const progress = session ? estimateFor(sessionID, measure, session) : void 0;
+    return { rows, lines, progress };
+  };
+  const styled = (segment) => {
+    const span = createElement(segment.role === "fraction" ? "b" : "span");
+    insertNode(span, createTextNode(segment.text));
+    effect(() => setProp(span, "style", { fg: roleColor(host.colors(), segment.role) }));
+    return span;
+  };
+  const buildProgressLine = (view, lead) => {
+    const line = createElement("text");
+    setProp(line, "wrapMode", "none");
+    const layout = layoutProgressLine(view, lead, SIDEBAR_ROW_WIDTH);
+    layout.lead.forEach((segment, index) => {
+      if (index === 0 && lead === "glyph" && view.state === "running") {
+        const span = createElement("span");
+        insert(span, () => SPINNER_FRAMES[frame() % SPINNER_FRAMES.length]);
+        effect(() => setProp(span, "style", { fg: roleColor(host.colors(), segment.role) }));
+        insertNode(line, span);
+      } else {
+        insertNode(line, styled(segment));
+      }
     });
+    for (const segment of layout.bar) insertNode(line, styled(segment));
+    for (const segment of layout.tail) insertNode(line, styled(segment));
+    return line;
   };
-  const buildRow = (row) => {
+  const buildRow = (row, progress) => {
     const box = createElement("box");
     const layout = layoutRow(row, SIDEBAR_ROW_WIDTH);
     const first = createElement("text");
@@ -372,14 +1064,10 @@ function createSidebar(host) {
     if (layout.second.length > 0) {
       const second = createElement("text");
       setProp(second, "wrapMode", "none");
-      for (const segment of layout.second) {
-        const span = createElement("span");
-        insertNode(span, createTextNode(segment.text));
-        effect(() => setProp(span, "style", { fg: roleColor(host.colors(), segment.role) }));
-        insertNode(second, span);
-      }
+      for (const segment of layout.second) insertNode(second, styled(segment));
       insertNode(box, second);
     }
+    if (progress) insertNode(box, attempt(() => buildProgressLine(progress, "indent"), createElement("box")));
     if (row.sessionID) {
       const sessionID = row.sessionID;
       setProp(box, "onMouseDown", () => attempt(() => host.navigate(sessionID), void 0));
@@ -396,7 +1084,16 @@ function createSidebar(host) {
     }
     return box;
   };
-  const buildSection = (list, expanded, setExpanded) => {
+  const buildHeading = (label) => {
+    const title = createElement("text");
+    const bold = createElement("b");
+    insertNode(bold, createTextNode(label));
+    insertNode(title, bold);
+    effect(() => setProp(title, "fg", host.colors().text));
+    return title;
+  };
+  const buildSection = (view, expanded, setExpanded) => {
+    const list = view.rows;
     const section = createElement("box");
     const header = createElement("box");
     setProp(header, "flexDirection", "row");
@@ -408,54 +1105,99 @@ function createSidebar(host) {
       effect(() => setProp(caret, "fg", host.colors().text));
       insertNode(header, caret);
     }
-    const title = createElement("text");
-    const bold = createElement("b");
-    insertNode(bold, createTextNode("Subagents"));
-    insertNode(title, bold);
+    const title = buildHeading("Subagents");
     const summary = createElement("span");
     insert(summary, () => expanded() ? "" : ` (${collapsedSummary(list)})`);
     effect(() => setProp(summary, "style", { fg: host.colors().muted }));
     insertNode(title, summary);
-    effect(() => setProp(title, "fg", host.colors().text));
     insertNode(header, title);
     insertNode(section, header);
     const body = createElement("box");
-    insert(body, () => expanded() || list.length <= 2 ? list.map(buildRow) : null);
+    insert(
+      body,
+      () => expanded() || list.length <= 2 ? list.map((row) => buildRow(row, row.sessionID ? view.lines.get(row.sessionID) : void 0)) : null
+    );
+    insertNode(section, body);
+    return section;
+  };
+  const buildProgress = (progress) => {
+    const section = createElement("box");
+    insertNode(section, buildHeading("Main Progress"));
+    const body = createElement("box");
+    insert(body, () => {
+      const view = progress();
+      return view ? attempt(() => buildProgressLine(view, "glyph"), null) : null;
+    });
     insertNode(section, body);
     return section;
   };
+  const buildAccounts = (lines) => {
+    const section = createElement("box");
+    insertNode(section, buildHeading("Accounts"));
+    for (const line of lines) {
+      const text3 = createElement("text");
+      setProp(text3, "wrapMode", "none");
+      for (const segment of line.segments) insertNode(text3, styled(segment));
+      insertNode(section, text3);
+    }
+    return section;
+  };
   const render = (sessionID) => {
     const root = createElement("box");
+    const progressBox = createElement("box");
+    const subagentsBox = createElement("box");
+    const accountsBox = createElement("box");
+    insertNode(root, progressBox);
+    insertNode(root, subagentsBox);
+    insertNode(root, accountsBox);
     const key = /* @__PURE__ */ Symbol("subagents-section");
+    sectionsMounted.add(key);
     const [expanded, setExpanded] = createSignal(true);
-    const rows = createMemo(() => {
+    const view = createMemo(() => {
       const parentID = sessionID();
-      if (!parentID) return [];
-      return attempt(() => deriveRows(parentID), []);
+      if (!parentID) return EMPTY_VIEW;
+      return attempt(() => deriveView(parentID), EMPTY_VIEW);
     });
     effect(() => {
-      const list = rows();
-      if (list.some((row) => row.state === "running")) sectionsRunning.add(key);
+      const { rows, progress } = view();
+      const running = rows.some((row) => row.state === "running") || progress?.state === "running";
+      if (running) sectionsRunning.add(key);
       else sectionsRunning.delete(key);
-      if (list.length > 0) sectionsShowing.add(key);
+      if (rows.length > 0 || progress) sectionsShowing.add(key);
       else sectionsShowing.delete(key);
       syncClocks();
     });
     onCleanup(() => {
       sectionsRunning.delete(key);
       sectionsShowing.delete(key);
+      sectionsMounted.delete(key);
       syncClocks();
     });
-    insert(root, () => {
-      const list = rows();
-      if (list.length === 0) return null;
-      return attempt(() => buildSection(list, expanded, setExpanded), null);
+    const hasProgress = createMemo(() => view().progress !== void 0);
+    insert(
+      progressBox,
+      () => hasProgress() ? attempt(() => buildProgress(() => view().progress), null) : null
+    );
+    insert(subagentsBox, () => {
+      const current = view();
+      if (current.rows.length === 0) return null;
+      return attempt(() => buildSection(current, expanded, setExpanded), null);
     });
+    const accountLines = createMemo(
+      () => attempt(() => accountUsageLines(usage(), usageNow(), SIDEBAR_ROW_WIDTH, known()), [])
+    );
+    insert(accountsBox, () => {
+      const lines = accountLines();
+      if (lines.length === 0) return null;
+      return attempt(() => buildAccounts(lines), null);
+    });
+    syncClocks();
     return root;
   };
   const dispose = () => {
     sectionsRunning.clear();
     sectionsShowing.clear();
+    sectionsMounted.clear();
     syncClocks();
   };
   return { render, dispose };
@@ -505,6 +1247,7 @@ function registerV1(api) {
     lastStatus.set(id, type);
     if (type === "idle" && previous && previous !== "idle") stoppedAt.set(id, Date.now());
     if (type !== "idle") stoppedAt.delete(id);
+    bump();
   });
   const fetchChildren = (parentID) => {
     if (fetched.has(parentID)) return;
@@ -520,15 +1263,23 @@ function registerV1(api) {
   const host = {
     colors() {
       const theme = api.theme.current;
+      const muted = theme.textMuted;
       return {
         text: theme.text,
-        muted: theme.textMuted,
+        muted,
         spinner: theme.accent,
-        done: mix(theme.success, theme.textMuted, 0.45),
-        error: mix(theme.error, theme.textMuted, 0.35),
-        effort: theme.warning ?? theme.textMuted,
-        effortFaded: mix(theme.warning ?? theme.textMuted, theme.textMuted, 0.45),
-        hover: theme.backgroundElement
+        done: mix(theme.success, muted, 0.45),
+        error: mix(theme.error, muted, 0.35),
+        effort: theme.warning ?? muted,
+        effortFaded: mix(theme.warning ?? muted, muted, 0.45),
+        hover: theme.backgroundElement,
+        barDone: theme.success ?? theme.accent,
+        barTrack: mix(muted, theme.backgroundPanel ?? theme.backgroundElement, 0.5),
+        fraction: theme.text,
+        tool: theme.info ?? theme.accent,
+        cost: theme.secondary ?? theme.primary ?? muted,
+        tier: theme.secondary ?? theme.primary ?? muted,
+        reset: theme.info ?? theme.accent
       };
     },
     gather(parentID) {
@@ -581,9 +1332,31 @@ function registerV1(api) {
           if (type === "idle") return "idle";
           return "unknown";
         },
-        stoppedAt: (id) => stoppedAt.get(id)
+        stoppedAt: (id) => stoppedAt.get(id),
+        cost: (id) => attempt(() => api.state.session.get(id)?.cost, void 0)
       };
     },
+    progress(sessionID) {
+      const messages = [];
+      const turn = turnMessages(api.state.session.messages(sessionID) ?? [], (message) => message.role === "user");
+      for (const message of turn) {
+        const tools = [];
+        const texts = [];
+        for (const part of api.state.part(message.id) ?? []) {
+          if (message.role === "assistant" && part.type === "tool") tools.push({ name: part.tool, status: part.state?.status });
+          if (message.role === "user" && part.type === "text" && typeof part.text === "string") texts.push(part.text);
+        }
+        messages.push({
+          role: message.role,
+          created: message.time?.created,
+          error: message.error !== void 0 && message.error !== null,
+          tools,
+          chars: message.role === "user" ? promptChars(texts) : void 0
+        });
+      }
+      const todos = attempt(() => api.state.session.todo?.(sessionID), void 0) ?? [];
+      return { messages, todos: todos.map((todo) => ({ status: todo.status })) };
+    },
     navigate(sessionID) {
       api.route.navigate("session", { sessionID });
     }
@@ -607,7 +1380,8 @@ function setupV2(context) {
     colors() {
       const theme = context.theme;
       const muted = theme.text.muted;
-      const accent = theme.hue.accent[context.themeMode === "light" ? "500" : "200"] ?? theme.text.base;
+      const shade = context.themeMode === "light" ? "500" : "200";
+      const accent = theme.hue.accent[shade] ?? theme.text.base;
       return {
         text: theme.text.base,
         muted,
@@ -616,7 +1390,14 @@ function setupV2(context) {
         error: mix(theme.text.feedback.error.muted ?? theme.text.feedback.error.base, muted, 0.35),
         effort: theme.text.feedback.warning?.base ?? muted,
         effortFaded: mix(theme.text.feedback.warning?.base ?? muted, muted, 0.45),
-        hover: theme.background.raised.base
+        hover: theme.background.raised.base,
+        barDone: theme.text.feedback.success.base ?? accent,
+        barTrack: mix(muted, theme.background.base ?? theme.background.raised.base, 0.5),
+        fraction: theme.text.base,
+        tool: theme.text.feedback.info?.base ?? accent,
+        cost: theme.hue.interactive?.[shade] ?? accent,
+        tier: theme.hue.interactive?.[shade] ?? accent,
+        reset: theme.text.feedback.info?.base ?? accent
       };
     },
     gather(parentID) {
@@ -655,9 +1436,37 @@ function setupV2(context) {
           if (status === "idle") return "idle";
           return "unknown";
         },
-        stoppedAt: () => void 0
+        stoppedAt: () => void 0,
+        cost: (id) => attempt(() => context.data.session.cost?.(id), void 0)
       };
     },
+    progress(sessionID) {
+      const messages = [];
+      const turn = turnMessages(
+        context.data.session.message.list(sessionID) ?? [],
+        (message) => message.type === "user" || message.type === "synthetic"
+      );
+      for (const message of turn) {
+        const tools = [];
+        const texts = [];
+        for (const item of message.content ?? []) {
+          if (message.type === "assistant" && item.type === "tool") tools.push({ name: item.name, status: item.state?.status });
+          if (message.type === "user" && item.type === "text" && typeof item.text === "string") texts.push(item.text);
+        }
+        if (message.type === "synthetic" && message.text) texts.push(message.text);
+        const starts = message.type === "user" || message.type === "synthetic";
+        messages.push({
+          // A synthetic message (a background child's end) prompts the parent
+          // like a user message does: it starts a turn.
+          role: message.type === "synthetic" ? "user" : message.type ?? "",
+          created: message.time?.created,
+          error: message.error !== void 0 && message.error !== null,
+          tools,
+          chars: starts ? promptChars(texts) : void 0
+        });
+      }
+      return { messages, todos: [] };
+    },
     navigate(sessionID) {
       context.ui.router.navigate({ type: "session", sessionID });
     }