oc-go-usage-display 1.1.0 → 2.1.0

package/dist/plugins/oc-go-usage-display.kilo.tsx

@@ -0,0 +1,1364 @@
+// oc-go-usage-display: kilo tui plugin bundle (self-contained)
+
+// src/tui.kilo.tsx
+import { For as For2, Show as Show2, createEffect as createEffect2, createMemo as createMemo2, createSignal as createSignal2, onCleanup } from "solid-js";
+
+// src/shared.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function resolveHomedir() {
+  const envHome = process.env.HOME;
+  if (envHome && envHome.length > 0) return envHome;
+  return os.homedir();
+}
+var ENV_PREFIX = {
+  opencode: "OPENCODE_OC_GO_",
+  kilo: "KILO_OC_GO_"
+};
+function hostEnvName(host, suffix) {
+  return `${ENV_PREFIX[host]}${suffix}`;
+}
+function hostEnv(host, suffix, env = process.env) {
+  return env?.[hostEnvName(host, suffix)];
+}
+function homedirOrEmpty(homedir2) {
+  try {
+    return homedir2();
+  } catch {
+    return "";
+  }
+}
+function resolveHostRoots(host, env = process.env, homedir2 = resolveHomedir) {
+  const home = homedirOrEmpty(homedir2);
+  const configRoot = toNonEmptyString(env.XDG_CONFIG_HOME) ?? safeJoinPath(home, ".config");
+  const dataRoot = toNonEmptyString(env.XDG_DATA_HOME) ?? safeJoinPath(home, ".local", "share");
+  if (host === "kilo") {
+    return {
+      configDir: toNonEmptyString(env.KILO_CONFIG_DIR) ?? safeJoinPath(configRoot, "kilo"),
+      dataDir: safeJoinPath(dataRoot, "kilo")
+    };
+  }
+  return {
+    configDir: safeJoinPath(configRoot, "opencode"),
+    dataDir: safeJoinPath(dataRoot, "opencode")
+  };
+}
+var CONFIG_DIR = resolveHostRoots("opencode").configDir;
+function toPathSegment(value) {
+  if (typeof value === "string") return value;
+  try {
+    return String(value);
+  } catch {
+    return "";
+  }
+}
+function safeJoinPath(base, ...segments) {
+  return path.join(toPathSegment(base), ...segments.map(toPathSegment));
+}
+function authJsonPaths(host = "opencode", env = process.env, homedir2 = resolveHomedir) {
+  const roots = resolveHostRoots(host, env, homedir2);
+  return [safeJoinPath(roots.dataDir, "auth.json"), safeJoinPath(roots.configDir, "auth.json")];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toFiniteNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+}
+function toUsageCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.max(value, 0);
+}
+function toNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function errorMessage(error) {
+  if (error === null || error === void 0) return "unknown error";
+  if (error instanceof Error) {
+    return toNonEmptyString(error.message) ?? toNonEmptyString(error.name) ?? "unknown error";
+  }
+  try {
+    return toNonEmptyString(String(error)) ?? "unknown error";
+  } catch {
+    return "unknown error";
+  }
+}
+var KILO_SLOT_ORDER = 125;
+var KILO_INTEGRATED_SLOT_ORDER = 150;
+var KILO_USAGE_PANEL_PLUGIN_ID = "internal:kilo-sidebar-usage";
+var KILO_TOKEN_USAGE_ROWS = [
+  "Input",
+  "Output",
+  "Reasoning",
+  "Cache read",
+  "Cache write",
+  "Cache rate",
+  "Cost"
+];
+var GO_PROVIDER_ID = "opencode-go";
+var KILO_MODEL_NAME_MAX_CHARS = 19;
+var KILO_STEPS_COLUMN_WIDTH = 5;
+var KILO_COST_COLUMN_WIDTH = 9;
+var SIDEBAR_COLLAPSED_GLYPH = "\u25B6";
+var SIDEBAR_EXPANDED_GLYPH = "\u25BE";
+var CACHE_RATE_DECIMALS = 1;
+var CACHE_RATE_EMPTY = "-";
+var PERCENT_CELL_WIDTH = 5;
+var INTEGRATED_TOKENS_SECTION_LABEL = "Session Tokens";
+var INTEGRATED_MODELS_SECTION_LABEL = "Models";
+var GO_PLAN_HEADING = "Go Plan";
+var INTEGRATED_GO_SHARE_LABEL = "Go share";
+var MODELS_EMPTY_LABEL = "No model usage yet";
+var INTEGRATED_LOADING_LABEL = "Loading usage...";
+var INTEGRATED_UNAVAILABLE_LABEL = "Usage unavailable";
+var SECONDS_PER_MINUTE = 60;
+var SECONDS_PER_HOUR = 3600;
+var SECONDS_PER_DAY = 86400;
+var SECONDS_PER_WEEK = 604800;
+function resetDayUnits(sec) {
+  const units = [
+    { value: Math.floor(sec / SECONDS_PER_WEEK), suffix: "w" },
+    { value: Math.floor(sec % SECONDS_PER_WEEK / SECONDS_PER_DAY), suffix: "d" },
+    { value: Math.floor(sec % SECONDS_PER_DAY / SECONDS_PER_HOUR), suffix: "h" }
+  ];
+  return units.filter((unit) => unit.value > 0).map((unit) => `${unit.value}${unit.suffix}`);
+}
+function formatResetDuration(totalSec) {
+  if (totalSec === null || !Number.isFinite(totalSec) || totalSec < 0) return null;
+  const sec = Math.floor(totalSec);
+  if (sec < SECONDS_PER_DAY) {
+    const hours = Math.floor(sec / SECONDS_PER_HOUR);
+    const minutes = Math.floor(sec % SECONDS_PER_HOUR / SECONDS_PER_MINUTE);
+    if (hours === 0) return minutes > 0 ? `${minutes}m` : `${sec}s`;
+    return minutes > 0 ? `${hours}h${minutes}m` : `${hours}h`;
+  }
+  return resetDayUnits(sec).join(" ");
+}
+function readAuthJsonApiKey(host = "opencode", env = process.env, homedir2 = resolveHomedir) {
+  for (const authPath of authJsonPaths(host, env, homedir2)) {
+    let raw;
+    try {
+      raw = fs.readFileSync(authPath, "utf8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) continue;
+    const goEntry = parsed["opencode-go"];
+    const fallbackEntry = parsed["opencode"];
+    const goKey = isRecord(goEntry) ? toNonEmptyString(goEntry.key) : null;
+    if (goKey) return goKey;
+    const fallbackKey = isRecord(fallbackEntry) ? toNonEmptyString(fallbackEntry.key) : null;
+    if (fallbackKey) return fallbackKey;
+  }
+  return null;
+}
+function usableCountdown(seconds) {
+  if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) return null;
+  return seconds;
+}
+function secondsUntilReset(resetsAt, now) {
+  const instant = toNonEmptyString(resetsAt);
+  if (instant === null) return null;
+  return usableCountdown(Math.round((Date.parse(instant) - now) / 1e3));
+}
+var LIMITED_STATUSES = /* @__PURE__ */ new Set(["rate-limited", "limited", "exhausted", "capped"]);
+function isLimitedStatus(status) {
+  if (status === null) return false;
+  const normalized = status.trim().toLowerCase().replace(/[\s_]+/g, "-");
+  return LIMITED_STATUSES.has(normalized);
+}
+function extractWindow(candidate, now = Date.now()) {
+  if (!isRecord(candidate)) return null;
+  const percent = toFiniteNumber(
+    candidate.percent ?? candidate.usagePercent ?? candidate.usedPercent ?? candidate.value ?? candidate.usage
+  );
+  if (percent === null) return null;
+  const status = toNonEmptyString(candidate.status);
+  const resetInSec = usableCountdown(candidate.resetInSec ?? candidate.resetInSeconds) ?? secondsUntilReset(candidate.resetsAt, now);
+  const resetText = toNonEmptyString(candidate.resetText ?? candidate.reset ?? null);
+  return { percent: Math.round(percent), status, limited: isLimitedStatus(status), resetInSec, resetText };
+}
+function extractSnapshotFromApiPayload(payload, now = Date.now()) {
+  if (!isRecord(payload)) return null;
+  const containers = [payload];
+  for (const key of ["usage", "data", "go"]) {
+    if (isRecord(payload[key])) containers.push(payload[key]);
+  }
+  for (const container of containers) {
+    if (!isRecord(container)) continue;
+    const rolling = extractWindow(container.rolling ?? container.rollingUsage ?? container["5h"], now);
+    const weekly = extractWindow(container.weekly ?? container.weeklyUsage ?? container["7d"], now);
+    const monthly = extractWindow(container.monthly ?? container.monthlyUsage ?? container["30d"], now);
+    if (rolling !== null || weekly !== null || monthly !== null) {
+      return {
+        rolling,
+        weekly,
+        monthly,
+        source: "api",
+        fetchedAt: now
+      };
+    }
+  }
+  return null;
+}
+var MOCK_PERCENTS = [42, 15, 61];
+function parseMockPercents(raw) {
+  const text = toNonEmptyString(raw);
+  if (text === null) return null;
+  const parts = text.split(",");
+  if (parts.length !== MOCK_PERCENTS.length) return null;
+  const values = parts.map((part) => Number(part.trim()));
+  const rolling = values[0];
+  const weekly = values[1];
+  const monthly = values[2];
+  if (rolling === void 0 || weekly === void 0 || monthly === void 0) return null;
+  if (!Number.isFinite(rolling) || !Number.isFinite(weekly) || !Number.isFinite(monthly)) return null;
+  return [rolling, weekly, monthly];
+}
+var MOCK_RESETS = [7543, null, null];
+var MOCK_LIMITED = [false, false, false];
+function parseMockShare(raw) {
+  const text = toNonEmptyString(raw);
+  if (text === null) return null;
+  const value = Number(text.trim());
+  return Number.isFinite(value) ? value : null;
+}
+function parseMockResets(raw) {
+  const text = toNonEmptyString(raw);
+  if (text === null) return null;
+  const parts = text.split(",");
+  if (parts.length !== MOCK_PERCENTS.length) return null;
+  const parsed = parts.map((part) => {
+    const slot = part.trim();
+    if (slot === "" || slot === "-") return null;
+    const value = Number(slot);
+    return Number.isFinite(value) && value >= 0 ? value : void 0;
+  });
+  const [rolling, weekly, monthly] = parsed;
+  if (rolling === void 0 || weekly === void 0 || monthly === void 0) return null;
+  return [rolling, weekly, monthly];
+}
+function parseMockLimited(raw) {
+  const text = toNonEmptyString(raw);
+  if (text === null) return null;
+  const parts = text.split(",");
+  if (parts.length !== MOCK_PERCENTS.length) return null;
+  const parsed = parts.map((part) => {
+    const slot = part.trim();
+    if (slot === "" || slot === "-") return false;
+    return MOCK_LIMITED_TRUE.has(slot.toLowerCase());
+  });
+  const [rolling, weekly, monthly] = parsed;
+  if (rolling === void 0 || weekly === void 0 || monthly === void 0) return null;
+  return [rolling, weekly, monthly];
+}
+var MOCK_LIMITED_TRUE = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function mockGoShare(host, env = process.env) {
+  if (hostEnv(host, "MOCK", env) !== "1") return null;
+  return parseMockShare(hostEnv(host, "MOCK_SHARE", env));
+}
+function mockSnapshot(overrides = {}) {
+  const percents = overrides.percents ?? MOCK_PERCENTS;
+  const resets = overrides.resets ?? MOCK_RESETS;
+  const limited = overrides.limited ?? MOCK_LIMITED;
+  const window = (index, percent) => {
+    const capped = limited[index] === true;
+    return {
+      percent,
+      // A capped window says so, because that is what the real payload says, and
+      // because `limited` is what gates the per-row countdown: a window with a
+      // countdown and no cap is a shape the API does not produce.
+      status: capped ? "rate-limited" : "active",
+      limited: capped,
+      resetInSec: resets[index] ?? null,
+      resetText: null
+    };
+  };
+  return {
+    rolling: window(0, percents[0]),
+    weekly: window(1, percents[1]),
+    monthly: window(2, percents[2]),
+    source: "mock",
+    fetchedAt: Date.now()
+  };
+}
+function unavailableSnapshot(error) {
+  return {
+    rolling: null,
+    weekly: null,
+    monthly: null,
+    source: "unavailable",
+    fetchedAt: Date.now(),
+    apiUnavailable: true,
+    apiError: error
+  };
+}
+var EMPTY_TOKENS = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+function parseUsageTokens(candidate) {
+  if (!isRecord(candidate)) return { ...EMPTY_TOKENS, cache: { ...EMPTY_TOKENS.cache } };
+  const cache = isRecord(candidate.cache) ? candidate.cache : {};
+  return {
+    input: toUsageCount(candidate.input),
+    output: toUsageCount(candidate.output),
+    reasoning: toUsageCount(candidate.reasoning),
+    cache: { read: toUsageCount(cache.read), write: toUsageCount(cache.write) }
+  };
+}
+function parseUsageTotals(candidate) {
+  if (!isRecord(candidate)) return { steps: 0, cost: 0, tokens: { ...EMPTY_TOKENS, cache: { ...EMPTY_TOKENS.cache } } };
+  return {
+    steps: toUsageCount(candidate.steps),
+    cost: toUsageCount(candidate.cost),
+    tokens: parseUsageTokens(candidate.tokens)
+  };
+}
+function parseSessionModelUsage(payload) {
+  if (!isRecord(payload)) return null;
+  const models = [];
+  if (Array.isArray(payload.models)) {
+    for (const entry of payload.models) {
+      if (!isRecord(entry)) continue;
+      const providerID = toNonEmptyString(entry.providerID);
+      const modelID = toNonEmptyString(entry.modelID);
+      if (providerID === null || modelID === null) continue;
+      models.push({ providerID, modelID, ...parseUsageTotals(entry) });
+    }
+  }
+  return {
+    sessionIDs: Array.isArray(payload.sessionIDs) ? payload.sessionIDs.filter((id) => typeof id === "string") : [],
+    totals: parseUsageTotals(payload.totals),
+    models
+  };
+}
+
+// src/helpers.ts
+function isDisplayMode(value) {
+  return value === "sidebar" || value === "statusline" || value === "both";
+}
+var DEFAULT_SIDEBAR_MODE = "integrated";
+function parseSidebarMode(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "integrated" || normalized === "standalone" ? normalized : null;
+}
+function providerIdFromModel(model) {
+  if (typeof model !== "string" || model.length === 0) return void 0;
+  const provider = model.split("/")[0];
+  return provider !== void 0 && provider.length > 0 ? provider : void 0;
+}
+function resolveProviderId(state, sessionId, fallback) {
+  try {
+    const fromSession = state?.session?.get?.(sessionId)?.model?.providerID;
+    if (typeof fromSession === "string" && fromSession.length > 0) return fromSession;
+  } catch {
+  }
+  try {
+    const fromConfig = providerIdFromModel(state?.config?.model);
+    if (fromConfig !== void 0) return fromConfig;
+  } catch {
+  }
+  return fallback;
+}
+function surfaceSelectionFromDisplayMode(mode) {
+  return { sidebar: mode !== "statusline", statusline: mode !== "sidebar" };
+}
+function parseBooleanFlag(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (value === 1) return true;
+    if (value === 0) return false;
+    return null;
+  }
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true") return true;
+  if (normalized === "0" || normalized === "false") return false;
+  return null;
+}
+function isSnapshotEmpty(snapshot) {
+  return snapshot.rolling === null && snapshot.weekly === null && snapshot.monthly === null;
+}
+function relevantReset(snapshot) {
+  const rows = buildPlanRows(snapshot);
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const row = rows[i];
+    if (row?.reset != null) return { label: row.label, text: row.reset };
+  }
+  return soonestReset(snapshot);
+}
+function soonestReset(snapshot) {
+  const windows = [
+    ["5h", snapshot.rolling],
+    ["7d", snapshot.weekly],
+    ["30d", snapshot.monthly]
+  ];
+  let soonest = null;
+  for (const [name, window] of windows) {
+    if (window === null) continue;
+    const seconds = window.resetInSec;
+    if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) continue;
+    if (soonest !== null && seconds >= soonest.seconds) continue;
+    soonest = { label: name, seconds };
+  }
+  if (soonest === null) return null;
+  const text = formatResetDuration(soonest.seconds);
+  return text === null ? null : { label: soonest.label, text };
+}
+function formatStatusline(snapshot) {
+  const rolling = snapshot.rolling === null ? "5h n/a" : `5h ${snapshot.rolling.percent}%`;
+  const weekly = snapshot.weekly === null ? "7d n/a" : `7d ${snapshot.weekly.percent}%`;
+  const monthly = snapshot.monthly === null ? "30d n/a" : `30d ${snapshot.monthly.percent}%`;
+  const windows = `Go ${rolling} | ${weekly} | ${monthly}`;
+  const reset = relevantReset(snapshot);
+  return reset === null ? windows : `${windows} \xB7 resets in ${reset.text}`;
+}
+var WARNING_PERCENT = 75;
+var ERROR_PERCENT = 90;
+function usageMeterSeverity(window) {
+  if (window.limited) return "error";
+  return meterSeverityForPercent(window.percent);
+}
+function meterSeverityForPercent(percent) {
+  if (!Number.isFinite(percent)) return "muted";
+  if (percent >= ERROR_PERCENT) return "error";
+  if (percent >= WARNING_PERCENT) return "warning";
+  return "muted";
+}
+function meterFillPercent(percent) {
+  if (!Number.isFinite(percent)) return 0;
+  return Math.min(Math.max(percent, 0), 100);
+}
+function buildPlanRows(snapshot) {
+  const windows = [
+    ["5h", snapshot.rolling],
+    ["7d", snapshot.weekly],
+    ["30d", snapshot.monthly]
+  ];
+  const rows = [];
+  for (const [label, window] of windows) {
+    if (window === null) continue;
+    rows.push({
+      label,
+      percent: window.percent,
+      severity: usageMeterSeverity(window),
+      // A countdown only tells the user something once the window is capped;
+      // before that the schedule is noise, and the header rows already show it.
+      reset: window.limited ? formatResetDuration(window.resetInSec) ?? window.resetText : null
+    });
+  }
+  return rows;
+}
+var COUNT_FORMAT = new Intl.NumberFormat("en-US");
+var CURRENCY_FORMAT = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });
+function formatUsageCount(value) {
+  return COUNT_FORMAT.format(toUsageCount(value));
+}
+function formatUsageCost(value) {
+  return CURRENCY_FORMAT.format(toUsageCount(value));
+}
+function usageTokenCount(tokens) {
+  return toUsageCount(tokens.input) + toUsageCount(tokens.output) + toUsageCount(tokens.reasoning) + toUsageCount(tokens.cache.read) + toUsageCount(tokens.cache.write);
+}
+function cacheRatePercent(tokens) {
+  const denominator = toUsageCount(tokens.input) + toUsageCount(tokens.cache.read) + toUsageCount(tokens.cache.write);
+  if (denominator === 0) return CACHE_RATE_EMPTY;
+  return `${(toUsageCount(tokens.cache.read) / denominator * 100).toFixed(CACHE_RATE_DECIMALS)}%`;
+}
+function goSharePercent(modelTokens, totalGoTokens2) {
+  const total = toUsageCount(totalGoTokens2);
+  if (total === 0) return 0;
+  return toUsageCount(modelTokens) / total * 100;
+}
+function totalGoTokens(models) {
+  let total = 0;
+  for (const model of models) {
+    if (model.providerID !== GO_PROVIDER_ID) continue;
+    total += usageTokenCount(model.tokens);
+  }
+  return total;
+}
+function groupModelsByProvider(models, providerNames = /* @__PURE__ */ new Map()) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const group = groups.get(model.providerID) ?? {
+      providerID: model.providerID,
+      providerName: providerNames.get(model.providerID) ?? model.providerID,
+      models: []
+    };
+    group.models.push(model);
+    groups.set(model.providerID, group);
+  }
+  return [...groups.values()];
+}
+function truncateModelName(value, max = KILO_MODEL_NAME_MAX_CHARS) {
+  if (value.length <= max) return value;
+  const budget = Math.max(max - 1, 0);
+  return `${value.slice(0, budget)}\u2026`;
+}
+function displayModelName(name) {
+  return name.trim().replace(/^[^:]+:\s+/, "").replace(/^[^/\s]+\/(?=[^/]+$)/, "").replace(/\s*\([^)]*%\s*off[^)]*\)\s*$/i, "").replace(/^([A-Za-z]{2,})(?=\d)/, "$1 ").replace(/\s+/g, " ");
+}
+function modelDisplayName(catalogName, modelID, max = KILO_MODEL_NAME_MAX_CHARS) {
+  const raw = toNonEmptyString(catalogName) ?? toNonEmptyString(modelID) ?? "";
+  return truncateModelName(displayModelName(raw), max);
+}
+var PLAN_LABEL_WIDTH = 3;
+var GO_SHARE_LABEL_WIDTH = INTEGRATED_GO_SHARE_LABEL.length;
+function formatPercentCell(percent, width = PERCENT_CELL_WIDTH) {
+  const cells = Math.max(Math.floor(width), 1);
+  const rounded = Number.isFinite(percent) ? Math.round(meterFillPercent(percent)) : 0;
+  return `${`${rounded}%`}`.padStart(cells, " ");
+}
+function buildTokenUsageRows(totals) {
+  const values = {
+    Input: formatUsageCount(totals.tokens.input),
+    Output: formatUsageCount(totals.tokens.output),
+    Reasoning: formatUsageCount(totals.tokens.reasoning),
+    "Cache read": formatUsageCount(totals.tokens.cache.read),
+    "Cache write": formatUsageCount(totals.tokens.cache.write),
+    "Cache rate": cacheRatePercent(totals.tokens),
+    Cost: formatUsageCost(totals.cost)
+  };
+  return KILO_TOKEN_USAGE_ROWS.flatMap((label) => {
+    const value = values[label];
+    return value === void 0 ? [] : [{ label, value }];
+  });
+}
+function buildModelTokenRows(tokens) {
+  return buildTokenUsageRows({ cost: 0, tokens }).filter((row) => row.label !== "Cost");
+}
+
+// src/tui-shared.tsx
+import { For, Show, createEffect, createMemo, createSignal } from "solid-js";
+import { jsx, jsxs } from "@opentui/solid/jsx-runtime";
+var API_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
+var POLL_INTERVAL_MS = 6e4;
+var EVENT_TTL_MS = 15e3;
+var DEBOUNCE_MS = 5e3;
+var FETCH_TIMEOUT_MS = 1e4;
+var LOG_SERVICE = "oc-go-usage-display";
+var KV_DISPLAY_KEY = "display";
+var KV_COLLAPSED_SIDEBAR_KEY = "collapsed_sidebar";
+var KV_COLLAPSED_STATUSLINE_KEY = "collapsed_statusline";
+var KV_COLLAPSED_LEGACY_KEY = "collapsed";
+function reactiveChild(accessor) {
+  return accessor;
+}
+function meterColor(theme, severity) {
+  if (severity === "error") return theme.current.error;
+  if (severity === "warning") return theme.current.warning;
+  return theme.current.textMuted;
+}
+async function logUsageError(api, message) {
+  try {
+    await api.client.app.log({ service: LOG_SERVICE, level: "error", message });
+  } catch {
+  }
+}
+async function fetchJsonWithTimeout(url, apiKey) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+    });
+    if (response.status === 401 || response.status === 403) return { __rejected: true };
+    if (!response.ok) return null;
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function loadUsageSnapshot(host) {
+  if (hostEnv(host, "MOCK") === "1") {
+    const overrides = {};
+    const percents = parseMockPercents(hostEnv(host, "MOCK_PERCENTS"));
+    if (percents !== null) overrides.percents = percents;
+    const resets = parseMockResets(hostEnv(host, "MOCK_RESETS"));
+    if (resets !== null) overrides.resets = resets;
+    const limited = parseMockLimited(hostEnv(host, "MOCK_LIMITED"));
+    if (limited !== null) overrides.limited = limited;
+    return mockSnapshot(overrides);
+  }
+  const apiKey = toNonEmptyString(hostEnv(host, "API_KEY")) ?? readAuthJsonApiKey(host);
+  if (apiKey === null) return null;
+  const payload = await fetchJsonWithTimeout(API_USAGE_URL, apiKey);
+  if (payload === null) return null;
+  if (isRecord(payload) && payload.__rejected === true) {
+    return unavailableSnapshot("API key rejected (401/403)");
+  }
+  return extractSnapshotFromApiPayload(payload);
+}
+function createUsageStore(api, host) {
+  const [snapshot, setSnapshot] = createSignal(null);
+  let cachedAt = 0;
+  let lastFetchAt = 0;
+  let refreshInFlight = false;
+  async function refresh(ttlOverride) {
+    if (refreshInFlight) return;
+    const effectiveTtl = ttlOverride ?? POLL_INTERVAL_MS;
+    if (ttlOverride !== void 0) {
+      if (Date.now() - lastFetchAt < DEBOUNCE_MS) return;
+      if (Date.now() - cachedAt < effectiveTtl && snapshot() !== null) return;
+    } else if (Date.now() - cachedAt < POLL_INTERVAL_MS && snapshot() !== null) {
+      return;
+    }
+    refreshInFlight = true;
+    try {
+      const next = await loadUsageSnapshot(host);
+      if (next === null) {
+        if (snapshot() === null) {
+          await logUsageError(api, "Go usage unavailable (not configured or request failed)");
+        }
+        return;
+      }
+      cachedAt = Date.now();
+      setSnapshot(next);
+    } catch {
+    } finally {
+      lastFetchAt = Date.now();
+      refreshInFlight = false;
+    }
+  }
+  return {
+    snapshot,
+    refresh: () => refresh(),
+    refreshSafely: (ttlOverride) => {
+      void refresh(ttlOverride).catch(() => {
+      });
+    }
+  };
+}
+function resolveSurfaceSelection(options, api, host) {
+  if (options !== void 0) {
+    const sidebarOption = parseBooleanFlag(options.sidebar);
+    const statuslineOption = parseBooleanFlag(options.statusline);
+    if (sidebarOption !== null || statuslineOption !== null) {
+      return { sidebar: sidebarOption ?? true, statusline: statuslineOption ?? true };
+    }
+    if (isDisplayMode(options.display)) return surfaceSelectionFromDisplayMode(options.display);
+  }
+  const sidebarEnv = parseBooleanFlag(hostEnv(host, "SIDEBAR"));
+  const statuslineEnv = parseBooleanFlag(hostEnv(host, "STATUSLINE"));
+  if (sidebarEnv !== null || statuslineEnv !== null) {
+    return { sidebar: sidebarEnv ?? true, statusline: statuslineEnv ?? true };
+  }
+  const displayEnv = toNonEmptyString(hostEnv(host, "DISPLAY"));
+  if (displayEnv !== null && isDisplayMode(displayEnv)) {
+    return surfaceSelectionFromDisplayMode(displayEnv);
+  }
+  try {
+    const stored = api.kv.get(KV_DISPLAY_KEY, "both");
+    if (isDisplayMode(stored)) return surfaceSelectionFromDisplayMode(stored);
+  } catch {
+  }
+  return { sidebar: true, statusline: true };
+}
+function readCollapsedFlag(api, key) {
+  try {
+    return api.kv.get(key, false) === true;
+  } catch {
+    return false;
+  }
+}
+function migrateLegacyCollapsedFlag(api) {
+  let legacyCollapsed = false;
+  try {
+    legacyCollapsed = api.kv.get(KV_COLLAPSED_LEGACY_KEY, false) === true;
+  } catch {
+    return;
+  }
+  if (!legacyCollapsed) return;
+  try {
+    api.kv.set(KV_COLLAPSED_SIDEBAR_KEY, true);
+    api.kv.set(KV_COLLAPSED_STATUSLINE_KEY, true);
+    api.kv.set(KV_COLLAPSED_LEGACY_KEY, false);
+  } catch {
+  }
+}
+function createCollapseState(api) {
+  migrateLegacyCollapsedFlag(api);
+  const [isSidebarCollapsed, setIsSidebarCollapsed] = createSignal(
+    readCollapsedFlag(api, KV_COLLAPSED_SIDEBAR_KEY)
+  );
+  const [isStatuslineCollapsed, setIsStatuslineCollapsed] = createSignal(
+    readCollapsedFlag(api, KV_COLLAPSED_STATUSLINE_KEY)
+  );
+  return {
+    isSidebarCollapsed,
+    isStatuslineCollapsed,
+    toggleSidebar() {
+      try {
+        const next = !isSidebarCollapsed();
+        setIsSidebarCollapsed(next);
+        api.kv.set(KV_COLLAPSED_SIDEBAR_KEY, next);
+      } catch {
+      }
+    },
+    toggleStatusline() {
+      try {
+        const next = !isStatuslineCollapsed();
+        setIsStatuslineCollapsed(next);
+        api.kv.set(KV_COLLAPSED_STATUSLINE_KEY, next);
+      } catch {
+      }
+    }
+  };
+}
+function isGoUsageProvider(providerId) {
+  return providerId === GO_PROVIDER_ID;
+}
+function makeProviderResolver(state, fallback) {
+  return (sessionId) => resolveProviderId(state, sessionId, fallback());
+}
+function readProviderDisplayNames(source) {
+  const names = /* @__PURE__ */ new Map();
+  try {
+    for (const provider of source.state?.provider ?? []) {
+      const id = toNonEmptyString(provider.id);
+      if (id === null) continue;
+      names.set(id, toNonEmptyString(provider.name) ?? id);
+    }
+  } catch {
+  }
+  return names;
+}
+function readModelDisplayName(source, providerID, modelID) {
+  try {
+    const provider = source.state?.provider?.find((entry) => entry.id === providerID);
+    return toNonEmptyString(provider?.models?.[modelID]?.name);
+  } catch {
+    return null;
+  }
+}
+function LabeledValueRow(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "row", justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: props.row.label }),
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: props.row.value })
+  ] });
+}
+var MIN_METER_WIDTH = 6;
+function MeterBar(props) {
+  const fill = createMemo(() => meterFillPercent(props.percent));
+  const track = createMemo(() => 100 - fill());
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "row", flexGrow: 1, flexShrink: 1, minWidth: MIN_METER_WIDTH, children: [
+    /* @__PURE__ */ jsx(Show, { when: fill() > 0, children: /* @__PURE__ */ jsx(
+      "box",
+      {
+        flexGrow: fill(),
+        flexBasis: 0,
+        flexShrink: 0,
+        backgroundColor: meterColor(props.theme, props.severity)
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Show, { when: track() > 0, children: /* @__PURE__ */ jsx(
+      "box",
+      {
+        flexGrow: track(),
+        flexBasis: 0,
+        flexShrink: 0,
+        backgroundColor: props.theme.current.backgroundElement
+      }
+    ) })
+  ] });
+}
+function GoPlanRow(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs("box", { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx("box", { width: PLAN_LABEL_WIDTH, marginRight: 1, flexShrink: 0, flexDirection: "row", children: /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: props.row.label }) }),
+      /* @__PURE__ */ jsx(MeterBar, { theme: props.theme, percent: props.row.percent, severity: props.row.severity }),
+      /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", flexShrink: 0, children: formatPercentCell(props.row.percent) })
+    ] }),
+    /* @__PURE__ */ jsx(Show, { when: props.row.reset, children: (reset) => /* @__PURE__ */ jsxs("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: [
+      "resets in ",
+      reset()
+    ] }) })
+  ] });
+}
+function GoPlanSection(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.text, wrapMode: "none", children: /* @__PURE__ */ jsx("b", { children: GO_PLAN_HEADING }) }),
+    /* @__PURE__ */ jsx("box", { flexDirection: "column", paddingLeft: 1, children: /* @__PURE__ */ jsx(For, { each: props.rows, children: (row) => /* @__PURE__ */ jsx(GoPlanRow, { theme: props.theme, row }) }) })
+  ] });
+}
+function SectionHeader(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "row", gap: 1, flexShrink: 0, onMouseDown: props.onToggle, children: [
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.text, wrapMode: "none", flexShrink: 0, children: reactiveChild(() => props.expanded() ? SIDEBAR_EXPANDED_GLYPH : SIDEBAR_COLLAPSED_GLYPH) }),
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.text, wrapMode: "none", children: /* @__PURE__ */ jsx("b", { children: reactiveChild(() => {
+      const count = props.count();
+      return count === null ? props.label : `${props.label} (${count})`;
+    }) }) })
+  ] });
+}
+function CollapsibleSection(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(
+      SectionHeader,
+      {
+        theme: props.theme,
+        label: props.label,
+        count: props.count,
+        expanded: props.expanded,
+        onToggle: props.onToggle
+      }
+    ),
+    /* @__PURE__ */ jsx("box", { flexDirection: "column", gap: 1, children: reactiveChild(() => props.expanded() ? props.body() : null) })
+  ] });
+}
+function GoShareRow(props) {
+  const rounded = Math.round(props.percent);
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx("box", { width: GO_SHARE_LABEL_WIDTH, marginRight: 1, flexShrink: 0, flexDirection: "row", children: /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: INTEGRATED_GO_SHARE_LABEL }) }),
+    /* @__PURE__ */ jsx(MeterBar, { theme: props.theme, percent: rounded, severity: meterSeverityForPercent(rounded) }),
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", flexShrink: 0, children: formatPercentCell(rounded) })
+  ] });
+}
+function GoUsageBlock(props) {
+  createEffect(() => {
+    const snapshot = props.snapshot();
+    if (snapshot !== null && snapshot.source === "unavailable") {
+      void logUsageError(
+        props.api,
+        snapshot.apiError ? `Go usage unavailable (${snapshot.apiError})` : "Go usage snapshot unavailable"
+      );
+    }
+  });
+  const body = createMemo(() => {
+    const snapshot = props.snapshot();
+    if (snapshot === null) {
+      return /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: "Go loading\u2026" });
+    }
+    if (snapshot.source === "unavailable") {
+      return /* @__PURE__ */ jsxs("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: [
+        "Go n/a (",
+        snapshot.apiError ?? "unavailable",
+        ")"
+      ] });
+    }
+    const planRows = buildPlanRows(snapshot).map((row) => ({ ...row, reset: null }));
+    return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Show, { when: props.resetLine === void 0 ? null : props.resetLine(), children: (reset) => /* @__PURE__ */ jsxs("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: [
+        reset().label,
+        " resets in ",
+        reset().text
+      ] }) }),
+      /* @__PURE__ */ jsx(For, { each: planRows, children: (row) => /* @__PURE__ */ jsx(GoPlanRow, { theme: props.theme, row }) })
+    ] });
+  });
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.text, children: /* @__PURE__ */ jsx("b", { children: "Go Usage" }) }),
+    reactiveChild(body)
+  ] });
+}
+function GoStatusline(props) {
+  return /* @__PURE__ */ jsx(Show, { when: props.snapshot(), fallback: null, children: (snapshot) => {
+    if (isSnapshotEmpty(snapshot())) return null;
+    return /* @__PURE__ */ jsx("text", { children: formatStatusline(snapshot()) });
+  } });
+}
+
+// src/tui.kilo.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "@opentui/solid/jsx-runtime";
+var SESSION_TREE_WALK_LIMIT = 32;
+var HOST = "kilo";
+var SLOT_ORDER = KILO_SLOT_ORDER;
+var INTEGRATED_SLOT_ORDER = KILO_INTEGRATED_SLOT_ORDER;
+var KV_SIDEBAR_MODE_KEY = "sidebar_mode";
+function resolveSidebarMode(options, api) {
+  if (options !== void 0) {
+    const option = parseSidebarMode(options.sidebar_mode);
+    if (option !== null) return option;
+  }
+  const env = parseSidebarMode(hostEnv(HOST, "SIDEBAR_MODE"));
+  if (env !== null) return env;
+  try {
+    const stored = parseSidebarMode(api.kv.get(KV_SIDEBAR_MODE_KEY, null));
+    if (stored !== null) return stored;
+  } catch {
+  }
+  return DEFAULT_SIDEBAR_MODE;
+}
+function hostUsagePanelEnabled(api) {
+  try {
+    const entry = api.plugins?.list?.().find((status) => status.id === KILO_USAGE_PANEL_PLUGIN_ID);
+    if (entry === void 0) return null;
+    return entry.active || entry.enabled;
+  } catch {
+    return null;
+  }
+}
+async function applyHostUsagePanel(api, mode) {
+  const wantEnabled = mode === "standalone";
+  try {
+    const current = hostUsagePanelEnabled(api);
+    if (current === wantEnabled) return;
+    const applied = await (wantEnabled ? api.plugins.activate(KILO_USAGE_PANEL_PLUGIN_ID) : api.plugins.deactivate(KILO_USAGE_PANEL_PLUGIN_ID));
+    if (applied === true) return;
+    await logUsageError(
+      api,
+      `Could not ${wantEnabled ? "enable" : "disable"} Kilo's ${KILO_USAGE_PANEL_PLUGIN_ID} panel`
+    );
+  } catch (error) {
+    await logUsageError(
+      api,
+      `Kilo ${KILO_USAGE_PANEL_PLUGIN_ID} panel switch failed: ${errorMessage(error)}`
+    );
+  }
+}
+async function fetchSessionModelUsage(api, sessionId) {
+  if (sessionId.length === 0) return null;
+  try {
+    const result = await api.client.kilocode.sessionModelUsage({ sessionID: sessionId });
+    return parseSessionModelUsage(result.data);
+  } catch {
+    return null;
+  }
+}
+function isInSessionTree(api, sessionId, rootId) {
+  if (sessionId === rootId) return true;
+  let current = sessionId;
+  for (let depth = 0; depth < SESSION_TREE_WALK_LIMIT; depth += 1) {
+    let parent;
+    try {
+      parent = api.state?.session.get(current)?.parentID;
+    } catch {
+      return false;
+    }
+    if (parent === void 0 || parent.length === 0) return false;
+    if (parent === rootId) return true;
+    current = parent;
+  }
+  return false;
+}
+function trackSubscription(unsubscribes, subscribe) {
+  try {
+    const unsubscribe = subscribe();
+    if (typeof unsubscribe === "function") unsubscribes.push(unsubscribe);
+  } catch {
+  }
+}
+async function initializeTui(api, options) {
+  const surfaces = resolveSurfaceSelection(options, api, HOST);
+  const usageStore = createUsageStore(api, HOST);
+  const collapse = createCollapseState(api);
+  let sidebarMode = resolveSidebarMode(options, api);
+  void applyHostUsagePanel(api, sidebarMode);
+  const [activeProviderId, setActiveProviderId] = createSignal2(void 0);
+  try {
+    const modelString = api.state?.config?.model;
+    if (typeof modelString === "string" && modelString.length > 0) {
+      const providerPart = modelString.split("/")[0];
+      if (providerPart !== void 0 && providerPart.length > 0) setActiveProviderId(providerPart);
+    }
+  } catch {
+  }
+  const resolveActiveProviderId = makeProviderResolver(api.state, activeProviderId);
+  function toggleSidebarMode() {
+    const next = sidebarMode === "integrated" ? "standalone" : "integrated";
+    sidebarMode = next;
+    void applyHostUsagePanel(api, next);
+    try {
+      api.kv.set(KV_SIDEBAR_MODE_KEY, next);
+    } catch {
+    }
+  }
+  function planResetLine() {
+    const snapshot = usageStore.snapshot();
+    if (snapshot === null || snapshot.source === "unavailable") return null;
+    return relevantReset(snapshot);
+  }
+  function currentPlanRows() {
+    const snapshot = usageStore.snapshot();
+    if (snapshot === null || snapshot.source === "unavailable") return [];
+    return buildPlanRows(snapshot);
+  }
+  function ProviderUsageGroup(props) {
+    const isGo = props.group.providerID === GO_PROVIDER_ID;
+    return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsx2("text", { fg: props.theme.current.text, wrapMode: "none", children: props.group.providerName }),
+      /* @__PURE__ */ jsx2(Show2, { when: isGo && props.planRows.length > 0, children: /* @__PURE__ */ jsx2(GoPlanSection, { theme: props.theme, rows: props.planRows }) }),
+      /* @__PURE__ */ jsxs2("box", { flexDirection: "row", gap: 1, children: [
+        /* @__PURE__ */ jsx2("box", { width: 1, flexShrink: 0 }),
+        /* @__PURE__ */ jsx2("text", { flexGrow: 1, minWidth: 0, fg: props.theme.current.textMuted, wrapMode: "none", children: "Model" }),
+        /* @__PURE__ */ jsx2(
+          "box",
+          {
+            width: KILO_STEPS_COLUMN_WIDTH,
+            flexDirection: "row",
+            flexShrink: 0,
+            justifyContent: "flex-end",
+            children: /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: "Steps" })
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "box",
+          {
+            width: KILO_COST_COLUMN_WIDTH,
+            flexDirection: "row",
+            flexShrink: 0,
+            justifyContent: "flex-end",
+            children: /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: "Cost" })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx2(For2, { each: props.group.models, children: (model) => {
+        const key = `${model.providerID}/${model.modelID}`;
+        return /* @__PURE__ */ jsx2(
+          ModelUsageRow,
+          {
+            theme: props.theme,
+            model,
+            isGo,
+            expanded: () => props.expandedModels().has(key),
+            goShare: () => mockGoShare(HOST) ?? goSharePercent(usageTokenCount(model.tokens), props.goTotal),
+            onToggle: () => props.onToggleModel(key)
+          }
+        );
+      } })
+    ] });
+  }
+  function ModelUsageRow(props) {
+    const detail = createMemo2(
+      () => props.expanded() ? /* @__PURE__ */ jsx2("box", { flexDirection: "column", paddingLeft: 2, children: /* @__PURE__ */ jsx2(For2, { each: buildModelTokenRows(props.model.tokens), children: (row) => /* @__PURE__ */ jsx2(LabeledValueRow, { theme: props.theme, row }) }) }) : null
+    );
+    return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsxs2("box", { flexDirection: "row", gap: 1, flexShrink: 0, onMouseDown: props.onToggle, children: [
+        /* @__PURE__ */ jsx2("text", { fg: props.theme.current.text, wrapMode: "none", flexShrink: 0, children: reactiveChild(() => props.expanded() ? SIDEBAR_EXPANDED_GLYPH : SIDEBAR_COLLAPSED_GLYPH) }),
+        /* @__PURE__ */ jsx2("box", { flexGrow: 1, minWidth: 0, overflow: "hidden", children: /* @__PURE__ */ jsx2("text", { fg: props.theme.current.text, wrapMode: "none", children: /* @__PURE__ */ jsx2("b", { children: modelDisplayName(
+          readModelDisplayName(api, props.model.providerID, props.model.modelID),
+          props.model.modelID
+        ) }) }) }),
+        /* @__PURE__ */ jsx2(
+          "box",
+          {
+            width: KILO_STEPS_COLUMN_WIDTH,
+            flexDirection: "row",
+            flexShrink: 0,
+            justifyContent: "flex-end",
+            children: /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: formatUsageCount(props.model.steps) })
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "box",
+          {
+            width: KILO_COST_COLUMN_WIDTH,
+            flexDirection: "row",
+            flexShrink: 0,
+            justifyContent: "flex-end",
+            children: /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: formatUsageCost(props.model.cost) })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx2(Show2, { when: props.isGo, children: /* @__PURE__ */ jsx2("box", { paddingLeft: 2, children: /* @__PURE__ */ jsx2(GoShareRow, { theme: props.theme, percent: props.goShare() }) }) }),
+      reactiveChild(detail)
+    ] });
+  }
+  function ModelsSection(props) {
+    const [isExpanded, setIsExpanded] = createSignal2(true);
+    const [expandedModels, setExpandedModels] = createSignal2(/* @__PURE__ */ new Set());
+    function toggleModel(key) {
+      setExpandedModels((current) => {
+        const next = new Set(current);
+        if (!next.delete(key)) next.add(key);
+        return next;
+      });
+    }
+    const modelCount = createMemo2(() => props.usage()?.models.length ?? 0);
+    const body = createMemo2(() => {
+      const usage = props.usage();
+      const models = usage?.models ?? [];
+      const providerNames = readProviderDisplayNames(api);
+      const grouped = groupModelsByProvider(models, providerNames);
+      const groups = grouped.length === 0 && props.planRows().length > 0 ? [
+        {
+          providerID: GO_PROVIDER_ID,
+          providerName: providerNames.get(GO_PROVIDER_ID) ?? GO_PROVIDER_ID,
+          models: []
+        }
+      ] : grouped;
+      const goTotal = totalGoTokens(models);
+      return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", gap: 1, paddingTop: 1, children: [
+        /* @__PURE__ */ jsx2(Show2, { when: models.length === 0, children: /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: MODELS_EMPTY_LABEL }) }),
+        /* @__PURE__ */ jsx2(For2, { each: groups, children: (group) => /* @__PURE__ */ jsx2(
+          ProviderUsageGroup,
+          {
+            theme: props.theme,
+            group,
+            planRows: props.planRows(),
+            goTotal,
+            expandedModels,
+            onToggleModel: toggleModel
+          }
+        ) })
+      ] });
+    });
+    return /* @__PURE__ */ jsx2(
+      CollapsibleSection,
+      {
+        theme: props.theme,
+        label: INTEGRATED_MODELS_SECTION_LABEL,
+        count: modelCount,
+        expanded: isExpanded,
+        onToggle: () => setIsExpanded((current) => !current),
+        body
+      }
+    );
+  }
+  function GoIntegratedPanel(props) {
+    const [usage, setUsage] = createSignal2(null);
+    const [loadFailed, setLoadFailed] = createSignal2(false);
+    const [refetchToken, setRefetchToken] = createSignal2(0);
+    const [isTokensExpanded, setIsTokensExpanded] = createSignal2(true);
+    createEffect2(() => {
+      const sessionId = props.sessionId;
+      refetchToken();
+      if (sessionId.length === 0) return;
+      let cancelled = false;
+      void fetchSessionModelUsage(api, sessionId).then((result) => {
+        if (cancelled) return;
+        setUsage(result);
+        if (result === null && !loadFailed()) {
+          void logUsageError(api, "Session model usage unavailable (request failed)");
+        }
+        setLoadFailed(result === null);
+      });
+      onCleanup(() => {
+        cancelled = true;
+      });
+    });
+    createEffect2(() => {
+      const sessionId = props.sessionId;
+      const unsubscribes = [];
+      const inTree = (id) => isInSessionTree(api, id, sessionId);
+      const refetch = () => {
+        setRefetchToken((current) => current + 1);
+      };
+      trackSubscription(
+        unsubscribes,
+        () => api.event.on("message.part.updated", (event) => {
+          if (event.properties.part.type !== "step-finish") return;
+          if (inTree(event.properties.sessionID)) refetch();
+        })
+      );
+      trackSubscription(
+        unsubscribes,
+        () => api.event.on("message.part.removed", (event) => {
+          if (inTree(event.properties.sessionID)) refetch();
+        })
+      );
+      trackSubscription(
+        unsubscribes,
+        () => api.event.on("message.removed", (event) => {
+          if (inTree(event.properties.sessionID)) refetch();
+        })
+      );
+      trackSubscription(
+        unsubscribes,
+        () => api.event.on("session.created", (event) => {
+          if (inTree(event.properties.sessionID)) refetch();
+        })
+      );
+      trackSubscription(
+        unsubscribes,
+        () => api.event.on("session.deleted", (event) => {
+          if (inTree(event.properties.sessionID)) refetch();
+        })
+      );
+      trackSubscription(unsubscribes, () => api.event.on("server.connected", refetch));
+      onCleanup(() => {
+        for (const unsubscribe of unsubscribes) {
+          try {
+            unsubscribe();
+          } catch {
+          }
+        }
+      });
+    });
+    const tokenBody = createMemo2(() => {
+      const data = usage();
+      if (data === null) {
+        return /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: loadFailed() ? INTEGRATED_UNAVAILABLE_LABEL : INTEGRATED_LOADING_LABEL });
+      }
+      return /* @__PURE__ */ jsx2("box", { flexDirection: "column", children: /* @__PURE__ */ jsx2(For2, { each: buildTokenUsageRows(data.totals), children: (row) => /* @__PURE__ */ jsx2(LabeledValueRow, { theme: props.theme, row }) }) });
+    });
+    return (
+      // Integrated mode draws the plan ONCE, as the `Go Plan` meters inside the
+      // OpenCode Go group of the Models table. A `Go Usage` block above it (as
+      // there was) said the same three numbers twice, in two different
+      // layouts, on the same screen.
+      /* @__PURE__ */ jsxs2("box", { flexDirection: "column", gap: 1, children: [
+        /* @__PURE__ */ jsx2(
+          CollapsibleSection,
+          {
+            theme: props.theme,
+            label: INTEGRATED_TOKENS_SECTION_LABEL,
+            count: () => null,
+            expanded: isTokensExpanded,
+            onToggle: () => setIsTokensExpanded((current) => !current),
+            body: tokenBody
+          }
+        ),
+        /* @__PURE__ */ jsx2(ModelsSection, { theme: props.theme, usage, planRows: currentPlanRows })
+      ] })
+    );
+  }
+  function GoSidebarPanel(props) {
+    return /* @__PURE__ */ jsx2(
+      GoUsageBlock,
+      {
+        api,
+        theme: props.theme,
+        snapshot: usageStore.snapshot,
+        resetLine: planResetLine
+      }
+    );
+  }
+  if (surfaces.sidebar) {
+    try {
+      api.slots.register({
+        order: sidebarMode === "integrated" ? INTEGRATED_SLOT_ORDER : SLOT_ORDER,
+        slots: {
+          sidebar_content(ctx, props) {
+            try {
+              if (props.session_id.length === 0) return null;
+              if (!isGoUsageProvider(resolveActiveProviderId(props.session_id))) return null;
+              if (api.route.current.name !== "session") return null;
+              if (collapse.isSidebarCollapsed()) return null;
+              if (sidebarMode === "integrated") {
+                return /* @__PURE__ */ jsx2(GoIntegratedPanel, { theme: ctx.theme, sessionId: props.session_id });
+              }
+              return /* @__PURE__ */ jsx2(GoSidebarPanel, { theme: ctx.theme });
+            } catch {
+              return null;
+            }
+          }
+        }
+      });
+    } catch {
+    }
+  }
+  if (surfaces.statusline) {
+    try {
+      api.slots.register({
+        order: SLOT_ORDER,
+        slots: {
+          session_prompt_right(_ctx, props) {
+            try {
+              if (props.session_id.length === 0) return null;
+              if (!isGoUsageProvider(resolveActiveProviderId(props.session_id))) return null;
+              if (collapse.isStatuslineCollapsed()) return null;
+              return /* @__PURE__ */ jsx2(GoStatusline, { snapshot: usageStore.snapshot });
+            } catch {
+              return null;
+            }
+          }
+        }
+      });
+    } catch {
+    }
+  }
+  let unregisterToggleCommand = () => {
+  };
+  try {
+    const unregister = api.command?.register(() => [
+      {
+        title: "Go usage: toggle sidebar",
+        value: "oc-go-usage-display.toggle-sidebar",
+        category: "Go",
+        onSelect: () => collapse.toggleSidebar()
+      },
+      {
+        title: "Go usage: toggle statusline",
+        value: "oc-go-usage-display.toggle-statusline",
+        category: "Go",
+        onSelect: () => collapse.toggleStatusline()
+      },
+      {
+        title: "Go usage: toggle sidebar mode",
+        value: "oc-go-usage-display.toggle-sidebar-mode",
+        category: "Go",
+        onSelect: () => toggleSidebarMode()
+      }
+    ]);
+    if (typeof unregister === "function") unregisterToggleCommand = unregister;
+  } catch {
+  }
+  let unsubscribeSession = () => {
+  };
+  let unsubscribeMessage = () => {
+  };
+  try {
+    const unsubscribe = api.event.on("session.updated", (event) => {
+      const providerId = event?.properties?.info?.model?.providerID;
+      if (providerId !== void 0) setActiveProviderId(providerId);
+      usageStore.refreshSafely(0);
+    });
+    if (typeof unsubscribe === "function") unsubscribeSession = unsubscribe;
+  } catch {
+  }
+  try {
+    const unsubscribe = api.event.on("message.updated", () => usageStore.refreshSafely(EVENT_TTL_MS));
+    if (typeof unsubscribe === "function") unsubscribeMessage = unsubscribe;
+  } catch {
+  }
+  let pollTimer = null;
+  try {
+    pollTimer = setInterval(() => usageStore.refreshSafely(), POLL_INTERVAL_MS);
+  } catch {
+  }
+  try {
+    api.lifecycle.onDispose(() => {
+      if (pollTimer !== null) {
+        try {
+          clearInterval(pollTimer);
+        } catch {
+        }
+      }
+      for (const teardown of [unsubscribeSession, unsubscribeMessage, unregisterToggleCommand]) {
+        try {
+          teardown();
+        } catch {
+        }
+      }
+    });
+  } catch {
+    if (pollTimer !== null) {
+      try {
+        clearInterval(pollTimer);
+      } catch {
+      }
+    }
+  }
+  await usageStore.refresh();
+}
+var goUsageTui = async (api, options) => {
+  try {
+    await initializeTui(api, options);
+  } catch (error) {
+    void logUsageError(
+      api,
+      `Go usage TUI failed to initialize: ${errorMessage(error)}; continuing without display`
+    );
+  }
+};
+var tui_kilo_default = { id: "oc-go-usage-display", tui: goUsageTui };
+export {
+  tui_kilo_default as default
+};