@mageyuki/opencode-subagent-statusline 0.0.0-stage → 0.7.1

package/dist/tui-v2.js

@@ -0,0 +1,2922 @@
+// src/tui-v2.tsx
+import { insert as _$insert2 } from "@opentui/solid";
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+import { memo as _$memo2 } from "@opentui/solid";
+import { use as _$use2 } from "@opentui/solid";
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+import { Plugin } from "@opencode/plugin/tui";
+import { batch, createEffect as createEffect2, createRoot, createSignal as createSignal2, onCleanup as onCleanup2, Show as Show2, untrack } from "solid-js";
+
+// src/state.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { basename, dirname, join } from "path";
+import os from "os";
+
+// src/internal-policy.ts
+var TERMINAL_CHILD_TTL_MS = 3 * 24 * 60 * 60 * 1e3;
+var MAX_TERMINAL_CHILDREN = 1500;
+var V2_RETRY_INITIAL_DELAY_MS = 1e3;
+var V2_RETRY_MAX_DELAY_MS = 3e4;
+var V2_RETRY_MAX_ATTEMPTS = 6;
+var V2_DETAIL_CONCURRENCY = 4;
+var V2_HISTORY_PAGE_SIZE = 100;
+var V2_FOCUS_MAX_ATTEMPTS = 10;
+var V2_FOCUS_RETRY_DELAY_MS = 30;
+var MAX_SYNC_LOG_READ_BYTES = 1024 * 1024;
+
+// src/subagent-classification.ts
+function isRealSessionID(value) {
+  return typeof value === "string" && value.startsWith("ses_");
+}
+function isTrustedTargetSessionID(value) {
+  return isRealSessionID(value);
+}
+function trustedTargetSessionID(item) {
+  return isTrustedTargetSessionID(item.targetSessionID) ? item.targetSessionID : void 0;
+}
+function isRealExecution(item) {
+  return item.source === "session" || isRealSessionID(item.id);
+}
+function realExecutionID(item) {
+  return trustedTargetSessionID(item) ?? item.id;
+}
+function classifySubagentWorkItem(item) {
+  if (isRealExecution(item)) {
+    const executionID = realExecutionID(item);
+    return {
+      kind: "real-execution",
+      executionID,
+      targetSessionID: executionID
+    };
+  }
+  const targetSessionID = trustedTargetSessionID(item);
+  if (targetSessionID) {
+    return {
+      kind: "execution-proxy",
+      executionID: targetSessionID,
+      targetSessionID
+    };
+  }
+  return { kind: "invocation-wrapper" };
+}
+function uniqueExecutionID(candidates) {
+  const executionIDs = new Set(candidates.map((item) => realExecutionID(item)));
+  return executionIDs.size === 1 ? [...executionIDs][0] : void 0;
+}
+function realExecutions(items) {
+  return items.filter((item) => classifySubagentWorkItem(item).kind === "real-execution");
+}
+function resolveTrustedTargetExecutionID(item, realItems) {
+  const targetSessionID = trustedTargetSessionID(item);
+  if (!targetSessionID) return void 0;
+  return realExecutions(realItems).some(
+    (realItem) => realExecutionID(realItem) === targetSessionID
+  ) ? targetSessionID : void 0;
+}
+function resolveSharedMessageExecutionID(item, realItems) {
+  if (!item.messageID) return void 0;
+  return uniqueExecutionID(
+    realExecutions(realItems).filter(
+      (realItem) => realItem.parentID === item.parentID && realItem.messageID === item.messageID
+    )
+  );
+}
+function resolveUniqueSameParentExecutionID(item, realItems) {
+  return uniqueExecutionID(
+    realExecutions(realItems).filter(
+      (realItem) => realItem.parentID === item.parentID
+    )
+  );
+}
+function resolveCorrelatedExecutionID(item, realItems) {
+  if (trustedTargetSessionID(item)) {
+    return resolveTrustedTargetExecutionID(item, realItems);
+  }
+  return resolveSharedMessageExecutionID(item, realItems) ?? resolveUniqueSameParentExecutionID(item, realItems);
+}
+function correlateSubagentWorkItems(items) {
+  const realItems = realExecutions(items);
+  const executions = /* @__PURE__ */ new Map();
+  for (const item of realItems) {
+    const executionID = realExecutionID(item);
+    if (!executions.has(executionID)) {
+      executions.set(executionID, { executionID, real: item, proxies: [] });
+    }
+  }
+  for (const item of items) {
+    if (classifySubagentWorkItem(item).kind === "real-execution") continue;
+    const executionID = resolveCorrelatedExecutionID(item, realItems);
+    if (!executionID) continue;
+    executions.get(executionID)?.proxies.push(item);
+  }
+  return [...executions.values()];
+}
+function mergeProxyMetadataWithRealExecution(real, proxy) {
+  const executionID = realExecutionID(real);
+  return {
+    ...real,
+    title: proxy.title ?? real.title,
+    summary: proxy.summary ?? real.summary,
+    agentName: proxy.agentName ?? real.agentName,
+    messageID: real.messageID ?? proxy.messageID,
+    id: real.id,
+    parentID: real.parentID,
+    source: "session",
+    targetSessionID: real.targetSessionID ?? executionID,
+    status: real.status,
+    color: real.color,
+    startedAt: real.startedAt,
+    updatedAt: real.updatedAt,
+    endedAt: real.endedAt,
+    elapsedMs: real.elapsedMs,
+    tokens: real.tokens,
+    model: real.model
+  };
+}
+
+// src/state.ts
+function statusColor(status) {
+  if (status === "done") return "green";
+  if (status === "error") return "red";
+  return "yellow";
+}
+function safeTimestamp(input, fallback) {
+  if (typeof input !== "string") return fallback;
+  return Number.isNaN(Date.parse(input)) ? fallback : input;
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function toNonNegativeInteger(value) {
+  const parsed = toFiniteNumber(value);
+  if (parsed === void 0) return void 0;
+  return Math.max(0, Math.floor(parsed));
+}
+function sanitizeCountedChildIDs(input) {
+  if (!input || typeof input !== "object") return {};
+  const counted = {};
+  for (const [id, value] of Object.entries(input)) {
+    if (!id) continue;
+    if (value === true) {
+      counted[id] = true;
+    }
+  }
+  return counted;
+}
+function normalizeExecutionCounters(state) {
+  state.countedChildIDs = sanitizeCountedChildIDs(state.countedChildIDs);
+  const countedTotal = Object.keys(state.countedChildIDs).length;
+  state.totalExecuted = Math.max(
+    toNonNegativeInteger(state.totalExecuted) ?? 0,
+    countedTotal
+  );
+}
+function resolveExecutionCountIdentity(child) {
+  const classification = classifySubagentWorkItem(child);
+  return classification.kind === "real-execution" ? classification.executionID : void 0;
+}
+function countHistoricalSubagentExecutions(input) {
+  const children = Array.isArray(input.children) ? input.children : Object.values(input.children);
+  const scopedChildren = input.parentSessionID ? children.filter((child) => child.parentID === input.parentSessionID) : children;
+  return correlateSubagentWorkItems(scopedChildren).length;
+}
+function countCountedSubagentExecutions(input) {
+  const children = Array.isArray(input.children) ? input.children : Object.values(input.children);
+  const scopedChildren = input.parentSessionID ? children.filter((child) => child.parentID === input.parentSessionID) : children;
+  return correlateSubagentWorkItems(scopedChildren).filter(
+    (execution) => input.countedChildIDs[execution.executionID]
+  ).length;
+}
+function countRetainedSubagentStatuses(input) {
+  const children = Array.isArray(input.children) ? input.children : Object.values(input.children);
+  const scopedChildren = input.parentSessionID ? children.filter((child) => child.parentID === input.parentSessionID) : children;
+  const counts = { running: 0, done: 0, error: 0 };
+  for (const { real } of correlateSubagentWorkItems(scopedChildren)) {
+    counts[real.status] += 1;
+  }
+  return counts;
+}
+function reconcileCountedExecutionsWithChildren(state) {
+  const executionIDs = correlateSubagentWorkItems(
+    Object.values(state.children)
+  ).map((execution) => execution.executionID);
+  state.countedChildIDs = Object.fromEntries(
+    executionIDs.map((id) => [id, true])
+  );
+  state.totalExecuted = executionIDs.length;
+}
+function countChildExecution(state, child) {
+  normalizeExecutionCounters(state);
+  const countIdentity = resolveExecutionCountIdentity(child);
+  if (!countIdentity) return false;
+  if (state.countedChildIDs[countIdentity]) return false;
+  const previousTotal = Math.max(
+    toNonNegativeInteger(state.totalExecuted) ?? 0,
+    Object.keys(state.countedChildIDs).length
+  );
+  state.countedChildIDs[countIdentity] = true;
+  state.totalExecuted = previousTotal + 1;
+  return true;
+}
+function sanitizeTokens(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const raw = input;
+  const tokens2 = {
+    input: toFiniteNumber(raw.input),
+    output: toFiniteNumber(raw.output),
+    total: toFiniteNumber(raw.total),
+    contextPercent: toFiniteNumber(raw.contextPercent)
+  };
+  if (tokens2.input === void 0 && tokens2.output === void 0 && tokens2.total === void 0 && tokens2.contextPercent === void 0) {
+    return void 0;
+  }
+  return tokens2;
+}
+function sanitizeModel(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const raw = input;
+  const providerID = typeof raw.providerID === "string" ? raw.providerID.trim() : "";
+  const modelID = typeof raw.modelID === "string" ? raw.modelID.trim() : "";
+  const variant = typeof raw.variant === "string" ? raw.variant.trim() : "";
+  if (!providerID || !modelID) return void 0;
+  return { providerID, modelID, ...variant ? { variant } : {} };
+}
+function sanitizeTargetSessionID(value, fallback) {
+  if (typeof value === "string" && value.startsWith("ses_")) {
+    return value;
+  }
+  if (typeof fallback === "string" && fallback.startsWith("ses_")) {
+    return fallback;
+  }
+  return void 0;
+}
+function mergeTokens(existing, incoming) {
+  if (!existing && !incoming) return void 0;
+  return {
+    input: incoming?.input ?? existing?.input,
+    output: incoming?.output ?? existing?.output,
+    total: incoming?.total ?? existing?.total,
+    contextPercent: incoming?.contextPercent ?? existing?.contextPercent
+  };
+}
+function sameTokens(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function normalizeComparableText(value) {
+  return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function sanitizeSummary(value, title) {
+  if (typeof value !== "string") return void 0;
+  const summary = value.replace(/\s+/g, " ").trim();
+  if (!summary) return void 0;
+  if (normalizeComparableText(summary) === normalizeComparableText(title)) {
+    return void 0;
+  }
+  return summary;
+}
+function sanitizeAgentName(value) {
+  if (typeof value !== "string") return void 0;
+  const agentName = value.replace(/^\((.*)\)$/, "$1").replace(/\s+/g, " ").trim();
+  return agentName || void 0;
+}
+function resolveElapsedMs(child, nowMs) {
+  const startedMs = Date.parse(child.startedAt);
+  if (Number.isNaN(startedMs)) return 0;
+  const endSource = child.endedAt ?? child.updatedAt;
+  const endMs = child.endedAt ? Date.parse(endSource) : nowMs;
+  if (Number.isNaN(endMs)) return 0;
+  return Math.max(0, endMs - startedMs);
+}
+function terminalReferenceMs(child) {
+  const parsed = Date.parse(
+    child.endedAt ?? child.updatedAt ?? child.startedAt
+  );
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function pruneTerminalChildren(state, now = /* @__PURE__ */ new Date()) {
+  const nowMs = now.getTime();
+  const terminalChildren = [];
+  let pruned = 0;
+  for (const child of Object.values(state.children)) {
+    if (child.status === "running") continue;
+    const referenceMs = terminalReferenceMs(child);
+    if (nowMs - referenceMs > TERMINAL_CHILD_TTL_MS) {
+      delete state.children[child.id];
+      pruned += 1;
+      continue;
+    }
+    terminalChildren.push({ id: child.id, referenceMs });
+  }
+  if (terminalChildren.length <= MAX_TERMINAL_CHILDREN) {
+    return pruned;
+  }
+  terminalChildren.sort(
+    (a, b) => b.referenceMs - a.referenceMs || a.id.localeCompare(b.id)
+  );
+  for (const child of terminalChildren.slice(MAX_TERMINAL_CHILDREN)) {
+    delete state.children[child.id];
+    pruned += 1;
+  }
+  return pruned;
+}
+function refreshDerivedFields(state, now = /* @__PURE__ */ new Date()) {
+  const nowISO = now.toISOString();
+  const nowMs = now.getTime();
+  normalizeExecutionCounters(state);
+  for (const [id, child] of Object.entries(state.children)) {
+    const startedAt = safeTimestamp(child.startedAt, nowISO);
+    const updatedAt = safeTimestamp(child.updatedAt, nowISO);
+    const endedAt = child.endedAt ? safeTimestamp(child.endedAt, updatedAt) : void 0;
+    const status = child.status === "done" || child.status === "error" || child.status === "running" ? child.status : "running";
+    const targetSessionID = sanitizeTargetSessionID(
+      child.targetSessionID,
+      id.startsWith("ses_") ? id : void 0
+    );
+    state.children[id] = {
+      ...child,
+      startedAt,
+      updatedAt,
+      endedAt,
+      status,
+      targetSessionID,
+      color: statusColor(status),
+      tokens: sanitizeTokens(child.tokens),
+      model: sanitizeModel(child.model),
+      elapsedMs: resolveElapsedMs(
+        {
+          ...child,
+          startedAt,
+          updatedAt,
+          endedAt,
+          status,
+          color: statusColor(status)
+        },
+        nowMs
+      )
+    };
+  }
+  reconcileCountedExecutionsWithChildren(state);
+  state.updatedAt = safeTimestamp(state.updatedAt, nowISO);
+  if (pruneTerminalChildren(state, now) > 0) {
+    reconcileCountedExecutionsWithChildren(state);
+    state.updatedAt = nowISO;
+  }
+}
+var STATUS_DIRNAME = "opencode-subagent-statusline";
+var STATUS_FILENAME = "state.json";
+var STATUS_DIR_MODE = 448;
+var STATUS_FILE_MODE = 384;
+function sanitizeInstanceName(input) {
+  return input.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function resolveDefaultInstanceName() {
+  const fromEnv = process.env.OPENCODE_SUBAGENT_STATUSLINE_INSTANCE;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+    const safe = sanitizeInstanceName(fromEnv);
+    if (safe.length > 0) {
+      return safe;
+    }
+  }
+  return `pid-${process.pid}`;
+}
+function createEmptyState() {
+  return {
+    children: {},
+    countedChildIDs: {},
+    totalExecuted: 0,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function resolveStatePath() {
+  const fromEnv = process.env.OPENCODE_SUBAGENT_STATUSLINE_STATE;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+    return fromEnv;
+  }
+  const runtimeDir = process.env.XDG_RUNTIME_DIR ?? os.tmpdir();
+  const instance = resolveDefaultInstanceName();
+  return join(runtimeDir, STATUS_DIRNAME, instance, STATUS_FILENAME);
+}
+function resolveTextPath(statePath) {
+  return join(dirname(statePath), "status.txt");
+}
+async function writeLocalStatusFile(path, contents, options) {
+  if (options?.shouldCommit?.() === false) return;
+  const directory = dirname(path);
+  await mkdir(directory, { recursive: true, mode: STATUS_DIR_MODE });
+  const tempPath = join(
+    directory,
+    `.${basename(path)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(tempPath, contents, {
+      encoding: "utf8",
+      mode: STATUS_FILE_MODE
+    });
+    if (options?.shouldCommit?.() === false) {
+      await rm(tempPath, { force: true });
+      return;
+    }
+    await rename(tempPath, path);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function saveStatusText(textPath, contents, options) {
+  await writeLocalStatusFile(textPath, contents, options);
+}
+async function saveState(statePath, state, options) {
+  if (options?.shouldCommit?.() === false) return;
+  refreshDerivedFields(state);
+  await writeLocalStatusFile(statePath, JSON.stringify(state, null, 2), options);
+}
+function upsertRunningChild(state, input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const observedUpdatedAt = safeTimestamp(input.updatedAt, now);
+  const observedStartedAt = safeTimestamp(input.startedAt, observedUpdatedAt);
+  const existing = state.children[input.id];
+  const targetSessionID = sanitizeTargetSessionID(
+    input.targetSessionID ?? existing?.targetSessionID,
+    input.id.startsWith("ses_") ? input.id : void 0
+  );
+  const source = input.source ?? existing?.source ?? "session";
+  const counted = existing ? false : countChildExecution(state, {
+    id: input.id,
+    title: input.title,
+    parentID: input.parentID,
+    messageID: input.messageID,
+    source,
+    targetSessionID
+  });
+  const shouldKeepCompletedTiming = existing?.status === "done" || existing?.status === "error";
+  const next = {
+    id: input.id,
+    title: input.title,
+    summary: sanitizeSummary(input.summary, input.title) ?? sanitizeSummary(existing?.summary, input.title),
+    agentName: sanitizeAgentName(input.agentName) ?? existing?.agentName,
+    parentID: input.parentID,
+    messageID: input.messageID ?? existing?.messageID,
+    source,
+    toolName: input.toolName ?? existing?.toolName,
+    targetSessionID,
+    status: shouldKeepCompletedTiming ? existing.status : "running",
+    color: statusColor(shouldKeepCompletedTiming ? existing.status : "running"),
+    startedAt: existing?.startedAt ?? observedStartedAt,
+    updatedAt: observedUpdatedAt,
+    endedAt: shouldKeepCompletedTiming ? existing.endedAt : void 0,
+    elapsedMs: existing?.elapsedMs,
+    tokens: existing?.tokens,
+    model: existing?.model
+  };
+  if (existing && next.title === existing.title && next.summary === existing.summary && next.agentName === existing.agentName && next.parentID === existing.parentID && next.messageID === existing.messageID && next.source === existing.source && next.toolName === existing.toolName && next.targetSessionID === existing.targetSessionID && next.status === existing.status && next.color === existing.color && next.startedAt === existing.startedAt && next.endedAt === existing.endedAt && sameTokens(next.tokens, existing.tokens) && JSON.stringify(next.model) === JSON.stringify(existing.model)) {
+    return counted;
+  }
+  state.children[input.id] = next;
+  state.updatedAt = observedUpdatedAt;
+  return true;
+}
+function markChildStatus(state, childID, status, endedAt) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let changed = false;
+  let stateUpdatedAt = state.updatedAt;
+  for (const child of Object.values(state.children)) {
+    if (child.id !== childID && child.targetSessionID !== childID) continue;
+    const observedEndedAt = endedAt ? safeTimestamp(endedAt, now) : child.endedAt ?? now;
+    if (child.status === status && child.color === statusColor(status) && child.updatedAt === observedEndedAt && child.endedAt === observedEndedAt) {
+      continue;
+    }
+    const nextChild = {
+      ...child,
+      status,
+      color: statusColor(status),
+      updatedAt: observedEndedAt,
+      endedAt: observedEndedAt
+    };
+    state.children[child.id] = {
+      ...nextChild,
+      elapsedMs: resolveElapsedMs(nextChild, Date.now())
+    };
+    stateUpdatedAt = observedEndedAt;
+    changed = true;
+  }
+  if (changed) {
+    state.updatedAt = stateUpdatedAt;
+  }
+  return changed;
+}
+function upsertChildDetails(state, childID, input) {
+  const existing = state.children[childID];
+  if (!existing) return false;
+  const nextTitle = typeof input.title === "string" && input.title.trim().length > 0 ? input.title : existing.title;
+  const nextSummary = sanitizeSummary(input.summary, nextTitle) ?? sanitizeSummary(existing.summary, nextTitle);
+  const nextAgentName = sanitizeAgentName(input.agentName) ?? existing.agentName;
+  const mergedTokens = mergeTokens(existing.tokens, input.tokens);
+  const nextTargetSessionID = sanitizeTargetSessionID(
+    input.targetSessionID ?? existing.targetSessionID,
+    existing.id.startsWith("ses_") ? existing.id : void 0
+  );
+  const detailsChanged = nextTitle !== existing.title || nextSummary !== existing.summary || nextAgentName !== existing.agentName || !sameTokens(mergedTokens, existing.tokens) || nextTargetSessionID !== existing.targetSessionID;
+  if (!detailsChanged) return false;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const observedUpdatedAt = safeTimestamp(input.updatedAt, now);
+  const next = {
+    ...existing,
+    title: nextTitle,
+    summary: nextSummary,
+    agentName: nextAgentName,
+    tokens: mergedTokens,
+    targetSessionID: nextTargetSessionID,
+    updatedAt: observedUpdatedAt
+  };
+  state.children[childID] = next;
+  state.updatedAt = observedUpdatedAt;
+  return true;
+}
+function setChildModel(state, sessionID, model, updatedAt) {
+  const matches = Object.values(state.children).filter(
+    (child) => child.id === sessionID || child.targetSessionID === sessionID
+  );
+  if (matches.length === 0) return false;
+  let changed = false;
+  const observedUpdatedAt = safeTimestamp(updatedAt, (/* @__PURE__ */ new Date()).toISOString());
+  for (const child of matches) {
+    const sanitized = sanitizeModel(model);
+    if (JSON.stringify(child.model) === JSON.stringify(sanitized)) continue;
+    state.children[child.id] = { ...child, model: sanitized };
+    changed = true;
+  }
+  if (changed) state.updatedAt = observedUpdatedAt;
+  return changed;
+}
+
+// src/text-width.ts
+var ELLIPSIS = "\u2026";
+function isCombiningCodePoint(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 65056 && codePoint <= 65071;
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 128640 && codePoint <= 128767 || codePoint >= 131072 && codePoint <= 262141);
+}
+function characterWidth(character) {
+  const codePoint = character.codePointAt(0);
+  if (codePoint === void 0) return 0;
+  if (codePoint === 0 || codePoint < 32 || codePoint >= 127 && codePoint < 160) {
+    return 0;
+  }
+  if (codePoint === 8205 || isCombiningCodePoint(codePoint)) return 0;
+  return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function textColumns(value) {
+  let columns = 0;
+  for (const character of value) columns += characterWidth(character);
+  return columns;
+}
+function takeColumns(value, maxColumns) {
+  if (maxColumns <= 0) return "";
+  let columns = 0;
+  let result = "";
+  for (const character of value) {
+    const width = characterWidth(character);
+    if (columns + width > maxColumns) break;
+    columns += width;
+    result += character;
+  }
+  return result;
+}
+function truncateToColumns(value, maxColumns) {
+  if (maxColumns <= 0) return "";
+  if (textColumns(value) <= maxColumns) return value;
+  if (maxColumns <= textColumns(ELLIPSIS)) return ELLIPSIS;
+  const prefix = takeColumns(
+    value,
+    maxColumns - textColumns(ELLIPSIS)
+  ).trimEnd();
+  return `${prefix}${ELLIPSIS}`;
+}
+
+// src/i18n.ts
+var translations = {
+  es: {
+    subagents: "Subagentes",
+    interrupted: "Interrumpido",
+    stale: "El estado puede estar desactualizado",
+    usage: "Uso de entrada + salida",
+    unavailable: "Lista de subagentes no disponible"
+  },
+  en: {
+    subagents: "Subagents",
+    interrupted: "Interrupted",
+    stale: "Status may be stale",
+    usage: "Input + output usage",
+    unavailable: "Subagent list unavailable"
+  }
+};
+var _cachedLocale = null;
+function detectSystemLocale() {
+  const envLang = process.env.LANG ?? process.env.LC_ALL ?? process.env.LANGUAGE ?? Intl.DateTimeFormat().resolvedOptions().locale;
+  const lang = envLang.toLowerCase();
+  if (lang.startsWith("es")) return "es";
+  return "en";
+}
+function getLocale() {
+  if (_cachedLocale === null) {
+    _cachedLocale = detectSystemLocale();
+  }
+  return _cachedLocale;
+}
+function t(key) {
+  const locale = getLocale();
+  const translation = translations[locale][key];
+  if (translation === void 0) {
+    const fallback = translations.en[key];
+    if (fallback === void 0) {
+      throw new Error(`Missing translation key: ${key}`);
+    }
+    return fallback;
+  }
+  return translation;
+}
+
+// src/reconcile.ts
+var DEFAULT_STALE_RUNNING_THRESHOLD_MS = 10 * 60 * 6e4;
+function nextBackoffState(input) {
+  const nextBackoffMs = input.cache ? Math.min(
+    input.maxBackoffMs,
+    Math.max(input.initialBackoffMs, input.cache.backoffMs * 2)
+  ) : input.initialBackoffMs;
+  return {
+    backoffMs: nextBackoffMs,
+    nextAllowedAtMs: input.nowMs + nextBackoffMs
+  };
+}
+
+// src/tui-v2-state.ts
+function tokens(usage) {
+  const finite = (value) => Number.isFinite(value) && value >= 0 ? value : void 0;
+  const input = finite(usage.input);
+  const output = finite(usage.output);
+  if (input === void 0 && output === void 0) return void 0;
+  const total = (input ?? 0) + (output ?? 0);
+  return { input, output, total: Number.isFinite(total) ? total : void 0 };
+}
+var iso = (at) => new Date(at).toISOString();
+function createV2Monitor(input) {
+  const current = createEmptyState();
+  const tracked = /* @__PURE__ */ new Map();
+  let disposed = false;
+  let epoch = 0;
+  let revision = 0;
+  let parentID;
+  let failed = false;
+  let failureRevision = 0;
+  let retries = 0;
+  let backoff;
+  let retryTimer;
+  let hintTimer;
+  let flight;
+  let reconnectFlight;
+  let detailsInFlight = 0;
+  let inventoriesInFlight = 0;
+  const detailQueue = [];
+  function record(id) {
+    let item = tracked.get(id);
+    if (!item) {
+      item = { revision: 0, executionRevision: 0, generation: 0 };
+      tracked.set(id, item);
+    }
+    return item;
+  }
+  const stale = () => failed || [...tracked.values()].some((item) => !item.deleted && !item.retired && (item.execution?.shutdown || item.needsRefresh));
+  function forgetRetired() {
+    if (inventoriesInFlight || detailsInFlight || detailQueue.length) return;
+    for (const [id, item] of tracked) if (item.retired) tracked.delete(id);
+  }
+  function publish() {
+    if (disposed) return;
+    const priorIDs = Object.keys(current.children);
+    refreshDerivedFields(current);
+    for (const id of priorIDs) {
+      const item = tracked.get(id);
+      if (item && !current.children[id]) item.retired = true;
+    }
+    forgetRetired();
+    input.onChange(structuredClone(current));
+  }
+  function clearTimers() {
+    clearTimeout(retryTimer);
+    retryTimer = void 0;
+    clearTimeout(hintTimer);
+    hintTimer = void 0;
+  }
+  function scheduleRetry() {
+    if (disposed || retryTimer || retries >= V2_RETRY_MAX_ATTEMPTS) return;
+    backoff = nextBackoffState({ cache: backoff, nowMs: Date.now(), initialBackoffMs: V2_RETRY_INITIAL_DELAY_MS, maxBackoffMs: V2_RETRY_MAX_DELAY_MS });
+    retryTimer = setTimeout(() => {
+      retryTimer = void 0;
+      retries++;
+      void refresh(parentID);
+    }, backoff.backoffMs);
+  }
+  function issue() {
+    if (disposed) return;
+    failureRevision++;
+    failed = true;
+    input.onIssue("refresh-failed");
+    publish();
+    scheduleRetry();
+  }
+  async function detail(id, valid) {
+    if (!valid()) return void 0;
+    if (detailsInFlight >= V2_DETAIL_CONCURRENCY) {
+      if (!await new Promise((resolve) => detailQueue.push(resolve))) return void 0;
+    } else {
+      detailsInFlight++;
+    }
+    try {
+      if (!valid()) return void 0;
+      const info = await input.session.get({ sessionID: id });
+      return valid() ? info : void 0;
+    } finally {
+      const next = detailQueue.shift();
+      if (next) next(true);
+      else detailsInFlight--;
+      forgetRetired();
+    }
+  }
+  function applyExecution(id, item) {
+    const execution = item.execution;
+    const row = current.children[id];
+    if (!row || !execution) return;
+    if (execution.status === "running") {
+      current.children[id] = {
+        ...row,
+        status: "running",
+        color: "yellow",
+        endedAt: void 0,
+        elapsedMs: void 0,
+        updatedAt: iso(execution.at)
+      };
+    } else {
+      markChildStatus(current, id, execution.status, iso(execution.at));
+    }
+  }
+  function applyMetadata(info, item, readRevision) {
+    const row = current.children[info.id];
+    if (!row) return;
+    const assistant = input.cache.message.list(info.id).filter((message) => message.type === "assistant").sort((a, b) => b.time.created - a.time.created)[0];
+    const reconcile = (observed, value) => readRevision !== void 0 && (!observed || observed.revision <= readRevision) ? { revision: readRevision, value } : observed;
+    item.title = reconcile(item.title, info.title);
+    item.agent = reconcile(item.agent, info.agent);
+    item.model = reconcile(item.model, info.model);
+    item.usage = reconcile(item.usage, tokens(info.tokens));
+    if (readRevision !== void 0 && Math.max(item.revision, item.metadataHintRevision ?? 0) <= readRevision) {
+      item.metadataPending = false;
+    }
+    const model = item.model ? item.model.value : info.model ?? assistant?.model;
+    upsertChildDetails(current, info.id, {
+      title: item.title ? item.title.value : info.title,
+      agentName: item.agent ? item.agent.value : info.agent ?? assistant?.agent,
+      updatedAt: row.updatedAt
+    });
+    setChildModel(current, info.id, model ? {
+      providerID: model.providerID,
+      modelID: model.id,
+      variant: model.variant
+    } : void 0);
+    current.children[info.id].tokens = item.usage ? item.usage.value : tokens(info.tokens);
+  }
+  function hydrate(info, active, readRevision, metadataReadRevision) {
+    if (!info.parentID) return;
+    if (!tracked.has(info.id) && !active && !(info.outcome && info.time.idle !== void 0)) return;
+    const item = record(info.id);
+    if (item.deleted || (active ? item.executionRevision : item.revision) > readRevision) return;
+    const idle = info.time.idle;
+    if (active) {
+      if (item.execution?.status !== "running") item.execution = { status: "running", at: Date.now() };
+      item.needsRefresh = false;
+    } else if (info.outcome && idle !== void 0 && Number.isFinite(idle) && idle >= info.time.created && (!item.execution || (item.execution.shutdown ? idle > item.execution.at : idle >= item.execution.at))) {
+      item.execution = {
+        status: info.outcome === "succeeded" ? "done" : "error",
+        at: idle,
+        interrupted: info.outcome === "interrupted",
+        hydrated: true
+      };
+      item.needsRefresh = false;
+    }
+    if (active && item.revision > readRevision && current.children[info.id]) {
+      applyExecution(info.id, item);
+    } else {
+      insert(info, item, metadataReadRevision);
+    }
+  }
+  function insert(info, item, metadataReadRevision) {
+    if (!info.parentID || item.deleted || !item.execution) return;
+    item.retired = false;
+    upsertRunningChild(current, {
+      id: info.id,
+      parentID: info.parentID,
+      title: info.title ?? info.id,
+      source: "session",
+      targetSessionID: info.id,
+      startedAt: iso(info.time.created),
+      updatedAt: iso(item.execution.at)
+    });
+    applyMetadata(info, item, metadataReadRevision);
+    applyExecution(info.id, item);
+  }
+  async function readInventory(readEpoch) {
+    const valid = () => !disposed && epoch === readEpoch;
+    const readRevision = revision;
+    const readFailureRevision = failureRevision;
+    const selectedParent = parentID;
+    let readFailed = false;
+    const activeIDs = /* @__PURE__ */ new Set();
+    const activeRead = (async () => {
+      try {
+        const activity = await input.session.active();
+        if (!valid()) return;
+        Object.keys(activity).forEach((id) => activeIDs.add(id));
+        const ids = [.../* @__PURE__ */ new Set([...activeIDs, ...[...tracked].filter(([id, item]) => !item.deleted && !item.retired && item.execution && (!current.children[id] || !selectedParent && item.metadataPending)).map(([id]) => id)])];
+        let offset = 0;
+        await Promise.all(Array.from({ length: Math.min(V2_DETAIL_CONCURRENCY, ids.length) }, async () => {
+          while (offset < ids.length && valid()) {
+            const id = ids[offset++];
+            const unchanged = () => {
+              const item = tracked.get(id);
+              const changedAt = activeIDs.has(id) ? item?.executionRevision : item?.revision;
+              return valid() && (changedAt ?? 0) <= readRevision && !item?.deleted;
+            };
+            if (!unchanged()) continue;
+            try {
+              const cached = tracked.get(id)?.metadataPending ? void 0 : input.cache.get(id);
+              const info = cached ?? await detail(id, unchanged);
+              if (info && unchanged()) {
+                hydrate(info, activeIDs.has(id), readRevision, cached ? void 0 : readRevision);
+                publish();
+              }
+            } catch {
+              if (unchanged()) readFailed = true;
+            }
+          }
+        }));
+      } catch {
+        if (valid()) readFailed = true;
+      }
+    })();
+    const historyRead = (async () => {
+      try {
+        if (!selectedParent) {
+          for (const info of input.cache.list()) hydrate(info, activeIDs.has(info.id), readRevision);
+          return;
+        }
+        let cursor;
+        const cursors = /* @__PURE__ */ new Set();
+        do {
+          const page = await input.session.list({ parentID: selectedParent, limit: V2_HISTORY_PAGE_SIZE, cursor });
+          if (!valid()) return;
+          for (const info of page.data) {
+            if (info.parentID === selectedParent) hydrate(info, activeIDs.has(info.id), readRevision, readRevision);
+          }
+          publish();
+          cursor = page.cursor.next ?? void 0;
+          if (cursor && cursors.has(cursor)) {
+            readFailed = true;
+            break;
+          }
+          if (cursor) cursors.add(cursor);
+        } while (cursor && valid());
+      } catch {
+        if (valid()) readFailed = true;
+      }
+    })();
+    await Promise.all([activeRead, historyRead]);
+    if (!valid()) return;
+    if (readFailed) issue();
+    else if (failureRevision === readFailureRevision) {
+      failed = false;
+      retries = 0;
+      backoff = void 0;
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      publish();
+    }
+    if ([...tracked.values()].some((item) => !item.deleted && !item.retired && item.metadataPending && Math.max(item.revision, item.metadataHintRevision ?? 0) > readRevision)) requestHint();
+  }
+  function refresh(selectedParent) {
+    if (disposed) return Promise.resolve();
+    if (selectedParent !== parentID) {
+      parentID = selectedParent;
+      epoch++;
+      clearTimers();
+      retries = 0;
+      backoff = void 0;
+    }
+    if (flight?.epoch === epoch) return flight.promise;
+    const readEpoch = epoch;
+    inventoriesInFlight++;
+    const promise = readInventory(readEpoch).finally(() => {
+      inventoriesInFlight--;
+      forgetRetired();
+      if (flight?.promise === promise) flight = void 0;
+    });
+    flight = { epoch: readEpoch, promise };
+    return promise;
+  }
+  function requestHint() {
+    if (disposed || hintTimer || retryTimer) return;
+    hintTimer = setTimeout(() => {
+      hintTimer = void 0;
+      void refresh(parentID);
+    }, 1e3);
+  }
+  async function accept(event) {
+    if (disposed) return;
+    switch (event.type) {
+      case "session.status":
+      case "session.idle":
+      case "session.step.ended":
+      case "session.step.failed":
+      case "session.tool.success":
+      case "session.tool.failed":
+      case "session.retry.scheduled": {
+        const item2 = tracked.get(event.data.sessionID);
+        if (item2 && !item2.deleted && !item2.retired) {
+          item2.metadataPending = true;
+          item2.metadataHintRevision = ++revision;
+        }
+        requestHint();
+        return;
+      }
+      case "session.created":
+      case "session.execution.started":
+      case "session.execution.succeeded":
+      case "session.execution.failed":
+      case "session.execution.interrupted":
+      case "session.deleted":
+      case "session.renamed":
+      case "session.agent.selected":
+      case "session.model.selected":
+      case "session.usage.updated":
+        break;
+      default:
+        return;
+    }
+    const id = event.data.sessionID;
+    const item = record(id);
+    if (item.deleted) return;
+    if ("durable" in event) {
+      if (item.seq !== void 0 && event.durable.seq <= item.seq) return;
+      item.seq = event.durable.seq;
+    } else if (item.usageCreated !== void 0 && event.created <= item.usageCreated) return;
+    if (event.type.startsWith("session.execution.") && item.execution?.hydrated && event.created < item.execution.at) return;
+    item.retired = false;
+    const metadataReadRevision = revision;
+    item.revision = ++revision;
+    if (event.type.startsWith("session.execution.") || event.type === "session.deleted") {
+      item.executionRevision = item.revision;
+    }
+    const generation = ++item.generation;
+    const readEpoch = epoch;
+    const valid = () => !disposed && epoch === readEpoch && !item.deleted && item.generation === generation;
+    switch (event.type) {
+      case "session.deleted":
+        item.deleted = true;
+        item.execution = void 0;
+        delete item.title;
+        delete item.agent;
+        delete item.model;
+        delete item.usage;
+        delete item.usageCreated;
+        delete item.needsRefresh;
+        delete item.metadataPending;
+        delete item.metadataHintRevision;
+        delete current.children[id];
+        input.cache.invalidate(id);
+        publish();
+        return;
+      case "session.execution.started":
+        item.execution = { status: "running", at: event.created };
+        item.needsRefresh = false;
+        break;
+      case "session.execution.succeeded":
+      case "session.execution.failed":
+        item.execution = { status: event.type === "session.execution.succeeded" ? "done" : "error", at: event.created };
+        item.needsRefresh = false;
+        break;
+      case "session.execution.interrupted":
+        item.execution = { status: "error", at: event.created, interrupted: true, shutdown: event.data.reason === "shutdown" };
+        item.needsRefresh = false;
+        break;
+      case "session.renamed":
+        item.title = { revision: item.revision, value: event.data.title };
+        item.metadataPending = true;
+        break;
+      case "session.agent.selected":
+        item.agent = { revision: item.revision, value: event.data.agent };
+        item.metadataPending = true;
+        break;
+      case "session.model.selected":
+        item.model = { revision: item.revision, value: event.data.model };
+        item.metadataPending = true;
+        break;
+      case "session.usage.updated":
+        item.usageCreated = event.created;
+        item.usage = { revision: item.revision, value: tokens(event.data.tokens) };
+        item.metadataPending = true;
+        requestHint();
+        break;
+    }
+    try {
+      if (current.children[id]) {
+        const cached2 = input.cache.get(id);
+        if (cached2) applyMetadata(cached2, item);
+        else {
+          if (event.type === "session.renamed") upsertChildDetails(current, id, { title: event.data.title });
+          if (event.type === "session.agent.selected") upsertChildDetails(current, id, { agentName: event.data.agent });
+          if (event.type === "session.model.selected") setChildModel(current, id, {
+            providerID: event.data.model.providerID,
+            modelID: event.data.model.id,
+            variant: event.data.model.variant
+          });
+          if (event.type === "session.usage.updated") current.children[id].tokens = item.usage?.value;
+        }
+        applyExecution(id, item);
+        publish();
+        return;
+      }
+      const cached = input.cache.get(id);
+      const info = cached ?? await detail(id, valid);
+      if (!valid() || !info) return;
+      if (!info.parentID) {
+        tracked.delete(id);
+        return;
+      }
+      if (!item.execution) hydrate(info, false, item.revision, cached ? void 0 : metadataReadRevision);
+      else insert(info, item, cached ? void 0 : metadataReadRevision);
+      if (!item.execution && !current.children[id]) item.retired = true;
+      publish();
+    } catch {
+      if (valid()) issue();
+    }
+  }
+  function reconnect() {
+    if (disposed) return Promise.resolve();
+    if (reconnectFlight) return reconnectFlight;
+    epoch++;
+    clearTimers();
+    retries = 0;
+    backoff = void 0;
+    failed = true;
+    for (const [id, item] of tracked) {
+      input.cache.invalidate(id);
+      if (!item.deleted && !item.retired && item.execution) item.metadataPending = true;
+      if (item.execution?.status === "running") item.needsRefresh = true;
+    }
+    publish();
+    const promise = refresh(parentID).finally(() => {
+      if (reconnectFlight === promise) reconnectFlight = void 0;
+    });
+    reconnectFlight = promise;
+    return promise;
+  }
+  return {
+    state: () => structuredClone(current),
+    hint: (id) => current.children[id] && tracked.get(id)?.execution?.interrupted ? "interrupted" : void 0,
+    stale,
+    accept,
+    refresh,
+    reconnect,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      epoch++;
+      clearTimers();
+      detailQueue.splice(0).forEach((resolve) => resolve(false));
+      tracked.clear();
+    }
+  };
+}
+
+// src/tui-v2-snapshot.ts
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/render.ts
+var ansi = {
+  reset: "\x1B[0m",
+  gray: "\x1B[90m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m"
+};
+function colorsEnabled() {
+  if (process.env.NO_COLOR) return false;
+  const fromEnv = process.env.OPENCODE_SUBAGENT_STATUSLINE_COLOR;
+  if (fromEnv === "0") return false;
+  return true;
+}
+function paint(text, color, enabled) {
+  if (!enabled) return text;
+  return `${color}${text}${ansi.reset}`;
+}
+function formatDuration(elapsedMs2) {
+  const totalSeconds = Math.max(0, Math.floor((elapsedMs2 ?? 0) / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+  }
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+function formatNumber(value) {
+  return Math.max(0, Math.round(value)).toLocaleString("en-US");
+}
+function resolveTokenTotal(child) {
+  const total = child.tokens?.total;
+  if (typeof total === "number" && Number.isFinite(total)) {
+    return total;
+  }
+  const inTokens = child.tokens?.input;
+  const outTokens = child.tokens?.output;
+  if (typeof inTokens === "number" || typeof outTokens === "number") {
+    return (inTokens ?? 0) + (outTokens ?? 0);
+  }
+  return void 0;
+}
+function formatPercentUsed(percent) {
+  const rounded = Math.round(percent * 10) / 10;
+  if (Math.abs(rounded - Math.round(rounded)) < 0.05) {
+    return `${Math.round(rounded)}% used`;
+  }
+  return `${rounded.toFixed(1)}% used`;
+}
+function formatTokenCount(total) {
+  const label = total === 1 ? "token" : "tokens";
+  return `${formatNumber(total)} ${label}`;
+}
+function formatContextDetails(child) {
+  const total = resolveTokenTotal(child);
+  const percent = child.tokens?.contextPercent;
+  const hasPercent = typeof percent === "number" && Number.isFinite(percent);
+  const hasTotal = typeof total === "number" && Number.isFinite(total);
+  if (hasTotal && hasPercent) {
+    return `${formatTokenCount(total)} \xB7 ${formatPercentUsed(percent)}`;
+  }
+  if (hasTotal) {
+    return formatTokenCount(total);
+  }
+  if (hasPercent) {
+    return formatPercentUsed(percent);
+  }
+  return void 0;
+}
+function formatContext(child) {
+  const details = formatContextDetails(child);
+  if (!details) return "";
+  return `ctx ${details}`;
+}
+function childColor(child) {
+  if (child.color === "green") return ansi.green;
+  if (child.color === "red") return ansi.red;
+  return ansi.yellow;
+}
+function byPriority(a, b) {
+  const startedDiff = b.startedAt.localeCompare(a.startedAt);
+  if (startedDiff !== 0) return startedDiff;
+  return a.id.localeCompare(b.id);
+}
+var RECENT_TERMINAL_VISIBLE_MS = 10 * 60 * 1e3;
+function collapseSubagentWorkItems(children) {
+  return correlateSubagentWorkItems(children).map(
+    ({ real, proxies }) => proxies.reduce(
+      (current, proxy) => mergeProxyMetadataWithRealExecution(current, proxy),
+      real
+    )
+  );
+}
+function isTerminalWorkItem(child) {
+  return child.status === "done" || child.status === "error";
+}
+function isVisibleWorkItem(child, nowMs = Date.now()) {
+  if (!isTerminalWorkItem(child)) return true;
+  const endedMs = Date.parse(child.endedAt ?? child.updatedAt);
+  if (Number.isNaN(endedMs)) return false;
+  return nowMs - endedMs <= RECENT_TERMINAL_VISIBLE_MS;
+}
+function visibleSubagentWorkItems(children, nowMs = Date.now(), options = {}) {
+  const collapsed = collapseSubagentWorkItems(children);
+  if (options.showCompletedHistory) return collapsed;
+  const visible = collapsed.filter((child) => isVisibleWorkItem(child, nowMs));
+  const hasRunning = visible.some((child) => child.status === "running");
+  const activeMessageIDs = new Set(
+    visible.filter((child) => child.status === "running" && child.messageID).map((child) => child.messageID)
+  );
+  if (!hasRunning) return visible;
+  return visible.filter((child) => {
+    if (child.status === "running") return true;
+    if (!child.messageID) return false;
+    return activeMessageIDs.has(child.messageID);
+  });
+}
+function renderStatusLine(state) {
+  const children = visibleSubagentWorkItems(Object.values(state.children)).sort(
+    byPriority
+  );
+  const counts = countRetainedSubagentStatuses({ children: state.children });
+  const totalExecuted = formatNumber(state.totalExecuted ?? 0);
+  const colorOn = colorsEnabled();
+  const aggregate = `\u21B3 ${counts.running} running \xB7 ${counts.done} done \xB7 ${counts.error} error \xB7 \u03A3 ${totalExecuted} total`;
+  if (children.length === 0) return aggregate;
+  const details = children.map((child) => {
+    const context = formatContext(child);
+    const label = [child.title, formatDuration(child.elapsedMs), context].filter((part) => part.length > 0).join(" ");
+    return paint(label, childColor(child), colorOn);
+  }).join(paint(" \xB7 ", ansi.gray, colorOn));
+  return `${aggregate} \xB7 ${details}`;
+}
+
+// src/tui-v2-snapshot.ts
+function resolveV2SnapshotPaths() {
+  const override = process.env.OPENCODE_SUBAGENT_STATUSLINE_STATE;
+  const statePath = override?.trim() ? resolveStatePath() : join2(dirname2(resolveStatePath()), "v2", "state.json");
+  return { statePath, textPath: resolveTextPath(statePath) };
+}
+function createV2SnapshotWriter(input) {
+  let disposed = false;
+  let pending;
+  let inFlight;
+  const options = { shouldCommit: () => !disposed };
+  function drain() {
+    if (inFlight || disposed || !pending) return;
+    inFlight = Promise.resolve().then(async () => {
+      while (!disposed && pending) {
+        const state = pending;
+        pending = void 0;
+        try {
+          await saveState(input.statePath, state, options);
+          if (!disposed) await saveStatusText(input.textPath, renderStatusLine(state), options);
+        } catch {
+          if (!disposed) input.onIssue("snapshot-failed");
+        }
+      }
+    }).finally(() => {
+      inFlight = void 0;
+      drain();
+    });
+  }
+  async function flush() {
+    while (inFlight) await inFlight;
+  }
+  return {
+    enqueue(state) {
+      if (disposed) return;
+      pending = structuredClone(state);
+      drain();
+    },
+    flush,
+    async dispose() {
+      disposed = true;
+      pending = void 0;
+      await flush();
+    }
+  };
+}
+
+// src/tui-v2-focus.ts
+function createV2SidebarFocus(input) {
+  let disposed = false;
+  let generation = 0;
+  let timer;
+  let saved;
+  const live = (target) => Boolean(target && !target.isDestroyed && target.visible);
+  function cancel() {
+    generation++;
+    clearTimeout(timer);
+    timer = void 0;
+  }
+  function release(restore) {
+    cancel();
+    const previous = saved;
+    saved = void 0;
+    input.view.blurList();
+    if (restore && previous && previous.route === input.route() && input.mode() === "base" && live(previous.target)) previous.target.focus();
+  }
+  function transfer(excluded) {
+    const target = input.view.target();
+    if (disposed || input.mode() !== "base" || !live(target)) return false;
+    if (input.view.isListFocused()) return true;
+    const candidate = input.renderer.currentFocusedEditor ?? input.renderer.currentFocusedRenderable;
+    if (!live(candidate) || candidate === target || candidate === excluded) return false;
+    const previous = { target: candidate, route: input.route() };
+    if (!input.view.focusList()) return false;
+    saved = previous;
+    return true;
+  }
+  return {
+    request(source) {
+      if (disposed) return;
+      cancel();
+      if (source === "keyboard") {
+        if (input.mode() === "base") transfer();
+        return;
+      }
+      const target = input.view.target();
+      if (!live(target)) {
+        input.unavailable();
+        return;
+      }
+      const route = input.route(), token = generation;
+      const modalTarget = input.mode() !== "base" ? input.renderer.currentFocusedEditor ?? input.renderer.currentFocusedRenderable : void 0;
+      let attempts = 0;
+      const attempt = () => {
+        timer = void 0;
+        if (disposed || token !== generation || route !== input.route()) return;
+        if (input.view.target() !== target || !live(target)) return;
+        if (transfer(modalTarget)) return;
+        if (++attempts === V2_FOCUS_MAX_ATTEMPTS) {
+          input.unavailable();
+          return;
+        }
+        timer = setTimeout(attempt, V2_FOCUS_RETRY_DELAY_MS);
+      };
+      timer = setTimeout(attempt, V2_FOCUS_RETRY_DELAY_MS);
+    },
+    leave: () => release(true),
+    beforeNavigate: () => release(false),
+    routeChanged: () => release(false),
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      release(true);
+    }
+  };
+}
+
+// src/tui-view.tsx
+import { use as _$use } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createRequire } from "module";
+import { For, Show, createEffect, createMemo, createSignal, onCleanup } from "solid-js";
+
+// src/tui-focus.ts
+function shouldReleaseSidebarListFocus(input) {
+  return input.listFocusModeActive && (input.previousRunningCount ?? 0) > 0 && input.runningCount === 0;
+}
+
+// src/tui-view.tsx
+var FALLBACK_SIDEBAR_WIDTH = 34;
+var MIN_ROW_WIDTH = 24;
+var MIN_LABEL_WIDTH = 8;
+var CLOCK_ICON = "\uF017";
+var TOKEN_ICON = "\uF51E";
+var SIDEBAR_ARROW_EXPANDED = "\u25BC";
+var SIDEBAR_ARROW_COLLAPSED = "\u25B6";
+var SUBAGENTS_MAX_VISIBLE_ROWS = 5;
+var SUBAGENTS_RUNNING_ROW_HEIGHT = 3;
+var SUBAGENTS_TERMINAL_ROW_HEIGHT = 2;
+var SUBAGENTS_MODEL_ROW_HEIGHT = 1;
+var SUBAGENTS_ROW_GAP = 0;
+var SUBAGENTS_ROW_MARKER_WIDTH = 4;
+var SUBAGENTS_MAX_LIST_HEIGHT = SUBAGENTS_MAX_VISIBLE_ROWS * (SUBAGENTS_RUNNING_ROW_HEIGHT + SUBAGENTS_MODEL_ROW_HEIGHT) + (SUBAGENTS_MAX_VISIBLE_ROWS - 1) * SUBAGENTS_ROW_GAP;
+var INACTIVE_SUBAGENT_OPACITY = 0.65;
+var packageRequire = createRequire(import.meta.url);
+function readPluginVersion() {
+  try {
+    const metadata = packageRequire("../package.json");
+    return typeof metadata.version === "string" && metadata.version.length > 0 ? metadata.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var PLUGIN_VERSION = readPluginVersion();
+var SIDEBAR_SCROLL_RESTORE_FRAME_BUDGET = 2;
+var registerSidebar = /* @__PURE__ */ Symbol("registerSidebar");
+function createSidebarViewController() {
+  const sidebarScrollRegistrations = /* @__PURE__ */ new Set();
+  const sidebarListFocusRegistrations = /* @__PURE__ */ new Set();
+  const sidebarCompletedHistoryRegistrations = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const controller = {
+    [registerSidebar]({
+      scroll,
+      focus,
+      history
+    }) {
+      if (disposed) return () => {
+      };
+      sidebarScrollRegistrations.add(scroll);
+      sidebarListFocusRegistrations.add(focus);
+      sidebarCompletedHistoryRegistrations.add(history);
+      return () => {
+        sidebarScrollRegistrations.delete(scroll);
+        sidebarListFocusRegistrations.delete(focus);
+        sidebarCompletedHistoryRegistrations.delete(history);
+      };
+    },
+    snapshotScroll() {
+      for (const registration of sidebarScrollRegistrations) {
+        const scrollbox = registration.getScrollbox();
+        if (!scrollbox) continue;
+        registration.offsetTop = clampedScrollTop(scrollbox, scrollbox.scrollTop);
+        registration.anchor = registration.getAnchor();
+        registration.restoreFramesRemaining = SIDEBAR_SCROLL_RESTORE_FRAME_BUDGET;
+      }
+    },
+    focusList(preferredChildID) {
+      for (const registration of [...sidebarListFocusRegistrations].reverse()) {
+        if (registration.focusList(preferredChildID)) return true;
+      }
+      return false;
+    },
+    blurList() {
+      for (const registration of [...sidebarListFocusRegistrations].reverse()) {
+        if (registration.blurList()) return true;
+      }
+      return false;
+    },
+    isListFocused() {
+      return [...sidebarListFocusRegistrations].some((registration) => registration.isListFocusModeActive());
+    },
+    toggleCompletedHistory() {
+      for (const registration of [...sidebarCompletedHistoryRegistrations].reverse()) {
+        if (registration.toggleCompletedHistory()) return true;
+      }
+      return false;
+    },
+    target() {
+      for (const registration of [...sidebarListFocusRegistrations].reverse()) {
+        const target = registration.target();
+        if (target) return target;
+      }
+      return void 0;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const registration of sidebarListFocusRegistrations) registration.blurList();
+      sidebarScrollRegistrations.clear();
+      sidebarListFocusRegistrations.clear();
+      sidebarCompletedHistoryRegistrations.clear();
+    }
+  };
+  return controller;
+}
+function maxScrollTop(scrollbox) {
+  return Math.max(0, scrollbox.scrollHeight - scrollbox.viewport.height);
+}
+function clampedScrollTop(scrollbox, value) {
+  return Math.max(0, Math.min(value, maxScrollTop(scrollbox)));
+}
+function resolveSidebarAnchorScrollTop(input) {
+  if (!input.expanded || !input.anchor || input.anchor.childIDs.length === 0) {
+    return {
+      matched: false
+    };
+  }
+  let top = input.leadingHeight;
+  const rowTops = /* @__PURE__ */ new Map();
+  for (const row of input.rows) {
+    rowTops.set(row.id, top);
+    top += row.height + SUBAGENTS_ROW_GAP;
+  }
+  for (const [index, childID] of input.anchor.childIDs.entries()) {
+    const rowTop = rowTops.get(childID);
+    if (rowTop === void 0) continue;
+    const desiredTop = rowTop + (index === 0 ? input.anchor.intraRowOffset : 0);
+    const maxTop = Math.max(0, input.scrollHeight - input.viewportHeight);
+    const nextTop = Math.max(0, Math.min(desiredTop, maxTop));
+    return {
+      matched: true,
+      offsetTop: nextTop,
+      scrollTop: input.scrollTop !== nextTop ? nextTop : void 0
+    };
+  }
+  return {
+    matched: false
+  };
+}
+function preservedSidebarScrollTop(input) {
+  if (!input.expanded) return void 0;
+  const anchorTop = resolveSidebarAnchorScrollTop({
+    expanded: input.expanded,
+    anchor: input.anchor,
+    rows: input.rows ?? [],
+    leadingHeight: input.leadingHeight ?? 0,
+    scrollTop: input.scrollTop,
+    scrollHeight: input.scrollHeight,
+    viewportHeight: input.viewportHeight
+  });
+  if (anchorTop.matched) return anchorTop.scrollTop;
+  const maxTop = Math.max(0, input.scrollHeight - input.viewportHeight);
+  const top = Math.max(0, Math.min(input.offsetTop, maxTop));
+  return top > 0 && input.scrollTop !== top ? top : void 0;
+}
+function elapsedMs(child, nowMs) {
+  if (child.status !== "running") {
+    return child.elapsedMs ?? 0;
+  }
+  const started = Date.parse(child.startedAt);
+  if (Number.isNaN(started)) return child.elapsedMs ?? 0;
+  return Math.max(0, nowMs - started);
+}
+function taskStatusMarker(status) {
+  if (status === "done") return "[\u2713]";
+  if (status === "error") return "[x]";
+  return "[ ]";
+}
+function statusColor2(status, theme) {
+  if (status === "done") return theme.success;
+  if (status === "error") return theme.error;
+  return theme.warning;
+}
+function isSessionTarget(value) {
+  return typeof value === "string" && value.startsWith("ses_");
+}
+function resolveChildTargetSessionID(child) {
+  if (isSessionTarget(child.targetSessionID)) {
+    return child.targetSessionID;
+  }
+  if (child.id.startsWith("ses_")) {
+    return child.id;
+  }
+  return void 0;
+}
+function resolveSyntheticTargetFromHydratedState(state, synthetic) {
+  const messageMatches = Object.values(state.children).filter((candidate) => candidate.id.startsWith("ses_") && candidate.parentID === synthetic.parentID && synthetic.messageID && candidate.messageID === synthetic.messageID);
+  if (messageMatches.length === 1) return messageMatches[0].id;
+  const parentMatches = Object.values(state.children).filter((candidate) => candidate.id.startsWith("ses_") && candidate.parentID === synthetic.parentID);
+  if (parentMatches.length === 1) return parentMatches[0].id;
+  return void 0;
+}
+function ellipsize(value, maxColumns) {
+  return truncateToColumns(value, maxColumns);
+}
+function splitParentheticalTitle(title) {
+  const match = title.match(/^(.*?)\s*(\([^)]*\))\s*$/);
+  if (!match) return {
+    label: title
+  };
+  const label = match[1]?.trim();
+  const parenthetical = match[2]?.trim();
+  if (!label || !parenthetical) return {
+    label: title
+  };
+  return {
+    label,
+    parenthetical
+  };
+}
+function childParenthetical(child) {
+  if (child.agentName?.trim()) return `(${child.agentName.trim()})`;
+  const primary = splitParentheticalTitle(childPrimaryText(child));
+  if (primary.parenthetical) return primary.parenthetical;
+  return splitParentheticalTitle(child.title).parenthetical;
+}
+function formatSecondaryLine(continuation, parenthetical, width) {
+  if (!continuation) return parenthetical;
+  if (!parenthetical) return continuation;
+  const parentheticalWidth = Math.min(textColumns(parenthetical), width);
+  const continuationWidth = width - parentheticalWidth - 1;
+  if (continuationWidth >= MIN_LABEL_WIDTH) {
+    return `${ellipsize(continuation, continuationWidth)} ${ellipsize(parenthetical, parentheticalWidth)}`;
+  }
+  return ellipsize(parenthetical, width);
+}
+function childPrimaryText(child) {
+  return child.summary?.trim() || child.title;
+}
+function resolveTokenTotal2(child) {
+  const total = child.tokens?.total;
+  if (typeof total === "number" && Number.isFinite(total)) {
+    return total;
+  }
+  const input = child.tokens?.input;
+  const output = child.tokens?.output;
+  if (typeof input === "number" || typeof output === "number") {
+    return Math.max(0, (input ?? 0) + (output ?? 0));
+  }
+  return void 0;
+}
+function formatCompactTokenCount(total) {
+  const value = Math.max(0, total);
+  if (value >= 1e6) return `${(value / 1e6).toFixed(1)}M ctx`;
+  if (value >= 1e3) return `${(value / 1e3).toFixed(1)}k ctx`;
+  return `${Math.round(value)} ctx`;
+}
+function formatCompactPercent(percent) {
+  return `${Math.max(0, Math.round(percent))}%`;
+}
+function contextVariants(child, usageLabel) {
+  const total = resolveTokenTotal2(child);
+  const percent = usageLabel ? void 0 : child.tokens?.contextPercent;
+  const hasTotal = typeof total === "number" && Number.isFinite(total);
+  const hasPercent = typeof percent === "number" && Number.isFinite(percent);
+  if (!hasTotal && !hasPercent) return [""];
+  const formattedTokens = hasTotal ? formatCompactTokenCount(total) : "";
+  const tokenPart = usageLabel ? formattedTokens.replace(/ ctx$/, "") : formattedTokens;
+  const percentPart = hasPercent ? formatCompactPercent(percent) : "";
+  if (tokenPart && percentPart) {
+    return [`${tokenPart} ${percentPart}`, percentPart, tokenPart, ""];
+  }
+  return [tokenPart || percentPart, ""];
+}
+function rowWidthBudget(sidebarWidth) {
+  const width = sidebarWidth ?? FALLBACK_SIDEBAR_WIDTH;
+  const innerWidth = width - 4;
+  return Math.max(MIN_ROW_WIDTH, Math.min(innerWidth, 52));
+}
+function wrapCompactText(value, width, maxLines) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) return [""];
+  const lines = [];
+  let remaining = normalized;
+  while (textColumns(remaining) > width && lines.length < maxLines - 1) {
+    const probe = takeColumns(remaining, width + 1);
+    const breakAt = probe.lastIndexOf(" ");
+    const breakPrefix = breakAt >= 0 ? probe.slice(0, breakAt) : "";
+    const fit = takeColumns(remaining, width);
+    const take = breakAt >= 0 && textColumns(breakPrefix) >= MIN_LABEL_WIDTH && textColumns(breakPrefix) <= width ? breakAt : fit.length;
+    if (take <= 0) break;
+    lines.push(remaining.slice(0, take).trimEnd());
+    remaining = remaining.slice(take).trimStart();
+  }
+  lines.push(lines.length === maxLines - 1 ? ellipsize(remaining, Math.max(1, width)) : remaining);
+  return lines;
+}
+function formatChildRowLine(input) {
+  const elapsed = formatDuration(elapsedMs(input.child, input.nowMs));
+  const width = Math.max(MIN_ROW_WIDTH, rowWidthBudget(input.sidebarWidth) - (input.reservedWidth ?? 0));
+  const title = splitParentheticalTitle(childPrimaryText(input.child));
+  const parenthetical = childParenthetical(input.child);
+  for (const meta of contextVariants(input.child, input.usageLabel)) {
+    const detailChars = 2 + textColumns(elapsed) + (meta ? 3 + textColumns(meta) : 0);
+    const labelBudget = Math.min(width - 2, width - Math.max(0, detailChars - width));
+    if (labelBudget >= MIN_LABEL_WIDTH || textColumns(meta) === 0) {
+      const labelLines2 = wrapCompactText(title.label, Math.max(1, labelBudget), 2);
+      return {
+        labelLines: labelLines2,
+        secondaryLine: formatSecondaryLine(labelLines2[1], parenthetical, Math.max(1, labelBudget)),
+        elapsed,
+        meta
+      };
+    }
+  }
+  const labelLines = wrapCompactText(title.label, MIN_LABEL_WIDTH, 2);
+  return {
+    labelLines,
+    secondaryLine: formatSecondaryLine(labelLines[1], parenthetical, MIN_LABEL_WIDTH),
+    elapsed,
+    meta: ""
+  };
+}
+function formatTerminalChildRowLine(input) {
+  const elapsed = formatDuration(elapsedMs(input.child, input.nowMs));
+  const width = Math.max(MIN_ROW_WIDTH, rowWidthBudget(input.sidebarWidth));
+  const title = splitParentheticalTitle(childPrimaryText(input.child));
+  const parenthetical = childParenthetical(input.child);
+  const labelSource = parenthetical ? `${title.label} ${parenthetical}` : title.label;
+  const context = contextVariants(input.child, input.usageLabel).find((variant) => variant.length > 0);
+  return {
+    label: ellipsize(labelSource, Math.max(1, width - (input.reservedWidth ?? 0))),
+    meta: context ? `${elapsed} ${context}` : elapsed
+  };
+}
+function subagentRowHeight(input) {
+  const hintHeight = input.childHint ? 1 : 0;
+  const modelHeight = input.child.model?.variant ? SUBAGENTS_MODEL_ROW_HEIGHT : 0;
+  if (input.child.status !== "running") {
+    return SUBAGENTS_TERMINAL_ROW_HEIGHT + modelHeight + hintHeight;
+  }
+  const line = formatChildRowLine(input);
+  return (line.secondaryLine ? SUBAGENTS_RUNNING_ROW_HEIGHT : SUBAGENTS_RUNNING_ROW_HEIGHT - 1) + modelHeight + hintHeight;
+}
+function resolveTuiSubagentSnapshot(input) {
+  const allChildren = Object.values(input.state.children);
+  const options = {
+    showCompletedHistory: input.showCompletedHistory
+  };
+  const nowMs = input.nowMs ?? Date.now();
+  const ownChildren = input.sessionID ? allChildren.filter((child) => child.parentID === input.sessionID) : allChildren;
+  const ownVisibleChildren = visibleSubagentWorkItems(ownChildren, nowMs, options).sort(byPriority);
+  const totalExecuted = input.sessionID ? countCountedSubagentExecutions({
+    children: allChildren,
+    countedChildIDs: input.state.countedChildIDs,
+    parentSessionID: input.sessionID
+  }) : countHistoricalSubagentExecutions({
+    children: allChildren
+  });
+  return {
+    visibleChildren: ownVisibleChildren,
+    visibleCounts: countRetainedSubagentStatuses({
+      children: allChildren,
+      parentSessionID: input.sessionID
+    }),
+    totalExecuted,
+    showingOtherSessions: false
+  };
+}
+function resolveSidebarSubagentSnapshot(input) {
+  return resolveTuiSubagentSnapshot(input);
+}
+function SidebarSubagents(props) {
+  const [showCompletedHistory, setShowCompletedHistory] = createSignal(props.restoreFromChild?.showCompletedHistory ?? false);
+  const completedHistoryOptions = () => ({
+    showCompletedHistory: showCompletedHistory()
+  });
+  const snapshot = createMemo(() => resolveSidebarSubagentSnapshot({
+    state: props.state(),
+    sessionID: props.sessionID,
+    nowMs: props.nowMs(),
+    ...completedHistoryOptions()
+  }));
+  const visibleChildren = createMemo(() => snapshot().visibleChildren);
+  const counts = createMemo(() => snapshot().visibleCounts);
+  const totalExecuted = createMemo(() => snapshot().totalExecuted);
+  const visibleChildIDs = createMemo(() => visibleChildren().map((child) => child.id));
+  const [selectedChildID, setSelectedChildID] = createSignal(props.restoreFromChild?.childRowID);
+  let restoreChildRowID = props.restoreFromChild?.childRowID;
+  const [mouseDownChildID, setMouseDownChildID] = createSignal();
+  const [listFocused, setListFocused] = createSignal(false);
+  const [listFocusModeActive, setListFocusModeActive] = createSignal(false);
+  const visibleChildLayoutSignature = createMemo(() => visibleChildren().map((child) => JSON.stringify([child.id, child.status, child.title, child.summary ?? "", child.agentName ?? "", child.tokens?.input ?? "", child.tokens?.output ?? "", child.tokens?.total ?? "", child.tokens?.contextPercent ?? "", child.model?.providerID ?? "", child.model?.modelID ?? "", child.model?.variant ?? "", props.childHint?.(child.id) ?? ""])).join("|"));
+  const listHeight = createMemo(() => {
+    const nowMs = props.nowMs();
+    const sidebarWidth = props.sidebarWidth?.();
+    const contentHeight = visibleChildren().reduce((height, child) => height + subagentRowHeight({
+      child,
+      nowMs,
+      sidebarWidth,
+      reservedWidth: SUBAGENTS_ROW_MARKER_WIDTH,
+      usageLabel: props.usageLabel,
+      childHint: props.childHint?.(child.id)
+    }), 0) + Math.max(0, visibleChildren().length - 1) * SUBAGENTS_ROW_GAP;
+    return Math.max(1, Math.min(SUBAGENTS_MAX_LIST_HEIGHT, contentHeight));
+  });
+  let listContainer;
+  let scrollbox;
+  const scrollRegistration = {
+    getScrollbox: () => scrollbox,
+    getAnchor: () => currentSidebarScrollAnchor(),
+    getRows: () => rowLayouts(),
+    getLeadingHeight: () => 0,
+    offsetTop: 0,
+    restoreFramesRemaining: 0
+  };
+  const focusRegistration = {
+    target: () => props.strictInput && visibleChildIDs().length === 0 ? void 0 : listContainer,
+    focusList: (preferredChildID) => {
+      if (!listContainer || props.strictInput && (listContainer.isDestroyed || !listContainer.visible || visibleChildIDs().length === 0)) return false;
+      const ids = visibleChildIDs();
+      if (preferredChildID && ids.includes(preferredChildID)) {
+        setSelectedChildID(preferredChildID);
+      } else if (!selectedChildID() && ids[0]) {
+        setSelectedChildID(ids[0]);
+      }
+      listContainer.focus();
+      setListFocused(true);
+      setListFocusModeActive(true);
+      return true;
+    },
+    blurList: () => {
+      if (!listFocused() && !listFocusModeActive()) return false;
+      listContainer?.blur();
+      setListFocused(false);
+      setListFocusModeActive(false);
+      return true;
+    },
+    isListFocusModeActive: () => listFocusModeActive()
+  };
+  let previousRunningCount;
+  createEffect(() => {
+    const runningCount = counts().running;
+    const shouldReleaseFocus = shouldReleaseSidebarListFocus({
+      previousRunningCount,
+      runningCount,
+      listFocusModeActive: listFocusModeActive()
+    });
+    previousRunningCount = runningCount;
+    if (!shouldReleaseFocus) return;
+    focusRegistration.blurList();
+    props.onReturnFocus();
+  });
+  const completedHistoryRegistration = {
+    toggleCompletedHistory: () => {
+      setShowCompletedHistory((current) => !current);
+      return true;
+    }
+  };
+  onCleanup(props.controller[registerSidebar]({
+    scroll: scrollRegistration,
+    focus: focusRegistration,
+    history: completedHistoryRegistration
+  }));
+  createEffect(() => {
+    const ids = visibleChildIDs();
+    const current = selectedChildID();
+    if (ids.length === 0) {
+      if (current) setSelectedChildID(void 0);
+      return;
+    }
+    if (!current || !ids.includes(current)) setSelectedChildID(ids[0]);
+  });
+  const refreshListFocused = () => {
+    if (listFocused() && !listContainer) {
+      setListFocused(false);
+      return;
+    }
+    const focused = Boolean(listContainer?.focused || listContainer?.hasFocusedDescendant);
+    if (!focused && listFocused()) setListFocused(false);
+  };
+  const rowTopForIndex = (index) => {
+    let top = 0;
+    const nowMs = props.nowMs();
+    const sidebarWidth = props.sidebarWidth?.();
+    for (let i = 0; i < index; i += 1) {
+      const child = visibleChildren()[i];
+      if (child) {
+        top += subagentRowHeight({
+          child,
+          nowMs,
+          sidebarWidth,
+          reservedWidth: SUBAGENTS_ROW_MARKER_WIDTH,
+          usageLabel: props.usageLabel,
+          childHint: props.childHint?.(child.id)
+        }) + SUBAGENTS_ROW_GAP;
+      }
+    }
+    return top;
+  };
+  const rowLayouts = () => {
+    const nowMs = props.nowMs();
+    const sidebarWidth = props.sidebarWidth?.();
+    return visibleChildren().map((child) => ({
+      id: child.id,
+      height: subagentRowHeight({
+        child,
+        nowMs,
+        sidebarWidth,
+        reservedWidth: SUBAGENTS_ROW_MARKER_WIDTH,
+        usageLabel: props.usageLabel,
+        childHint: props.childHint?.(child.id)
+      })
+    }));
+  };
+  const currentSidebarScrollAnchor = () => {
+    if (!scrollbox) return void 0;
+    const rows = rowLayouts();
+    if (rows.length === 0) return void 0;
+    const viewportTop = clampedScrollTop(scrollbox, scrollbox.scrollTop);
+    let top = 0;
+    for (let index = 0; index < rows.length; index += 1) {
+      const row = rows[index];
+      if (!row) continue;
+      const rowBottom = top + row.height;
+      if (rowBottom > viewportTop) {
+        return {
+          childIDs: rows.slice(index).map((candidate) => candidate.id),
+          intraRowOffset: Math.max(0, viewportTop - top)
+        };
+      }
+      top = rowBottom + SUBAGENTS_ROW_GAP;
+    }
+    const lastRow = rows[rows.length - 1];
+    return lastRow ? {
+      childIDs: [lastRow.id],
+      intraRowOffset: 0
+    } : void 0;
+  };
+  const scrollChildIntoView = (childID) => {
+    if (!scrollbox) return;
+    const selectedIndex = visibleChildIDs().findIndex((id) => id === childID);
+    if (selectedIndex < 0) return;
+    const selectedChild = visibleChildren()[selectedIndex];
+    if (!selectedChild) return;
+    const rowTop = rowTopForIndex(selectedIndex);
+    const rowBottom = rowTop + subagentRowHeight({
+      child: selectedChild,
+      nowMs: props.nowMs(),
+      sidebarWidth: props.sidebarWidth?.(),
+      reservedWidth: SUBAGENTS_ROW_MARKER_WIDTH,
+      usageLabel: props.usageLabel,
+      childHint: props.childHint?.(selectedChild.id)
+    });
+    const viewportTop = scrollbox.scrollTop;
+    const viewportBottom = viewportTop + listHeight();
+    if (rowTop < viewportTop) {
+      const nextTop = clampedScrollTop(scrollbox, rowTop);
+      scrollRegistration.offsetTop = nextTop;
+      scrollbox.scrollTop = nextTop;
+    } else if (rowBottom > viewportBottom) {
+      const nextTop = clampedScrollTop(scrollbox, rowBottom - listHeight());
+      scrollRegistration.offsetTop = nextTop;
+      scrollbox.scrollTop = nextTop;
+    }
+  };
+  const scrollSelectedChildIntoView = () => {
+    if (!listFocusModeActive()) return;
+    scrollChildIntoView(selectedChildID());
+  };
+  const moveSelection = (delta) => {
+    const ids = visibleChildIDs();
+    if (ids.length === 0) return;
+    const currentIndex = ids.findIndex((id) => id === selectedChildID());
+    const fallbackIndex = delta > 0 ? 0 : ids.length - 1;
+    const nextIndex = Math.max(0, Math.min(ids.length - 1, currentIndex < 0 ? fallbackIndex : currentIndex + delta));
+    setSelectedChildID(ids[nextIndex]);
+    scrollChildIntoView(ids[nextIndex]);
+  };
+  const rowActivations = /* @__PURE__ */ new Map();
+  const resolveNavigableChildTargetSessionID = (child) => resolveChildTargetSessionID(child) ?? resolveSyntheticTargetFromHydratedState(props.state(), child);
+  const selectedTargetSessionID = () => {
+    const selected = visibleChildren().find((child) => child.id === selectedChildID());
+    return selected ? resolveNavigableChildTargetSessionID(selected) : void 0;
+  };
+  const activateSelectedChild = () => {
+    const selectedID = selectedChildID();
+    const activateRow = selectedID ? rowActivations.get(selectedID) : void 0;
+    if (activateRow) {
+      activateRow();
+      return;
+    }
+    props.navigate(selectedTargetSessionID());
+  };
+  const toggleCompletedHistory = () => {
+    completedHistoryRegistration.toggleCompletedHistory();
+  };
+  createEffect(() => {
+    selectedChildID();
+    listHeight();
+    if (!listFocused()) return;
+    scrollSelectedChildIntoView();
+  });
+  const handleListKeyDown = (event) => {
+    if (!listFocused()) return;
+    const name = event.name.toLowerCase();
+    if (props.strictInput && (event.ctrl || event.shift || event.super || event.hyper || (event.meta || event.option) && name !== "b")) return;
+    if ((event.meta || event.option) && name === "b") {
+      props.onToggleListFocus();
+    } else if (name === "j" || name === "down" || name === "arrowdown") {
+      moveSelection(1);
+    } else if (name === "k" || name === "up" || name === "arrowup") {
+      moveSelection(-1);
+    } else if (name === "return" || name === "enter") {
+      activateSelectedChild();
+    } else if (name === "h" || name === "left" || name === "arrowleft") {
+      if (props.expanded()) props.onSetExpanded(false);
+    } else if (name === "l" || name === "right" || name === "arrowright") {
+      if (!props.expanded()) props.onSetExpanded(true);
+    } else if (name === "c") {
+      toggleCompletedHistory();
+    } else if (name === "escape" || name === "esc") {
+      focusRegistration.blurList();
+      props.onReturnFocus();
+    } else {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+  };
+  props.registerListKeys({
+    target: () => listContainer,
+    onKeyDown: handleListKeyDown
+  });
+  const restorePreservedScroll = () => {
+    if (!scrollbox) return;
+    if (scrollRegistration.restoreFramesRemaining <= 0) return;
+    scrollRegistration.restoreFramesRemaining -= 1;
+    if (restoreChildRowID) {
+      const childRowID = restoreChildRowID;
+      restoreChildRowID = void 0;
+      scrollRegistration.restoreFramesRemaining = 0;
+      if (visibleChildIDs().includes(childRowID)) {
+        scrollChildIntoView(childRowID);
+      } else {
+        scrollbox.scrollTop = 0;
+      }
+      return;
+    }
+    const top = preservedSidebarScrollTop({
+      expanded: props.expanded(),
+      offsetTop: scrollRegistration.offsetTop,
+      anchor: scrollRegistration.anchor,
+      rows: scrollRegistration.getRows(),
+      leadingHeight: scrollRegistration.getLeadingHeight(),
+      scrollTop: scrollbox.scrollTop,
+      scrollHeight: scrollbox.scrollHeight,
+      viewportHeight: scrollbox.viewport.height
+    });
+    if (top === void 0) return;
+    scrollRegistration.offsetTop = top;
+    scrollbox.scrollTop = top;
+  };
+  createEffect(() => {
+    props.expanded();
+    visibleChildIDs().join("|");
+    visibleChildLayoutSignature();
+    props.sidebarWidth?.();
+    restorePreservedScroll();
+  });
+  const ChildRow = (rowProps) => {
+    const child = createMemo(() => visibleChildren().find((candidate) => candidate.id === rowProps.childID));
+    const [hovered, setHovered] = createSignal(false);
+    const [focused, setFocused] = createSignal(false);
+    const targetSessionID = createMemo(() => {
+      const currentChild = child();
+      return currentChild ? resolveNavigableChildTargetSessionID(currentChild) : void 0;
+    });
+    const clickable = createMemo(() => isSessionTarget(targetSessionID()));
+    const selected = createMemo(() => listFocused() && selectedChildID() === rowProps.childID);
+    const emphasized = createMemo(() => clickable() && (hovered() || focused() || selected()));
+    const status = createMemo(() => child()?.status ?? "running");
+    const muted = createMemo(() => status() !== "running" && clickable() && !emphasized());
+    const rowOpacity = createMemo(() => status() === "running" ? 1 : INACTIVE_SUBAGENT_OPACITY);
+    const line = createMemo(() => {
+      const currentChild = child();
+      if (!currentChild) {
+        return {
+          labelLines: [""],
+          elapsed: "00:00",
+          meta: ""
+        };
+      }
+      return formatChildRowLine({
+        child: currentChild,
+        nowMs: props.nowMs(),
+        sidebarWidth: props.sidebarWidth?.(),
+        reservedWidth: SUBAGENTS_ROW_MARKER_WIDTH,
+        usageLabel: props.usageLabel
+      });
+    });
+    const terminalLine = createMemo(() => {
+      const currentChild = child();
+      if (!currentChild) return {
+        label: "",
+        meta: "00:00"
+      };
+      return formatTerminalChildRowLine({
+        child: currentChild,
+        nowMs: props.nowMs(),
+        sidebarWidth: props.sidebarWidth?.(),
+        reservedWidth: SUBAGENTS_ROW_MARKER_WIDTH,
+        usageLabel: props.usageLabel
+      });
+    });
+    const rowHeight = createMemo(() => {
+      const currentChild = child();
+      if (!currentChild) return SUBAGENTS_TERMINAL_ROW_HEIGHT;
+      return subagentRowHeight({
+        child: currentChild,
+        nowMs: props.nowMs(),
+        sidebarWidth: props.sidebarWidth?.(),
+        reservedWidth: SUBAGENTS_ROW_MARKER_WIDTH,
+        usageLabel: props.usageLabel,
+        childHint: props.childHint?.(currentChild.id)
+      });
+    });
+    const modelLine = createMemo(() => {
+      const currentChild = child();
+      if (!currentChild) return void 0;
+      return props.modelLine(currentChild, rowWidthBudget(props.sidebarWidth?.()) - SUBAGENTS_ROW_MARKER_WIDTH);
+    });
+    const activate = () => {
+      const target = targetSessionID();
+      if (target) {
+        props.onNavigateToChild({
+          parentSessionID: props.sessionID,
+          childSessionID: target,
+          childRowID: rowProps.childID,
+          showCompletedHistory: showCompletedHistory()
+        });
+      }
+      props.controller.snapshotScroll();
+      props.navigate(target);
+    };
+    rowActivations.set(rowProps.childID, activate);
+    onCleanup(() => {
+      rowActivations.delete(rowProps.childID);
+    });
+    const handleKeyDown = (event) => {
+      if (!clickable()) return;
+      if (props.strictInput && (event.ctrl || event.meta || event.option || event.shift || event.super || event.hyper)) return;
+      setFocused(true);
+      if (event.name === "return" || event.name === "space") {
+        activate();
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    };
+    return (() => {
+      var _el$ = _$createElement("box");
+      _$setProp(_el$, "flexDirection", "column");
+      _$insert(_el$, _$createComponent(Show, {
+        get when() {
+          return status() === "running";
+        },
+        get fallback() {
+          return (() => {
+            var _el$0 = _$createElement("box"), _el$1 = _$createElement("box"), _el$10 = _$createElement("text"), _el$11 = _$createElement("text"), _el$12 = _$createElement("text"), _el$13 = _$createElement("text");
+            _$insertNode(_el$0, _el$1);
+            _$insertNode(_el$0, _el$13);
+            _$setProp(_el$0, "flexDirection", "column");
+            _$insertNode(_el$1, _el$10);
+            _$insertNode(_el$1, _el$11);
+            _$insertNode(_el$1, _el$12);
+            _$setProp(_el$1, "flexDirection", "row");
+            _$insert(_el$10, () => selected() ? "\u203A" : " ");
+            _$insert(_el$11, () => taskStatusMarker(status()));
+            _$insert(_el$12, () => ` ${terminalLine().label}`);
+            _$insert(_el$13, () => `    \u21B3 ${CLOCK_ICON} ${terminalLine().meta}`);
+            _$insert(_el$0, _$createComponent(Show, {
+              get when() {
+                return modelLine();
+              },
+              children: (metadata) => (() => {
+                var _el$14 = _$createElement("text");
+                _$insert(_el$14, () => `    ${metadata()}`);
+                _$effect((_$p) => _$setProp(_el$14, "fg", props.theme.textMuted, _$p));
+                return _el$14;
+              })()
+            }), null);
+            _$effect((_p$) => {
+              var _v$13 = selected() ? props.theme.accent : props.theme.textMuted, _v$14 = statusColor2(status(), props.theme), _v$15 = selected() ? props.theme.text : muted() ? props.theme.textMuted : props.theme.text, _v$16 = emphasized() ? props.theme.text : props.theme.textMuted;
+              _v$13 !== _p$.e && (_p$.e = _$setProp(_el$10, "fg", _v$13, _p$.e));
+              _v$14 !== _p$.t && (_p$.t = _$setProp(_el$11, "fg", _v$14, _p$.t));
+              _v$15 !== _p$.a && (_p$.a = _$setProp(_el$12, "fg", _v$15, _p$.a));
+              _v$16 !== _p$.o && (_p$.o = _$setProp(_el$13, "fg", _v$16, _p$.o));
+              return _p$;
+            }, {
+              e: void 0,
+              t: void 0,
+              a: void 0,
+              o: void 0
+            });
+            return _el$0;
+          })();
+        },
+        get children() {
+          var _el$2 = _$createElement("box"), _el$3 = _$createElement("box"), _el$4 = _$createElement("text"), _el$5 = _$createElement("text"), _el$6 = _$createElement("text"), _el$7 = _$createElement("box"), _el$8 = _$createElement("text");
+          _$insertNode(_el$2, _el$3);
+          _$insertNode(_el$2, _el$7);
+          _$setProp(_el$2, "flexDirection", "column");
+          _$insertNode(_el$3, _el$4);
+          _$insertNode(_el$3, _el$5);
+          _$insertNode(_el$3, _el$6);
+          _$setProp(_el$3, "flexDirection", "row");
+          _$insert(_el$4, () => selected() ? "\u203A" : " ");
+          _$insert(_el$5, () => taskStatusMarker(status()));
+          _$insert(_el$6, () => ` ${line().labelLines[0] ?? ""}`);
+          _$insert(_el$2, _$createComponent(Show, {
+            get when() {
+              return line().secondaryLine;
+            },
+            children: (secondaryLine) => (() => {
+              var _el$15 = _$createElement("text");
+              _$insert(_el$15, () => `    ${secondaryLine()}`);
+              _$effect((_$p) => _$setProp(_el$15, "fg", muted() ? props.theme.textMuted : props.theme.text, _$p));
+              return _el$15;
+            })()
+          }), _el$7);
+          _$insertNode(_el$7, _el$8);
+          _$setProp(_el$7, "flexDirection", "row");
+          _$setProp(_el$7, "paddingLeft", 4);
+          _$insert(_el$8, () => `\u21B3 ${CLOCK_ICON} ${line().elapsed}`);
+          _$insert(_el$7, _$createComponent(Show, {
+            get when() {
+              return line().meta.length > 0;
+            },
+            get children() {
+              var _el$9 = _$createElement("text");
+              _$insert(_el$9, () => ` ${TOKEN_ICON} ${line().meta}`);
+              _$effect((_$p) => _$setProp(_el$9, "fg", emphasized() ? props.theme.text : props.theme.textMuted, _$p));
+              return _el$9;
+            }
+          }), null);
+          _$insert(_el$2, _$createComponent(Show, {
+            get when() {
+              return modelLine();
+            },
+            children: (metadata) => (() => {
+              var _el$16 = _$createElement("text");
+              _$insert(_el$16, () => `    ${metadata()}`);
+              _$effect((_$p) => _$setProp(_el$16, "fg", props.theme.textMuted, _$p));
+              return _el$16;
+            })()
+          }), null);
+          _$effect((_p$) => {
+            var _v$ = selected() ? props.theme.accent : props.theme.textMuted, _v$2 = statusColor2(status(), props.theme), _v$3 = selected() ? props.theme.text : muted() ? props.theme.textMuted : props.theme.text, _v$4 = emphasized() ? props.theme.text : props.theme.textMuted;
+            _v$ !== _p$.e && (_p$.e = _$setProp(_el$4, "fg", _v$, _p$.e));
+            _v$2 !== _p$.t && (_p$.t = _$setProp(_el$5, "fg", _v$2, _p$.t));
+            _v$3 !== _p$.a && (_p$.a = _$setProp(_el$6, "fg", _v$3, _p$.a));
+            _v$4 !== _p$.o && (_p$.o = _$setProp(_el$8, "fg", _v$4, _p$.o));
+            return _p$;
+          }, {
+            e: void 0,
+            t: void 0,
+            a: void 0,
+            o: void 0
+          });
+          return _el$2;
+        }
+      }), null);
+      _$insert(_el$, _$createComponent(Show, {
+        get when() {
+          return props.childHint?.(rowProps.childID);
+        },
+        children: (hint) => (() => {
+          var _el$17 = _$createElement("text");
+          _$insert(_el$17, () => `    ${hint()}`);
+          _$effect((_$p) => _$setProp(_el$17, "fg", props.theme.warning, _$p));
+          return _el$17;
+        })()
+      }), null);
+      _$effect((_p$) => {
+        var _v$5 = rowHeight(), _v$6 = rowOpacity(), _v$7 = selected() ? props.theme.backgroundElement : void 0, _v$8 = clickable() ? () => setHovered(true) : void 0, _v$9 = clickable() ? () => {
+          setHovered(false);
+          setFocused(false);
+          setMouseDownChildID(void 0);
+        } : void 0, _v$0 = clickable() ? (event) => {
+          event.stopPropagation();
+          setSelectedChildID(rowProps.childID);
+          setMouseDownChildID(rowProps.childID);
+        } : void 0, _v$1 = clickable() ? (event) => {
+          if (mouseDownChildID() === rowProps.childID) {
+            event.stopPropagation();
+            activate();
+          }
+          setMouseDownChildID(void 0);
+        } : void 0, _v$10 = clickable() ? handleKeyDown : void 0, _v$11 = clickable(), _v$12 = clickable() && focused();
+        _v$5 !== _p$.e && (_p$.e = _$setProp(_el$, "height", _v$5, _p$.e));
+        _v$6 !== _p$.t && (_p$.t = _$setProp(_el$, "opacity", _v$6, _p$.t));
+        _v$7 !== _p$.a && (_p$.a = _$setProp(_el$, "backgroundColor", _v$7, _p$.a));
+        _v$8 !== _p$.o && (_p$.o = _$setProp(_el$, "onMouseOver", _v$8, _p$.o));
+        _v$9 !== _p$.i && (_p$.i = _$setProp(_el$, "onMouseOut", _v$9, _p$.i));
+        _v$0 !== _p$.n && (_p$.n = _$setProp(_el$, "onMouseDown", _v$0, _p$.n));
+        _v$1 !== _p$.s && (_p$.s = _$setProp(_el$, "onMouseUp", _v$1, _p$.s));
+        _v$10 !== _p$.h && (_p$.h = _$setProp(_el$, "onKeyDown", _v$10, _p$.h));
+        _v$11 !== _p$.r && (_p$.r = _$setProp(_el$, "focusable", _v$11, _p$.r));
+        _v$12 !== _p$.d && (_p$.d = _$setProp(_el$, "focused", _v$12, _p$.d));
+        return _p$;
+      }, {
+        e: void 0,
+        t: void 0,
+        a: void 0,
+        o: void 0,
+        i: void 0,
+        n: void 0,
+        s: void 0,
+        h: void 0,
+        r: void 0,
+        d: void 0
+      });
+      return _el$;
+    })();
+  };
+  const AggregateBar = () => (() => {
+    var _el$18 = _$createElement("box"), _el$19 = _$createElement("text"), _el$20 = _$createElement("text"), _el$22 = _$createElement("text"), _el$23 = _$createElement("text"), _el$25 = _$createElement("text"), _el$26 = _$createElement("text"), _el$28 = _$createElement("text");
+    _$insertNode(_el$18, _el$19);
+    _$insertNode(_el$18, _el$20);
+    _$insertNode(_el$18, _el$22);
+    _$insertNode(_el$18, _el$23);
+    _$insertNode(_el$18, _el$25);
+    _$insertNode(_el$18, _el$26);
+    _$insertNode(_el$18, _el$28);
+    _$setProp(_el$18, "flexDirection", "row");
+    _$setProp(_el$18, "paddingRight", 1);
+    _$insert(_el$19, () => `\u25CF ${counts().running} run`);
+    _$insertNode(_el$20, _$createTextNode(` \xB7 `));
+    _$insert(_el$22, () => `\u2713 ${counts().done} done`);
+    _$insertNode(_el$23, _$createTextNode(` \xB7 `));
+    _$insert(_el$25, () => `\u2715 ${counts().error} err`);
+    _$insertNode(_el$26, _$createTextNode(` \xB7 `));
+    _$setProp(_el$28, "selectable", false);
+    _$setProp(_el$28, "onMouseDown", toggleCompletedHistory);
+    _$insert(_el$28, () => `\u03A3 ${totalExecuted()}`);
+    _$effect((_p$) => {
+      var _v$17 = props.theme.warning, _v$18 = props.theme.textMuted, _v$19 = props.theme.success, _v$20 = props.theme.textMuted, _v$21 = props.theme.error, _v$22 = props.theme.textMuted, _v$23 = showCompletedHistory() ? props.theme.accent : props.theme.text;
+      _v$17 !== _p$.e && (_p$.e = _$setProp(_el$19, "fg", _v$17, _p$.e));
+      _v$18 !== _p$.t && (_p$.t = _$setProp(_el$20, "fg", _v$18, _p$.t));
+      _v$19 !== _p$.a && (_p$.a = _$setProp(_el$22, "fg", _v$19, _p$.a));
+      _v$20 !== _p$.o && (_p$.o = _$setProp(_el$23, "fg", _v$20, _p$.o));
+      _v$21 !== _p$.i && (_p$.i = _$setProp(_el$25, "fg", _v$21, _p$.i));
+      _v$22 !== _p$.n && (_p$.n = _$setProp(_el$26, "fg", _v$22, _p$.n));
+      _v$23 !== _p$.s && (_p$.s = _$setProp(_el$28, "fg", _v$23, _p$.s));
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0,
+      a: void 0,
+      o: void 0,
+      i: void 0,
+      n: void 0,
+      s: void 0
+    });
+    return _el$18;
+  })();
+  return (() => {
+    var _el$29 = _$createElement("box"), _el$30 = _$createElement("box"), _el$31 = _$createElement("text");
+    _$insertNode(_el$29, _el$30);
+    _$use((element) => {
+      listContainer = element;
+      if (!element) setListFocused(false);
+    }, _el$29);
+    _$setProp(_el$29, "flexDirection", "column");
+    _$setProp(_el$29, "focusable", true);
+    _$setProp(_el$29, "renderBefore", () => {
+      refreshListFocused();
+      restorePreservedScroll();
+    });
+    _$insertNode(_el$30, _el$31);
+    _$setProp(_el$30, "flexDirection", "row");
+    _$setProp(_el$31, "selectable", false);
+    _$insert(_el$31, () => `${props.expanded() ? SIDEBAR_ARROW_EXPANDED : SIDEBAR_ARROW_COLLAPSED} ${t("subagents")}`);
+    _$insert(_el$30, _$createComponent(Show, {
+      when: PLUGIN_VERSION,
+      children: (version) => (() => {
+        var _el$34 = _$createElement("box"), _el$35 = _$createElement("text");
+        _$insertNode(_el$34, _el$35);
+        _$setProp(_el$34, "flexDirection", "row");
+        _$setProp(_el$35, "opacity", 0.7);
+        _$setProp(_el$35, "selectable", false);
+        _$insert(_el$35, () => ` ${version()}`);
+        _$insert(_el$34, _$createComponent(Show, {
+          get when() {
+            return listFocused();
+          },
+          get children() {
+            var _el$36 = _$createElement("text");
+            _$insertNode(_el$36, _$createTextNode(` \u25CF`));
+            _$setProp(_el$36, "selectable", false);
+            _$effect((_p$) => {
+              var _v$28 = props.theme.accent, _v$29 = props.onToggleExpanded;
+              _v$28 !== _p$.e && (_p$.e = _$setProp(_el$36, "fg", _v$28, _p$.e));
+              _v$29 !== _p$.t && (_p$.t = _$setProp(_el$36, "onMouseDown", _v$29, _p$.t));
+              return _p$;
+            }, {
+              e: void 0,
+              t: void 0
+            });
+            return _el$36;
+          }
+        }), null);
+        _$effect((_p$) => {
+          var _v$30 = props.theme.textMuted, _v$31 = props.onToggleExpanded;
+          _v$30 !== _p$.e && (_p$.e = _$setProp(_el$35, "fg", _v$30, _p$.e));
+          _v$31 !== _p$.t && (_p$.t = _$setProp(_el$35, "onMouseDown", _v$31, _p$.t));
+          return _p$;
+        }, {
+          e: void 0,
+          t: void 0
+        });
+        return _el$34;
+      })()
+    }), null);
+    _$insert(_el$29, _$createComponent(AggregateBar, {}), null);
+    _$insert(_el$29, _$createComponent(Show, {
+      get when() {
+        return props.notice?.();
+      },
+      children: (notice) => (() => {
+        var _el$38 = _$createElement("text");
+        _$insert(_el$38, () => wrapCompactText(notice(), rowWidthBudget(props.sidebarWidth?.()), 3).join("\n"));
+        _$effect((_$p) => _$setProp(_el$38, "fg", props.theme.warning, _$p));
+        return _el$38;
+      })()
+    }), null);
+    _$insert(_el$29, _$createComponent(Show, {
+      get when() {
+        return props.usageLabel;
+      },
+      children: (label) => (() => {
+        var _el$39 = _$createElement("text");
+        _$insert(_el$39, () => wrapCompactText(label(), rowWidthBudget(props.sidebarWidth?.()), 3).join("\n"));
+        _$effect((_$p) => _$setProp(_el$39, "fg", props.theme.textMuted, _$p));
+        return _el$39;
+      })()
+    }), null);
+    _$insert(_el$29, _$createComponent(Show, {
+      get when() {
+        return props.expanded();
+      },
+      get children() {
+        var _el$32 = _$createElement("scrollbox"), _el$33 = _$createElement("box");
+        _$insertNode(_el$32, _el$33);
+        _$use((element) => {
+          scrollbox = element;
+          restorePreservedScroll();
+        }, _el$32);
+        _$setProp(_el$32, "scrollY", true);
+        _$setProp(_el$32, "viewportCulling", false);
+        _$setProp(_el$33, "flexDirection", "column");
+        _$setProp(_el$33, "rowGap", 0);
+        _$insert(_el$33, _$createComponent(For, {
+          get each() {
+            return visibleChildIDs();
+          },
+          children: (childID) => _$createComponent(ChildRow, {
+            childID
+          })
+        }));
+        _$effect((_$p) => _$setProp(_el$32, "height", listHeight(), _$p));
+        return _el$32;
+      }
+    }), null);
+    _$effect((_p$) => {
+      var _v$24 = listFocused() ? props.theme.backgroundPanel : void 0, _v$25 = listFocused(), _v$26 = props.theme.text, _v$27 = props.onToggleExpanded;
+      _v$24 !== _p$.e && (_p$.e = _$setProp(_el$29, "backgroundColor", _v$24, _p$.e));
+      _v$25 !== _p$.t && (_p$.t = _$setProp(_el$29, "focused", _v$25, _p$.t));
+      _v$26 !== _p$.a && (_p$.a = _$setProp(_el$31, "fg", _v$26, _p$.a));
+      _v$27 !== _p$.o && (_p$.o = _$setProp(_el$31, "onMouseDown", _v$27, _p$.o));
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0,
+      a: void 0,
+      o: void 0
+    });
+    return _el$29;
+  })();
+}
+function HomeBottomStatus(props) {
+  const snapshot = createMemo(() => resolveTuiSubagentSnapshot({
+    state: props.state()
+  }));
+  const counts = createMemo(() => snapshot().visibleCounts);
+  const totalExecuted = createMemo(() => snapshot().totalExecuted);
+  const visible = createMemo(() => counts().running > 0 || counts().error > 0 || totalExecuted() > 0);
+  return _$createComponent(Show, {
+    get when() {
+      return visible();
+    },
+    get children() {
+      var _el$40 = _$createElement("box"), _el$41 = _$createElement("box"), _el$42 = _$createElement("text"), _el$43 = _$createElement("text"), _el$45 = _$createElement("text"), _el$46 = _$createElement("text"), _el$48 = _$createElement("text"), _el$49 = _$createElement("text"), _el$51 = _$createElement("text");
+      _$insertNode(_el$40, _el$41);
+      _$setProp(_el$40, "paddingLeft", 1);
+      _$setProp(_el$40, "paddingRight", 1);
+      _$insertNode(_el$41, _el$42);
+      _$insertNode(_el$41, _el$43);
+      _$insertNode(_el$41, _el$45);
+      _$insertNode(_el$41, _el$46);
+      _$insertNode(_el$41, _el$48);
+      _$insertNode(_el$41, _el$49);
+      _$insertNode(_el$41, _el$51);
+      _$setProp(_el$41, "flexDirection", "row");
+      _$insert(_el$42, () => `\u25CF ${counts().running}`);
+      _$insertNode(_el$43, _$createTextNode(` \xB7 `));
+      _$insert(_el$45, () => `\u2713 ${counts().done}`);
+      _$insertNode(_el$46, _$createTextNode(` \xB7 `));
+      _$insert(_el$48, () => `\u2715 ${counts().error}`);
+      _$insertNode(_el$49, _$createTextNode(` \xB7 `));
+      _$insert(_el$51, () => `\u03A3 ${totalExecuted()}`);
+      _$effect((_p$) => {
+        var _v$32 = props.theme.warning, _v$33 = props.theme.textMuted, _v$34 = props.theme.success, _v$35 = props.theme.textMuted, _v$36 = props.theme.error, _v$37 = props.theme.textMuted, _v$38 = props.theme.text;
+        _v$32 !== _p$.e && (_p$.e = _$setProp(_el$42, "fg", _v$32, _p$.e));
+        _v$33 !== _p$.t && (_p$.t = _$setProp(_el$43, "fg", _v$33, _p$.t));
+        _v$34 !== _p$.a && (_p$.a = _$setProp(_el$45, "fg", _v$34, _p$.a));
+        _v$35 !== _p$.o && (_p$.o = _$setProp(_el$46, "fg", _v$35, _p$.o));
+        _v$36 !== _p$.i && (_p$.i = _$setProp(_el$48, "fg", _v$36, _p$.i));
+        _v$37 !== _p$.n && (_p$.n = _$setProp(_el$49, "fg", _v$37, _p$.n));
+        _v$38 !== _p$.s && (_p$.s = _$setProp(_el$51, "fg", _v$38, _p$.s));
+        return _p$;
+      }, {
+        e: void 0,
+        t: void 0,
+        a: void 0,
+        o: void 0,
+        i: void 0,
+        n: void 0,
+        s: void 0
+      });
+      return _el$40;
+    }
+  });
+}
+
+// src/tui-v2.tsx
+async function initializeV2(context) {
+  let disposed = false;
+  let cleanupPromise;
+  let disposeRoot;
+  let hide;
+  let tick;
+  let navigationGeneration = 0;
+  let view;
+  let focus;
+  let monitor;
+  let writer;
+  const subscriptions = [];
+  const claims = [];
+  const reported = /* @__PURE__ */ new Set();
+  function showToast(message, variant) {
+    try {
+      context.ui.toast.show({
+        message,
+        variant
+      });
+    } catch {
+    }
+  }
+  function report(message) {
+    if (reported.has(message)) return;
+    reported.add(message);
+    showToast(message, "warning");
+  }
+  function issue(message) {
+    if (!disposed) report(message);
+  }
+  function cleanup() {
+    if (cleanupPromise) return cleanupPromise;
+    disposed = true;
+    navigationGeneration++;
+    cleanupPromise = (async () => {
+      let failed = false;
+      const release = (action) => {
+        try {
+          action?.();
+        } catch {
+          failed = true;
+        }
+      };
+      release(() => monitor?.dispose());
+      release(() => clearInterval(tick));
+      for (const stop of subscriptions.splice(0)) release(stop);
+      release(() => focus?.dispose());
+      release(hide);
+      for (const remove of claims.splice(0).reverse()) release(remove);
+      release(() => view?.dispose());
+      release(disposeRoot);
+      try {
+        await writer?.dispose();
+      } catch {
+        failed = true;
+      }
+      if (failed) report("Subagents: Cleanup incomplete");
+    })();
+    return cleanupPromise;
+  }
+  try {
+    createRoot((dispose) => {
+      disposeRoot = dispose;
+      const [alive, setAlive] = createSignal2(true);
+      hide = () => setAlive(false);
+      const [state, setState] = createSignal2(createEmptyState());
+      const [nowMs, setNowMs] = createSignal2(Date.now());
+      const [stale, setStale] = createSignal2(false);
+      const [preferences, updatePreferences] = context.storage.store("subagents.sidebar", {
+        initial: {
+          enabled: true,
+          expanded: true
+        }
+      });
+      const theme = {
+        get text() {
+          return context.theme.text.base;
+        },
+        get textMuted() {
+          return context.theme.text.muted;
+        },
+        get accent() {
+          return context.theme.hue.accent[500];
+        },
+        get warning() {
+          return context.theme.text.feedback.warning.base;
+        },
+        get success() {
+          return context.theme.text.feedback.success.base;
+        },
+        get error() {
+          return context.theme.text.feedback.error.base;
+        },
+        get backgroundElement() {
+          return context.theme.background.raised.high;
+        },
+        get backgroundPanel() {
+          return context.theme.background.raised.base;
+        }
+      };
+      const ownedView = view = createSidebarViewController();
+      const routeKey = () => {
+        const route = context.ui.router.current();
+        return route.type === "session" ? `session:${route.sessionID}` : route.type === "plugin" ? `plugin:${route.id}:${route.name}` : "home";
+      };
+      const ownedFocus = focus = createV2SidebarFocus({
+        renderer: context.renderer,
+        view: ownedView,
+        route: routeKey,
+        mode: () => context.keymap.mode.current(),
+        unavailable: () => {
+          if (!disposed) showToast(t("unavailable"), "info");
+        }
+      });
+      const ownedWriter = writer = createV2SnapshotWriter({
+        ...resolveV2SnapshotPaths(),
+        onIssue: () => issue("Subagents: Snapshot unavailable")
+      });
+      const ownedMonitor = monitor = createV2Monitor({
+        session: context.client.session,
+        cache: context.data.session,
+        onIssue: () => issue(t("stale")),
+        onChange(next) {
+          if (disposed) return;
+          ownedView.snapshotScroll();
+          batch(() => {
+            setState(next);
+            setStale(ownedMonitor.stale());
+            setNowMs(Date.now());
+          });
+          ownedWriter.enqueue(next);
+          const running = Object.values(next.children).some((child) => child.status === "running");
+          if (running && !tick) tick = setInterval(() => {
+            if (!disposed) setNowMs(Date.now());
+          }, 1e3);
+          if (!running && tick) {
+            clearInterval(tick);
+            tick = void 0;
+          }
+        }
+      });
+      const run = (work) => {
+        void work.catch(() => issue(t("stale")));
+      };
+      let restore;
+      let intent;
+      async function navigate(target) {
+        const selected = intent;
+        intent = void 0;
+        if (disposed || !target || !selected || selected.childSessionID !== target) return;
+        const token = ++navigationGeneration, route = routeKey();
+        const valid = () => !disposed && token === navigationGeneration && routeKey() === route && state().children[selected.childRowID]?.parentID === selected.parentSessionID;
+        if (!valid()) return;
+        try {
+          const info = await context.client.session.get({
+            sessionID: target
+          });
+          if (!valid() || info.id !== target || info.parentID !== selected.parentSessionID) return;
+          restore = selected;
+          ownedFocus.beforeNavigate();
+          context.ui.router.navigate({
+            type: "session",
+            sessionID: target
+          });
+        } catch {
+        }
+      }
+      async function preference(mutate) {
+        if (disposed) return;
+        try {
+          await updatePreferences(mutate);
+        } catch {
+          issue("Subagents: Preferences unavailable");
+        }
+      }
+      const toggleFocus = () => {
+        if (disposed || context.keymap.mode.current() !== "base" || !preferences.enabled) return false;
+        if (ownedView.isListFocused()) ownedFocus.leave();
+        else {
+          const target = ownedView.target();
+          if (!target || target.isDestroyed || !target.visible) return false;
+          ownedFocus.request("keyboard");
+          if (!ownedView.isListFocused()) return false;
+        }
+      };
+      function Commands() {
+        context.keymap.layer(() => ({
+          mode: "global",
+          commands: [{
+            id: "subagent-statusline.toggle-sidebar-section",
+            title: "Subagents: Toggle sidebar section",
+            description: "Toggle the entire subagent sidebar section",
+            group: "Subagents",
+            palette: true,
+            bind: false,
+            run: () => {
+              if (disposed) return;
+              if (preferences.enabled) ownedFocus.leave();
+              return preference((draft) => {
+                draft.enabled = !draft.enabled;
+              });
+            }
+          }, {
+            id: "subagent-statusline.focus-sidebar-list",
+            title: "Subagents: Focus sidebar list",
+            description: "Focus the subagent sidebar list for keyboard navigation",
+            group: "Subagents",
+            palette: true,
+            bind: false,
+            run: () => {
+              if (!disposed) ownedFocus.request("palette");
+            }
+          }, {
+            id: "subagent-statusline.toggle-completed-history",
+            title: "Subagents: Toggle completed history",
+            description: "Toggle retained completed rows in the subagent sidebar. Shortcut: c while the sidebar list is focused.",
+            group: "Subagents",
+            palette: true,
+            bind: false,
+            run: () => {
+              if (!disposed && !ownedView.toggleCompletedHistory()) issue(t("unavailable"));
+            }
+          }]
+        }));
+        context.keymap.layer(() => ({
+          mode: "base",
+          priority: 100,
+          commands: [{
+            // V2 2.0.11 forwards the keyboard event only to named commands.
+            id: "subagent-statusline.internal.toggle-list-focus",
+            bind: "alt+b",
+            run: (_input, event) => {
+              if (event && (event.ctrl || event.shift || event.super || event.hyper || !(event.meta || event.option) || event.name.toLowerCase() !== "b")) return false;
+              if (toggleFocus() === false) return false;
+              event?.preventDefault();
+              event?.stopPropagation();
+            }
+          }]
+        }));
+        return null;
+      }
+      const registerListKeys = ({
+        target,
+        onKeyDown
+      }) => {
+        context.keymap.layer(() => ({
+          mode: "base",
+          priority: 100,
+          target,
+          commands: ["j", "k", "up", "down", "return", "c", "h", "l", "left", "right", "escape", "alt+b"].map((bind) => ({
+            id: `subagent-statusline.internal.list.${bind.replace("+", "-")}`,
+            bind,
+            run: (_input, event) => {
+              if (disposed || context.keymap.mode.current() !== "base" || !ownedView.isListFocused() || !event) return false;
+              onKeyDown(event);
+              if (!event.defaultPrevented) return false;
+            }
+          }))
+        }));
+      };
+      function modelLine(child, width) {
+        if (!child.model?.variant) return void 0;
+        const info = context.data.session.get(child.id);
+        const model = info && context.data.location.model.list(info.location)?.find((candidate) => candidate.id === child.model?.modelID && candidate.providerID === child.model.providerID);
+        return truncateToColumns(`${model?.name || child.model.modelID} \xB7 ${child.model.variant}`, Math.max(1, width));
+      }
+      function Sidebar(props) {
+        const [width, setWidth] = createSignal2();
+        let element;
+        const measure = () => {
+          if (!element || element.isDestroyed || element.width <= 0 || element.width === width()) return;
+          ownedView.snapshotScroll();
+          setWidth(element.width);
+        };
+        onCleanup2(() => {
+          navigationGeneration++;
+          element?.off("layout-changed", measure);
+          element?.off("resized", measure);
+          ownedFocus.leave();
+        });
+        return (() => {
+          var _el$ = _$createElement2("box");
+          _$use2((node) => {
+            element = node;
+            node.on("layout-changed", measure);
+            node.on("resized", measure);
+            measure();
+          }, _el$);
+          _$setProp2(_el$, "flexDirection", "column");
+          _$insert2(_el$, _$createComponent2(SidebarSubagents, {
+            controller: ownedView,
+            get sessionID() {
+              return props.sessionID;
+            },
+            state,
+            nowMs,
+            expanded: () => preferences.expanded,
+            onToggleExpanded: () => {
+              void preference((draft) => {
+                draft.expanded = !draft.expanded;
+              });
+            },
+            onSetExpanded: (expanded) => {
+              void preference((draft) => {
+                draft.expanded = expanded;
+              });
+            },
+            onReturnFocus: () => ownedFocus.leave(),
+            onToggleListFocus: toggleFocus,
+            onNavigateToChild: (next) => {
+              intent = next;
+            },
+            navigate: (target) => {
+              void navigate(target);
+            },
+            modelLine,
+            registerListKeys,
+            sidebarWidth: width,
+            theme,
+            get restoreFromChild() {
+              return restore?.parentSessionID === props.sessionID ? restore : void 0;
+            },
+            notice: () => stale() ? t("stale") : void 0,
+            childHint: (id) => {
+              state();
+              return ownedMonitor.hint(id) ? t("interrupted") : void 0;
+            },
+            get usageLabel() {
+              return t("usage");
+            },
+            strictInput: true
+          }));
+          return _el$;
+        })();
+      }
+      subscriptions.push(context.data.listen(({
+        details
+      }) => {
+        if (disposed) return;
+        if (details.type === "server.connected") run(ownedMonitor.reconnect());
+        else run(ownedMonitor.accept(details));
+      }));
+      claims.push(context.ui.slot({
+        append: "app",
+        render: () => _$createComponent2(Show2, {
+          get when() {
+            return alive();
+          },
+          get children() {
+            return _$createComponent2(Commands, {});
+          }
+        })
+      }));
+      claims.push(context.ui.slot({
+        append: "sidebar.content",
+        render: (input) => _$createComponent2(Show2, {
+          get when() {
+            return _$memo2(() => !!alive())() && preferences.enabled;
+          },
+          get children() {
+            return _$createComponent2(Show2, {
+              get when() {
+                return input.sessionID;
+              },
+              keyed: true,
+              children: (sessionID) => _$createComponent2(Sidebar, {
+                sessionID
+              })
+            });
+          }
+        })
+      }));
+      claims.push(context.ui.slot({
+        append: "home.footer.status",
+        render: () => _$createComponent2(Show2, {
+          get when() {
+            return alive();
+          },
+          get children() {
+            return _$createComponent2(HomeBottomStatus, {
+              state,
+              theme
+            });
+          }
+        })
+      }));
+      let previousRoute;
+      createEffect2(() => {
+        const route = context.ui.router.current(), key = routeKey();
+        if (key === previousRoute) return;
+        previousRoute = key;
+        navigationGeneration++;
+        intent = void 0;
+        ownedFocus.routeChanged();
+        if (restore && (route.type !== "session" || route.sessionID !== restore.parentSessionID && route.sessionID !== restore.childSessionID)) restore = void 0;
+        untrack(() => run(ownedMonitor.refresh(route.type === "session" ? route.sessionID : void 0)));
+      });
+    });
+    return cleanup;
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+var tui_v2_default = Plugin.define({
+  id: "subagent-statusline.tui",
+  setup: initializeV2
+});
+export {
+  tui_v2_default as default
+};