@khalilgharbaoui/opencode-claude-code-plugin 0.53.5 → 0.54.1

package/dist/tui.js

@@ -0,0 +1,689 @@
+// src/tui.ts
+import { RGBA } from "@opentui/core";
+import { createElement, createTextNode, effect, insert, insertNode, setProp } from "@opentui/solid";
+import { createMemo, createSignal, onCleanup } from "solid-js";
+
+// src/subagent-sidebar.ts
+var FINISHED_TTL_MS = 10 * 6e4;
+var FINISHED_KEEP = 3;
+var STARTING_GRACE_MS = 1e4;
+var SIDEBAR_ROW_WIDTH = 36;
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var TITLE_SUFFIX = /\s*\(@([^)\s]+) subagent\)\s*$/;
+function parseChildTitle(title) {
+  const text2 = (title ?? "").trim();
+  const match = TITLE_SUFFIX.exec(text2);
+  if (!match) return { description: text2 };
+  return { description: text2.slice(0, match.index).trim(), agent: match[1] };
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function partChildID(part) {
+  const metadata = part.metadata ?? {};
+  return text(metadata.sessionId) ?? text(metadata.sessionID);
+}
+function partAgent(part) {
+  const input = part.input ?? {};
+  return text(input.subagent_type) ?? text(input.agent);
+}
+function partDescription(part) {
+  return text(part.input?.description) ?? text(part.title);
+}
+function partBackground(part) {
+  return part.input?.background === true || part.metadata?.background === true;
+}
+var COMPLETION_ENVELOPE = /<(?:task\s+id|subagent\s+sessionID)="(ses_[A-Za-z0-9]+)"\s+state="([a-z_]+)"/g;
+function completionsIn(value, at) {
+  const found = [];
+  for (const match of value.matchAll(COMPLETION_ENVELOPE)) {
+    if (match[2] === "running") continue;
+    found.push({ sessionID: match[1], state: match[2], at });
+  }
+  return found;
+}
+function endState(state) {
+  return state === "completed" ? "done" : "error";
+}
+function shortModelName(modelID) {
+  let id = text(modelID);
+  if (!id) return void 0;
+  const at = id.indexOf("@");
+  if (at > 0) id = id.slice(0, at);
+  let suffix = "";
+  const window = /\[(\d+[km])\]$/i.exec(id);
+  if (window) {
+    suffix += ` ${window[1].toLowerCase()}`;
+    id = id.slice(0, window.index);
+  }
+  if (id.endsWith("-fast")) {
+    suffix = ` fast${suffix}`;
+    id = id.slice(0, -"-fast".length);
+  }
+  if (!id.startsWith("claude-")) return `${id}${suffix}`;
+  id = id.slice("claude-".length).replace(/-\d{8}$/, "");
+  const match = /^([a-z]+)-(\d+)(?:-(\d+))?$/.exec(id);
+  if (!match) return `${id}${suffix}`;
+  const version = match[3] === void 0 ? match[2] : `${match[2]}.${match[3]}`;
+  return `${match[1]}-${version}${suffix}`;
+}
+function accountFromProvider(providerID) {
+  const id = text(providerID);
+  if (!id?.startsWith("claude-code-")) return void 0;
+  return id.slice("claude-code-".length) || void 0;
+}
+function subagentLabel(record, part) {
+  const asked = part?.metadata?.model;
+  const askedModel = typeof asked?.modelID === "string" ? asked.modelID : void 0;
+  const askedProvider = typeof asked?.providerID === "string" ? asked.providerID : void 0;
+  const model = shortModelName(record?.model ?? askedModel);
+  const effort = text(record?.effort);
+  const account = record?.model ? text(record.account) : accountFromProvider(askedProvider);
+  return [model, effort, account].filter(Boolean).join(" \xB7 ");
+}
+function truncate(value, width) {
+  const chars = Array.from(value.replace(/\s+/g, " ").trim());
+  if (width <= 0) return "";
+  if (chars.length <= width) return chars.join("");
+  if (width === 1) return "\u2026";
+  return `${chars.slice(0, width - 1).join("").trimEnd()}\u2026`;
+}
+function deriveSubagentRows(input) {
+  const completions = /* @__PURE__ */ new Map();
+  for (const completion of input.completions) completions.set(completion.sessionID, completion);
+  const byChild = /* @__PURE__ */ new Map();
+  const unmatched = [];
+  for (const part of input.parts) {
+    const child = partChildID(part);
+    if (child) byChild.set(child, part);
+    else unmatched.push(part);
+  }
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const child of input.children) {
+    if (seen.has(child.id)) continue;
+    seen.add(child.id);
+    const parsed = parseChildTitle(child.title);
+    let part = byChild.get(child.id);
+    if (!part) {
+      const index = unmatched.findIndex(
+        (candidate) => partDescription(candidate) === parsed.description && (parsed.agent === void 0 || partAgent(candidate) === parsed.agent)
+      );
+      if (index >= 0) part = unmatched.splice(index, 1)[0];
+    }
+    rows.push(rowFor(input, child, parsed, part, completions.get(child.id)));
+  }
+  for (const part of unmatched) {
+    if (part.status !== "pending" && part.status !== "running") continue;
+    const description = partDescription(part);
+    const agent = partAgent(part);
+    if (!description && !agent) continue;
+    rows.push({
+      agent: agent ?? "subagent",
+      description: description ?? "",
+      background: partBackground(part),
+      state: "running",
+      label: subagentLabel(void 0, part),
+      started: part.start ?? input.now
+    });
+  }
+  const running = rows.filter((row) => row.state === "running").sort((a, b) => a.started - b.started);
+  const finished = rows.filter((row) => row.state !== "running").filter((row) => input.now - (row.finished ?? row.started) <= FINISHED_TTL_MS).sort((a, b) => (b.finished ?? b.started) - (a.finished ?? a.started)).slice(0, FINISHED_KEEP);
+  return [...running, ...finished];
+}
+function rowFor(input, child, parsed, part, completion) {
+  const background = part ? partBackground(part) : false;
+  const started = part?.start ?? child.created ?? input.now;
+  const status = input.status(child.id);
+  let state;
+  let finished;
+  if (part && !background && part.status !== "pending" && part.status !== "running") {
+    state = part.status === "completed" ? "done" : "error";
+    finished = part.end;
+  } else if (completion) {
+    state = endState(completion.state);
+    finished = completion.at;
+  } else if (status === "busy") {
+    state = "running";
+  } else if (part && !background) {
+    state = "running";
+  } else if (status === "idle" && input.now - started < STARTING_GRACE_MS) {
+    state = "running";
+  } else if (status === "unknown" && background) {
+    state = "running";
+  } else {
+    state = "done";
+  }
+  if (state !== "running" && finished === void 0) {
+    finished = input.stoppedAt(child.id) ?? child.updated ?? started;
+  }
+  return {
+    sessionID: child.id,
+    agent: parsed.agent ?? (part ? partAgent(part) : void 0) ?? text(child.agent) ?? "subagent",
+    description: (part ? partDescription(part) : void 0) ?? parsed.description,
+    background,
+    state,
+    label: subagentLabel(input.record(child.id), part),
+    effort: text(input.record(child.id)?.effort),
+    started,
+    finished
+  };
+}
+function layoutRow(row, width = SIDEBAR_ROW_WIDTH, frame = 0) {
+  const finished = row.state !== "running";
+  const glyph = row.state === "running" ? SPINNER_FRAMES[frame % SPINNER_FRAMES.length] : row.state === "done" ? "\u2713" : "\u2717";
+  const marker = row.background ? "bg" : "";
+  const reserved = marker ? marker.length + 1 : 0;
+  const agentWidth = Math.max(1, Math.min(Array.from(row.agent).length, width - 2 - reserved - 6));
+  const agent = truncate(row.agent, agentWidth);
+  const room = width - 2 - Array.from(agent).length - 1 - reserved;
+  const description = room > 0 ? truncate(row.description, room) : "";
+  const used = 2 + Array.from(agent).length + (description ? 1 + Array.from(description).length : 0);
+  const first = [
+    { text: glyph, role: row.state === "running" ? "spinner" : row.state === "done" ? "done" : "error" },
+    { text: " ", role: "muted" },
+    { text: agent, role: finished ? "muted" : "agent" }
+  ];
+  if (description) {
+    first.push({ text: " ", role: "muted" });
+    first.push({ text: description, role: finished ? "muted" : "description" });
+  }
+  if (marker) {
+    first.push({ text: " ".repeat(Math.max(1, width - used - marker.length)), role: "muted" });
+    first.push({ text: marker, role: "muted" });
+  }
+  const second = [];
+  if (row.label) {
+    const pieces = truncate(row.label, width - 2).split(" \xB7 ");
+    const effortAt = row.effort ? pieces.indexOf(row.effort) : -1;
+    second.push({ text: "  ", role: "muted" });
+    pieces.forEach((piece, index) => {
+      if (index > 0) second.push({ text: " \xB7 ", role: "muted" });
+      const role = index !== effortAt ? "muted" : finished ? "effort-faded" : "effort";
+      second.push({ text: piece, role });
+    });
+  }
+  return { first, second };
+}
+function collapsedSummary(rows) {
+  const running = rows.filter((row) => row.state === "running").length;
+  return running > 0 ? `${running} running` : `${rows.length} done`;
+}
+
+// src/spawn-record-store.ts
+import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var SPAWN_RECORD_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var pathOverride = null;
+function spawnRecordStorePath() {
+  if (pathOverride) return pathOverride;
+  const stateRoot = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state");
+  return join(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
+}
+function isRecord(value) {
+  const record = value;
+  if (!record || typeof record !== "object" || Array.isArray(record)) return false;
+  if (typeof record.at !== "number" || !Number.isFinite(record.at)) return false;
+  const ok = (field) => field === void 0 || typeof field === "string";
+  if (!ok(record.model) || !ok(record.effort) || !ok(record.account)) return false;
+  return !!record.model;
+}
+function readEntries(file) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
+    if (!entries || typeof entries !== "object") return out;
+    const cutoff = Date.now() - SPAWN_RECORD_MAX_AGE_MS;
+    const valid = Object.entries(entries).filter((entry) => isRecord(entry[1])).filter(([, record]) => record.at >= cutoff).sort((a, b) => a[1].at - b[1].at);
+    for (const [key, record] of valid) {
+      out.set(key, {
+        model: record.model,
+        ...record.effort ? { effort: record.effort } : {},
+        ...record.account ? { account: record.account } : {},
+        at: record.at
+      });
+    }
+  } catch {
+  }
+  return out;
+}
+function createSpawnRecordReader(file = spawnRecordStorePath) {
+  let identity = "";
+  let cached = /* @__PURE__ */ new Map();
+  return {
+    read() {
+      const path = file();
+      let next = "";
+      try {
+        const stats = statSync(path);
+        next = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
+      } catch {
+        next = "missing";
+      }
+      if (next !== identity) {
+        identity = next;
+        cached = next === "missing" ? /* @__PURE__ */ new Map() : readEntries(path);
+      }
+      return cached;
+    }
+  };
+}
+
+// src/tui.ts
+var SUBAGENTS_TUI_PLUGIN_ID = "opencode-claude-code-plugin.subagents";
+var SECTION_ORDER = 900;
+var SPINNER_INTERVAL_MS = 100;
+var REFRESH_INTERVAL_MS = 1500;
+var TASK_TOOLS = /* @__PURE__ */ new Set(["task", "subagent"]);
+function attempt(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function mix(a, b, weight) {
+  return attempt(
+    () => RGBA.fromValues(
+      a.r + (b.r - a.r) * weight,
+      a.g + (b.g - a.g) * weight,
+      a.b + (b.b - a.b) * weight,
+      a.a
+    ),
+    a
+  );
+}
+function roleColor(colors, role) {
+  switch (role) {
+    case "spinner":
+      return colors.spinner;
+    case "done":
+      return colors.done;
+    case "error":
+      return colors.error;
+    case "effort":
+      return colors.effort;
+    case "effort-faded":
+      return colors.effortFaded;
+    case "agent":
+    case "description":
+      return colors.text;
+    default:
+      return colors.muted;
+  }
+}
+function createSidebar(host) {
+  const [frame, setFrame] = createSignal(0);
+  const [now, setNow] = createSignal(Date.now());
+  const records = createSpawnRecordReader();
+  let recordMap = attempt(() => records.read(), /* @__PURE__ */ new Map());
+  const [recordVersion, setRecordVersion] = createSignal(0);
+  const sectionsRunning = /* @__PURE__ */ new Set();
+  const sectionsShowing = /* @__PURE__ */ new Set();
+  let spinner;
+  let refresh;
+  const syncClocks = () => {
+    if (sectionsRunning.size > 0 && !spinner) {
+      spinner = setInterval(() => setFrame((value) => (value + 1) % SPINNER_FRAMES.length), SPINNER_INTERVAL_MS);
+    } else if (sectionsRunning.size === 0 && spinner) {
+      clearInterval(spinner);
+      spinner = void 0;
+    }
+    if (sectionsShowing.size > 0 && !refresh) {
+      refresh = setInterval(() => {
+        const next = attempt(() => records.read(), recordMap);
+        if (next !== recordMap) {
+          recordMap = next;
+          setRecordVersion((value) => value + 1);
+        }
+        setNow(Date.now());
+      }, REFRESH_INTERVAL_MS);
+    } else if (sectionsShowing.size === 0 && refresh) {
+      clearInterval(refresh);
+      refresh = void 0;
+    }
+  };
+  const deriveRows = (parentID) => {
+    recordVersion();
+    return deriveSubagentRows({
+      ...host.gather(parentID),
+      record: (id) => recordMap.get(id),
+      now: now()
+    });
+  };
+  const buildRow = (row) => {
+    const box = createElement("box");
+    const layout = layoutRow(row, SIDEBAR_ROW_WIDTH);
+    const first = createElement("text");
+    setProp(first, "wrapMode", "none");
+    layout.first.forEach((segment, index) => {
+      const span = createElement("span");
+      if (index === 0 && row.state === "running") {
+        insert(span, () => SPINNER_FRAMES[frame() % SPINNER_FRAMES.length]);
+      } else {
+        insertNode(span, createTextNode(segment.text));
+      }
+      effect(() => setProp(span, "style", { fg: roleColor(host.colors(), segment.role) }));
+      insertNode(first, span);
+    });
+    insertNode(box, first);
+    if (layout.second.length > 0) {
+      const second = createElement("text");
+      setProp(second, "wrapMode", "none");
+      for (const segment of layout.second) {
+        const span = createElement("span");
+        insertNode(span, createTextNode(segment.text));
+        effect(() => setProp(span, "style", { fg: roleColor(host.colors(), segment.role) }));
+        insertNode(second, span);
+      }
+      insertNode(box, second);
+    }
+    if (row.sessionID) {
+      const sessionID = row.sessionID;
+      setProp(box, "onMouseDown", () => attempt(() => host.navigate(sessionID), void 0));
+      setProp(
+        box,
+        "onMouseOver",
+        () => attempt(() => setProp(box, "backgroundColor", host.colors().hover), void 0)
+      );
+      setProp(
+        box,
+        "onMouseOut",
+        () => attempt(() => setProp(box, "backgroundColor", "transparent"), void 0)
+      );
+    }
+    return box;
+  };
+  const buildSection = (list, expanded, setExpanded) => {
+    const section = createElement("box");
+    const header = createElement("box");
+    setProp(header, "flexDirection", "row");
+    setProp(header, "gap", 1);
+    setProp(header, "onMouseDown", () => list.length > 2 && setExpanded((value) => !value));
+    if (list.length > 2) {
+      const caret = createElement("text");
+      insert(caret, () => expanded() ? "\u25BC" : "\u25B6");
+      effect(() => setProp(caret, "fg", host.colors().text));
+      insertNode(header, caret);
+    }
+    const title = createElement("text");
+    const bold = createElement("b");
+    insertNode(bold, createTextNode("Subagents"));
+    insertNode(title, bold);
+    const summary = createElement("span");
+    insert(summary, () => expanded() ? "" : ` (${collapsedSummary(list)})`);
+    effect(() => setProp(summary, "style", { fg: host.colors().muted }));
+    insertNode(title, summary);
+    effect(() => setProp(title, "fg", host.colors().text));
+    insertNode(header, title);
+    insertNode(section, header);
+    const body = createElement("box");
+    insert(body, () => expanded() || list.length <= 2 ? list.map(buildRow) : null);
+    insertNode(section, body);
+    return section;
+  };
+  const render = (sessionID) => {
+    const root = createElement("box");
+    const key = /* @__PURE__ */ Symbol("subagents-section");
+    const [expanded, setExpanded] = createSignal(true);
+    const rows = createMemo(() => {
+      const parentID = sessionID();
+      if (!parentID) return [];
+      return attempt(() => deriveRows(parentID), []);
+    });
+    effect(() => {
+      const list = rows();
+      if (list.some((row) => row.state === "running")) sectionsRunning.add(key);
+      else sectionsRunning.delete(key);
+      if (list.length > 0) sectionsShowing.add(key);
+      else sectionsShowing.delete(key);
+      syncClocks();
+    });
+    onCleanup(() => {
+      sectionsRunning.delete(key);
+      sectionsShowing.delete(key);
+      syncClocks();
+    });
+    insert(root, () => {
+      const list = rows();
+      if (list.length === 0) return null;
+      return attempt(() => buildSection(list, expanded, setExpanded), null);
+    });
+    return root;
+  };
+  const dispose = () => {
+    sectionsRunning.clear();
+    sectionsShowing.clear();
+    syncClocks();
+  };
+  return { render, dispose };
+}
+function registerV1(api) {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const fetched = /* @__PURE__ */ new Set();
+  const stoppedAt = /* @__PURE__ */ new Map();
+  const lastStatus = /* @__PURE__ */ new Map();
+  const [version, setVersion] = createSignal(0);
+  const bump = () => setVersion((value) => value + 1);
+  const remember = (info) => {
+    if (!info?.id || !info.parentID) return false;
+    let children = childrenByParent.get(info.parentID);
+    if (!children) {
+      children = /* @__PURE__ */ new Map();
+      childrenByParent.set(info.parentID, children);
+    }
+    children.set(info.id, {
+      id: info.id,
+      title: info.title,
+      agent: info.agent,
+      created: info.time?.created,
+      updated: info.time?.updated
+    });
+    return true;
+  };
+  const unsubscribe = [];
+  const listen = (type, handler) => {
+    const off = attempt(
+      () => api.event.on(type, (event) => attempt(() => handler(event?.properties ?? {}), void 0)),
+      void 0
+    );
+    if (off) unsubscribe.push(off);
+  };
+  listen("session.created", (properties) => remember(properties.info) && bump());
+  listen("session.updated", (properties) => remember(properties.info) && bump());
+  listen("session.deleted", (properties) => {
+    const info = properties.info;
+    if (info?.parentID && childrenByParent.get(info.parentID)?.delete(info.id)) bump();
+  });
+  listen("session.status", (properties) => {
+    const id = properties.sessionID;
+    const type = properties.status?.type;
+    if (!id || !type) return;
+    const previous = lastStatus.get(id);
+    lastStatus.set(id, type);
+    if (type === "idle" && previous && previous !== "idle") stoppedAt.set(id, Date.now());
+    if (type !== "idle") stoppedAt.delete(id);
+  });
+  const fetchChildren = (parentID) => {
+    if (fetched.has(parentID)) return;
+    fetched.add(parentID);
+    const session = api.client?.session;
+    if (!session?.children) return;
+    void Promise.resolve().then(() => session.children.call(session, { sessionID: parentID })).then((response) => {
+      let changed = false;
+      for (const info of response?.data ?? []) changed = remember(info) || changed;
+      if (changed) bump();
+    }).catch(() => void 0);
+  };
+  const host = {
+    colors() {
+      const theme = api.theme.current;
+      return {
+        text: theme.text,
+        muted: theme.textMuted,
+        spinner: theme.accent,
+        done: mix(theme.success, theme.textMuted, 0.45),
+        error: mix(theme.error, theme.textMuted, 0.35),
+        effort: theme.warning ?? theme.textMuted,
+        effortFaded: mix(theme.warning ?? theme.textMuted, theme.textMuted, 0.45),
+        hover: theme.backgroundElement
+      };
+    },
+    gather(parentID) {
+      version();
+      fetchChildren(parentID);
+      const parts = [];
+      const completions = [];
+      for (const message of api.state.session.messages(parentID) ?? []) {
+        const messageParts = api.state.part(message.id) ?? [];
+        if (message.role === "assistant") {
+          for (const part of messageParts) {
+            if (part.type !== "tool" || !TASK_TOOLS.has(part.tool ?? "")) continue;
+            const state = part.state ?? {};
+            parts.push({
+              status: state.status,
+              input: state.input,
+              metadata: state.metadata,
+              title: state.title,
+              start: state.time?.start,
+              end: state.time?.end
+            });
+          }
+        } else if (message.role === "user") {
+          for (const part of messageParts) {
+            if (part.type !== "text" || part.synthetic !== true || !part.text) continue;
+            completions.push(...completionsIn(part.text, message.time?.created));
+          }
+        }
+      }
+      const known = new Map(childrenByParent.get(parentID) ?? []);
+      for (const part of parts) {
+        const id = partChildID(part);
+        if (!id || known.has(id)) continue;
+        const info = attempt(() => api.state.session.get(id), void 0);
+        known.set(id, {
+          id,
+          title: info?.title,
+          agent: info?.agent,
+          created: info?.time?.created ?? part.start,
+          updated: info?.time?.updated
+        });
+      }
+      return {
+        children: [...known.values()],
+        parts,
+        completions,
+        status: (id) => {
+          const type = attempt(() => api.state.session.status(id)?.type, void 0);
+          if (type === "busy" || type === "retry") return "busy";
+          if (type === "idle") return "idle";
+          return "unknown";
+        },
+        stoppedAt: (id) => stoppedAt.get(id)
+      };
+    },
+    navigate(sessionID) {
+      api.route.navigate("session", { sessionID });
+    }
+  };
+  const sidebar = createSidebar(host);
+  api.slots.register({
+    order: SECTION_ORDER,
+    slots: {
+      sidebar_content(_ctx, props) {
+        return sidebar.render(() => props.session_id);
+      }
+    }
+  });
+  api.lifecycle?.onDispose(() => {
+    for (const off of unsubscribe) attempt(off, void 0);
+    sidebar.dispose();
+  });
+}
+function setupV2(context) {
+  const host = {
+    colors() {
+      const theme = context.theme;
+      const muted = theme.text.muted;
+      const accent = theme.hue.accent[context.themeMode === "light" ? "500" : "200"] ?? theme.text.base;
+      return {
+        text: theme.text.base,
+        muted,
+        spinner: accent,
+        done: mix(theme.text.feedback.success.muted ?? theme.text.feedback.success.base, muted, 0.45),
+        error: mix(theme.text.feedback.error.muted ?? theme.text.feedback.error.base, muted, 0.35),
+        effort: theme.text.feedback.warning?.base ?? muted,
+        effortFaded: mix(theme.text.feedback.warning?.base ?? muted, muted, 0.45),
+        hover: theme.background.raised.base
+      };
+    },
+    gather(parentID) {
+      const children = (context.data.session.list() ?? []).filter((session) => session.parentID === parentID).map((session) => ({
+        id: session.id,
+        title: session.title,
+        agent: session.agent,
+        created: session.time?.created,
+        updated: session.time?.updated
+      }));
+      const parts = [];
+      const completions = [];
+      for (const message of context.data.session.message.list(parentID) ?? []) {
+        if (message.type === "assistant") {
+          for (const item of message.content ?? []) {
+            if (item.type !== "tool" || !TASK_TOOLS.has(item.name ?? "")) continue;
+            parts.push({
+              status: item.state?.status,
+              input: item.state?.input,
+              metadata: item.state?.metadata,
+              start: item.time?.created,
+              end: item.time?.completed
+            });
+          }
+        } else if (message.type === "synthetic" && message.text) {
+          completions.push(...completionsIn(message.text, message.time?.created));
+        }
+      }
+      return {
+        children,
+        parts,
+        completions,
+        status: (id) => {
+          const status = attempt(() => context.data.session.status(id), void 0);
+          if (status === "running") return "busy";
+          if (status === "idle") return "idle";
+          return "unknown";
+        },
+        stoppedAt: () => void 0
+      };
+    },
+    navigate(sessionID) {
+      context.ui.router.navigate({ type: "session", sessionID });
+    }
+  };
+  const sidebar = createSidebar(host);
+  const release = attempt(
+    () => context.ui.slot({
+      append: "sidebar.content",
+      render: (input) => sidebar.render(() => input.sessionID)
+    }),
+    void 0
+  );
+  return () => {
+    if (release) attempt(release, void 0);
+    sidebar.dispose();
+  };
+}
+var tui = async (api) => {
+  attempt(() => registerV1(api), void 0);
+};
+var setup = (context) => attempt(() => setupV2(context), void 0);
+var tui_default = { id: SUBAGENTS_TUI_PLUGIN_ID, tui, setup };
+export {
+  SUBAGENTS_TUI_PLUGIN_ID,
+  tui_default as default,
+  registerV1,
+  setupV2
+};
+//# sourceMappingURL=tui.js.map