@mirrowel/opencode-subagent-explorer 0.1.0 → 0.2.0-dev.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirrowel/opencode-subagent-explorer",
-  "version": "0.1.0",
+  "version": "0.2.0-dev.2",
   "type": "module",
   "description": "OpenCode plugin for exploring and cleaning up subagent sessions of the current session",
   "license": "MIT",

package/src/palette-category.ts

@@ -1,83 +1,83 @@
-/**
- * Shared palette category for Mirrowel OpenCode plugins loaded in the same
- * session. Every family plugin declares its own label into a process-wide
- * registry at TUI activation; a delayed reconciler joins all declared labels
- * (alphabetical, deterministic) and writes the join into every registered
- * command object, so the palette shows one combined section. A plugin loaded
- * alone keeps its own name; third-party plugins never declare and stay out.
- *
- * Labels are defined only in each plugin's entry point - this module carries
- * no per-plugin data. Keep the logic copies in sync across family repos.
- */
-
-const REGISTRY_KEY = Symbol.for("mirrowel.opencode.paletteCategory")
-
-// v1 command objects group via `category`; v2 keymap commands use `group`.
-// Stamping both keeps one registry meaningful on both hosts.
-type CategorizedCommand = { category?: string; group?: string }
-type RegistryEntry = { label: string; commands: CategorizedCommand[] }
-type Registry = { entries: RegistryEntry[] }
-
-function registry(): Registry {
-  const globals = globalThis as { [key: symbol]: Registry | undefined }
-  if (!globals[REGISTRY_KEY]) globals[REGISTRY_KEY] = { entries: [] }
-  return globals[REGISTRY_KEY]!
-}
-
-function joinLabels(labels: string[]): string {
-  if (labels.length <= 1) return labels[0] ?? ""
-  return `${labels.slice(0, -1).join(", ")} & ${labels[labels.length - 1]!}`
-}
-
-function joinedCategory(): string {
-  const labels = [...new Set(registry().entries.map((entry) => entry.label))].sort((a, b) => a.localeCompare(b))
-  return joinLabels(labels)
-}
-
-/**
- * Declares this plugin's category label and attaches command objects whose
- * `category` field is kept in sync. Returns the current join, so the very
- * first registration already renders correctly even before reconcilers run.
- */
-export function declarePaletteCategory(label: string, ...commands: CategorizedCommand[]): string {
-  const reg = registry()
-  let entry = reg.entries.find((item) => item.label === label)
-  if (!entry) {
-    entry = { label, commands: [] }
-    reg.entries.push(entry)
-  }
-  for (const command of commands) {
-    if (command && !entry.commands.includes(command)) entry.commands.push(command)
-  }
-  reconcilePaletteCategories()
-  return joinedCategory()
-}
-
-/** Live join for callback-style command registration (reads fresh each call). */
-export function currentPaletteCategory(): string {
-  return joinedCategory()
-}
-
-/** Writes the current join into every declared command (idempotent). */
-export function reconcilePaletteCategories(): void {
-  const category = joinedCategory()
-  for (const entry of registry().entries) {
-    for (const command of entry.commands) {
-      command.category = category
-      command.group = category
-    }
-  }
-}
-
-/** Delayed reconciles so later-activating siblings join before the user opens the palette. */
-export function schedulePaletteReconcile(delaysMs: readonly number[] = [2000, 6000]): void {
-  for (const delay of delaysMs) {
-    const timer = setTimeout(() => reconcilePaletteCategories(), delay)
-    ;(timer as { unref?: () => void }).unref?.()
-  }
-}
-
-/** Tests only: drop all declarations. */
-export function __resetPaletteRegistry(): void {
-  ;(globalThis as { [key: symbol]: Registry | undefined })[REGISTRY_KEY] = undefined
-}
+/**
+ * Shared palette category for Mirrowel OpenCode plugins loaded in the same
+ * session. Every family plugin declares its own label into a process-wide
+ * registry at TUI activation; a delayed reconciler joins all declared labels
+ * (alphabetical, deterministic) and writes the join into every registered
+ * command object, so the palette shows one combined section. A plugin loaded
+ * alone keeps its own name; third-party plugins never declare and stay out.
+ *
+ * Labels are defined only in each plugin's entry point - this module carries
+ * no per-plugin data. Keep the logic copies in sync across family repos.
+ */
+
+const REGISTRY_KEY = Symbol.for("mirrowel.opencode.paletteCategory")
+
+// v1 command objects group via `category`; v2 keymap commands use `group`.
+// Stamping both keeps one registry meaningful on both hosts.
+type CategorizedCommand = { category?: string; group?: string }
+type RegistryEntry = { label: string; commands: CategorizedCommand[] }
+type Registry = { entries: RegistryEntry[] }
+
+function registry(): Registry {
+  const globals = globalThis as { [key: symbol]: Registry | undefined }
+  if (!globals[REGISTRY_KEY]) globals[REGISTRY_KEY] = { entries: [] }
+  return globals[REGISTRY_KEY]!
+}
+
+function joinLabels(labels: string[]): string {
+  if (labels.length <= 1) return labels[0] ?? ""
+  return `${labels.slice(0, -1).join(", ")} & ${labels[labels.length - 1]!}`
+}
+
+function joinedCategory(): string {
+  const labels = [...new Set(registry().entries.map((entry) => entry.label))].sort((a, b) => a.localeCompare(b))
+  return joinLabels(labels)
+}
+
+/**
+ * Declares this plugin's category label and attaches command objects whose
+ * `category` field is kept in sync. Returns the current join, so the very
+ * first registration already renders correctly even before reconcilers run.
+ */
+export function declarePaletteCategory(label: string, ...commands: CategorizedCommand[]): string {
+  const reg = registry()
+  let entry = reg.entries.find((item) => item.label === label)
+  if (!entry) {
+    entry = { label, commands: [] }
+    reg.entries.push(entry)
+  }
+  for (const command of commands) {
+    if (command && !entry.commands.includes(command)) entry.commands.push(command)
+  }
+  reconcilePaletteCategories()
+  return joinedCategory()
+}
+
+/** Live join for callback-style command registration (reads fresh each call). */
+export function currentPaletteCategory(): string {
+  return joinedCategory()
+}
+
+/** Writes the current join into every declared command (idempotent). */
+export function reconcilePaletteCategories(): void {
+  const category = joinedCategory()
+  for (const entry of registry().entries) {
+    for (const command of entry.commands) {
+      command.category = category
+      command.group = category
+    }
+  }
+}
+
+/** Delayed reconciles so later-activating siblings join before the user opens the palette. */
+export function schedulePaletteReconcile(delaysMs: readonly number[] = [2000, 6000]): void {
+  for (const delay of delaysMs) {
+    const timer = setTimeout(() => reconcilePaletteCategories(), delay)
+    ;(timer as { unref?: () => void }).unref?.()
+  }
+}
+
+/** Tests only: drop all declarations. */
+export function __resetPaletteRegistry(): void {
+  ;(globalThis as { [key: symbol]: Registry | undefined })[REGISTRY_KEY] = undefined
+}

package/src/sessions.ts

@@ -5,6 +5,7 @@
  * timeout-bounded, and envelope-unwrapping ({data} vs raw) so one code path
  * serves the v1 and v2 hosts and the studio embed alike.
  */
+import { existsSync, readFileSync } from "node:fs"
 
 export type SessionLite = {
   id: string
@@ -81,16 +82,26 @@ export function normalizeSession(raw: unknown): SessionLite | undefined {
 }
 
 /** Lists sessions for a directory. Tries the v2 client's flat params first,
- * then the v1 `{query}` shape; unwraps both envelope styles. Fail-soft. */
+ * then the v1 `{query}` shape; unwraps both envelope styles. Fail-soft.
+ *
+ * EXPLICIT LARGE LIMIT: OpenCode's Session.list defaults to a 100-row page
+ * (ordered by time_updated DESC, session.ts `limit ?? 100`) - a plain call
+ * silently hides older sessions, which truncated large trees (100+ subagents
+ * showed ~85) and made cleanups miss everything past the first page. The
+ * server imposes no max on limit (NonNegativeInt), and its `start` cursor
+ * filters to NEWER sessions (gte), so downward paging is impossible by
+ * design - one large bounded page is the honest shape. */
+const SESSION_LIST_LIMIT = 5000
+
 export async function fetchSessions(client: unknown, directory: string): Promise<SessionLite[] | undefined> {
   const namespace = (client as { session?: Record<string, any> } | undefined)?.session
   if (!namespace?.list) return undefined
   const calls: (() => Promise<unknown>)[] = [
-    () => namespace.list({ directory }),
-    () => namespace.list({ query: { directory } }),
+    () => namespace.list({ directory, limit: SESSION_LIST_LIMIT }),
+    () => namespace.list({ query: { directory, limit: SESSION_LIST_LIMIT } }),
   ]
   for (const call of calls) {
-    const result = unwrap(await withTimeout(call))
+    const result = unwrap(await withTimeout(call, 8000))
     if (Array.isArray(result)) return result.map(normalizeSession).filter((s): s is SessionLite => !!s)
   }
   return undefined
@@ -99,26 +110,34 @@ export async function fetchSessions(client: unknown, directory: string): Promise
 /** Running session ids via `session.active()` with the `session.status()`
  * fallback (busy/retry = running). `undefined` when neither exists or both
  * fail — callers must treat that as "unknown", never "idle". */
+/**
+ * Running session ids via `session.active()` with the `session.status()`
+ * fallback (busy/retry/unknown-type = running). Mirrors the Config Studio
+ * reload coordinator's proven probing: PRESENCE in the active map means
+ * running (values may be falsy and must not be filtered), the status map
+ * keys carry `.type` (not `.status`), and all calls stay attached to the
+ * namespace object (SDK methods dereference `this`). `undefined` when
+ * neither exists or both fail - callers must treat that as "unknown",
+ * never "idle".
+ */
 export async function fetchActiveSessionIDs(client: unknown): Promise<Set<string> | undefined> {
   const namespace = (client as { session?: Record<string, any> } | undefined)?.session
   if (!namespace) return undefined
   if (typeof namespace.active === "function") {
-    const active = unwrap(await withTimeout(() => namespace.active()))
-    if (active && typeof active === "object") {
-      const ids = new Set<string>()
-      for (const [id, value] of Object.entries(active as Record<string, unknown>)) {
-        if (value) ids.add(id)
-      }
-      return ids
+    const result = await withTimeout(() => namespace.active())
+    const data = result && typeof result === "object" ? (result as { data?: unknown }).data : undefined
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      return new Set(Object.keys(data as Record<string, unknown>))
     }
   }
   if (typeof namespace.status === "function") {
-    const status = unwrap(await withTimeout(() => namespace.status()))
-    if (status && typeof status === "object") {
+    const result = await withTimeout(() => namespace.status())
+    const data = result && typeof result === "object" ? (result as { data?: unknown }).data : undefined
+    if (data && typeof data === "object" && !Array.isArray(data)) {
       const ids = new Set<string>()
-      for (const [id, value] of Object.entries(status as Record<string, any>)) {
-        const state = value?.status ?? value
-        if (state === "busy" || state === "retry") ids.add(id)
+      for (const [id, value] of Object.entries(data as Record<string, any>)) {
+        const type = value && typeof value === "object" ? (value.type ?? value.status) : value
+        if (type === undefined || type === "busy" || type === "retry") ids.add(id)
       }
       return ids
     }
@@ -126,6 +145,108 @@ export async function fetchActiveSessionIDs(client: unknown): Promise<Set<string
   return undefined
 }
 
+/** Minimal agent-variants sidecar view: which parents exist and which have
+ * the base disabled. Absent file / parse errors -> empty (fail-soft). */
+export type AvSidecar = {
+  parents: Map<string, { disableBase: boolean }>
+}
+
+export function loadAvSidecar(globalConfigDir: string | undefined): AvSidecar {
+  const parents = new Map<string, { disableBase: boolean }>()
+  if (!globalConfigDir) return { parents }
+  try {
+    const path = `${globalConfigDir.replace(/[\\/]+$/, "")}/agent-variants.jsonc`
+    if (!existsSync(path)) return { parents }
+    const raw = readFileSync(path, "utf8")
+    const json = JSON.parse(stripJsoncComments(raw)) as {
+      agents?: Record<string, { disable_base?: boolean; disable?: boolean }>
+    }
+    for (const [parent, entry] of Object.entries(json.agents ?? {})) {
+      if (!entry || typeof entry !== "object") continue
+      parents.set(parent, { disableBase: entry.disable_base === true && entry.disable !== true })
+    }
+  } catch {
+    // Not our file to complain about - AV may simply not be installed.
+  }
+  return { parents }
+}
+
+function stripJsoncComments(text: string): string {
+  // Block comments, line comments, and trailing commas before } or ].
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/(^|[^:"'\\])\/\/.*$/gm, "$1")
+    .replace(/,(\s*[}\]])/g, "$1")
+}
+
+/** child session id -> the AV variant that created it (from the parent's
+ * task-part metadata). Paged backward through the parent's history via the
+ * `before` message cursor (up to ATTRIBUTION_PAGES pages), so large trees
+ * attribute most children instead of only the newest ~15 tasks; very deep
+ * history simply stays unattributed (the row then shows the parent agent,
+ * never a hidden badge - see explorerRows). */
+export type VariantAttribution = Map<string, { alias: string; parent: string }>
+
+const ATTRIBUTION_PAGE_SIZE = 100
+const ATTRIBUTION_PAGES = 5
+
+export async function fetchVariantAttribution(
+  client: unknown,
+  parentSessionID: string | undefined,
+  directory: string | undefined,
+  avParents: Set<string>,
+): Promise<VariantAttribution> {
+  const map: VariantAttribution = new Map()
+  if (avParents.size === 0 || !parentSessionID) return map
+  const namespace = (client as { session?: Record<string, any> } | undefined)?.session
+  if (!namespace || typeof namespace.messages !== "function") return map
+  const fetchPage = (before?: string): Promise<unknown> => {
+    const query: Record<string, unknown> = { directory, limit: ATTRIBUTION_PAGE_SIZE }
+    if (before) query.before = before
+    // Try the flat (v2-gen) shape first, then the legacy {path, query} wrapper.
+    const flat = namespace.messages!({ sessionID: parentSessionID, ...query })
+    return flat instanceof Promise ? flat : namespace.messages!({ path: { id: parentSessionID }, query })
+  }
+  const asList = (value: unknown): Array<{ parts?: Array<Record<string, any>> }> | undefined => {
+    if (Array.isArray(value)) return value as Array<{ parts?: Array<Record<string, any>> }>
+    if (value && typeof value === "object") {
+      const unwrapped = (value as { data?: unknown }).data
+      if (Array.isArray(unwrapped)) return unwrapped as Array<{ parts?: Array<Record<string, any>> }>
+    }
+    return undefined
+  }
+  let before: string | undefined
+  const seenCursors = new Set<string>()
+  for (let page = 0; page < ATTRIBUTION_PAGES; page++) {
+    const messages = await withTimeout(() => fetchPage(before), 8000)
+    const list = asList(messages)
+    if (!list || list.length === 0) break
+    for (const message of list) {
+      for (const part of message.parts ?? []) {
+        if (part?.type !== "tool" || part.tool !== "task") continue
+        const metadata = part.state?.metadata as Record<string, any> | undefined
+        const child = metadata?.sessionId
+        const variantMeta = metadata?.agentVariants as Record<string, unknown> | undefined
+        const alias = variantMeta?.alias
+        const routedAgent = variantMeta?.routedAgent
+        if (typeof child === "string" && typeof alias === "string" && !map.has(child)) {
+          map.set(child, {
+            alias,
+            parent: typeof routedAgent === "string" ? routedAgent : alias.replace(/-[a-z0-9-]+$/, ""),
+          })
+        }
+      }
+    }
+    if (list.length < ATTRIBUTION_PAGE_SIZE) break
+    const last = list[list.length - 1] as { id?: string; info?: { id?: string } }
+    const next = last?.info?.id ?? last?.id
+    if (!next || seenCursors.has(next)) break
+    seenCursors.add(next)
+    before = next
+  }
+  return map
+}
+
 /** Builds the recursive subagent tree for `rootID`. Unknown-parent sessions
  * are ignored (not part of this session's tree). Guarded against cycles. */
 export function buildSessionTree(sessions: SessionLite[], rootID: string): SessionTreeNode[] {
@@ -221,12 +342,35 @@ export function isHiddenAgent(agent: string | undefined, hidden: Set<string>, co
   return !configAgents.has(agent) && !BUILTIN_AGENTS.has(agent) && !agent.startsWith("av:")
 }
 
+/** Badge decision for explorer rows: variant children and children of
+ * AV-managed parents never carry the hidden badge - a hidden AV parent is
+ * agent-variants' base-disable ("must use a variant"), not a background
+ * agent, and the decision must not depend on attribution windows. Only
+ * genuinely hidden non-AV agents (plugin background agents, hidden custom
+ * agents without variants) keep the badge. */
+export function rowHidden(
+  variant: unknown,
+  agent: string | undefined,
+  avParents: { has: (id: string) => boolean },
+  hidden: Set<string>,
+  configAgents: Set<string>,
+): boolean {
+  if (variant) return false
+  if (agent && avParents.has(agent)) return false
+  return isHiddenAgent(agent, hidden, configAgents)
+}
+
 /** Deletes one session through whichever delete method the host client
  * exposes (`session.delete`, `session.remove`). Returns false when no
- * method exists or the call failed. */
+ * method exists or the call failed. An `{error}` envelope without `data`
+ * (the runtime's non-throwing failure shape) counts as a failure, not a
+ * success - the server's remove handler swallows internal errors and can
+ * still answer, so callers verify after batch deletes. */
 export async function deleteSession(client: unknown, sessionID: string): Promise<boolean> {
   const namespace = (client as { session?: Record<string, any> } | undefined)?.session
   if (!namespace) return false
+  const isErrorEnvelope = (value: unknown): boolean =>
+    !!value && typeof value === "object" && "error" in (value as Record<string, unknown>) && !("data" in (value as Record<string, unknown>))
   const shapes: (() => Promise<unknown>)[] = []
   if (typeof namespace.delete === "function") {
     shapes.push(() => namespace.delete({ sessionID }), () => namespace.delete({ path: { sessionID } }), () => namespace.delete({ path: { id: sessionID } }), () => namespace.delete({ id: sessionID }))
@@ -236,7 +380,9 @@ export async function deleteSession(client: unknown, sessionID: string): Promise
   }
   for (const call of shapes) {
     const result = await withTimeout(call)
-    if (result !== undefined) return true
+    if (result === undefined) continue
+    if (isErrorEnvelope(result)) continue
+    return true
   }
   return false
 }

package/src/wizard.tsx

@@ -24,13 +24,16 @@ import {
   fetchActiveSessionIDs,
   fetchSessionDetails,
   fetchSessions,
+  fetchVariantAttribution,
   formatAge,
   hiddenAgentIDs,
-  isHiddenAgent,
+  loadAvSidecar,
   parentCandidates,
+  rowHidden,
   type CleanupPlan,
   type SessionLite,
   type SessionTreeNode,
+  type VariantAttribution,
 } from "./sessions.js"
 
 export type ExplorerRow = {
@@ -38,6 +41,7 @@ export type ExplorerRow = {
   depth: number
   running: boolean
   hidden: boolean
+  variant?: { alias: string; parent: string }
 }
 
 export type ExplorerData = {
@@ -46,6 +50,10 @@ export type ExplorerData = {
   activeKnown: boolean
   hidden: Set<string>
   configAgents: Set<string>
+  /** child session id -> creating AV variant (recent history only). */
+  variantOf: VariantAttribution
+  /** AV sidecar parents (empty when agent-variants is not installed). */
+  avParents: Map<string, { disableBase: boolean }>
 }
 
 export type TreeAction =
@@ -57,16 +65,30 @@ export type TreeAction =
   | { type: "size" }
   | { type: "exit" }
 
-export async function loadExplorerData(api: TuiPluginApi, directory: string): Promise<ExplorerData | undefined> {
+function globalConfigDirOf(api: TuiPluginApi): string | undefined {
+  const config = api.state.path?.config
+  if (!config) return undefined
+  const index = Math.max(config.lastIndexOf("/"), config.lastIndexOf("\\"))
+  return index > 0 ? config.slice(0, index) : undefined
+}
+
+export async function loadExplorerData(api: TuiPluginApi, directory: string, rootOverride?: string): Promise<ExplorerData | undefined> {
   const sessions = await fetchSessions(api.client, directory)
   if (!sessions) return undefined
-  const activeIDs = await fetchActiveSessionIDs(api.client)
+  const [activeIDs, avSidecar] = await Promise.all([
+    fetchActiveSessionIDs(api.client),
+    Promise.resolve(loadAvSidecar(globalConfigDirOf(api))),
+  ])
+  const rootID = rootOverride ?? currentSessionID(api.currentSessionID?.(), sessions)
+  const variantOf = await fetchVariantAttribution(api.client, rootID, directory, new Set(avSidecar.parents.keys()))
   return {
     sessions,
     activeIDs,
     activeKnown: activeIDs !== undefined,
     hidden: hiddenAgentIDs(api.state.config),
     configAgents: configAgentIDs(api.state.config),
+    variantOf,
+    avParents: avSidecar.parents,
   }
 }
 
@@ -74,11 +96,16 @@ export function explorerRows(tree: SessionTreeNode[], data: ExplorerData): Explo
   const rows: ExplorerRow[] = []
   const walk = (nodes: SessionTreeNode[], depth: number) => {
     for (const node of nodes) {
+      const variant = data.variantOf.get(node.session.id)
+      const agent = node.session.agent
       rows.push({
         session: node.session,
         depth,
         running: data.activeIDs?.has(node.session.id) ?? false,
-        hidden: isHiddenAgent(node.session.agent, data.hidden, data.configAgents),
+        // Badge decision is window-independent (see rowHidden): children of
+        // AV-managed parents are never badged, attributed or not.
+        hidden: rowHidden(variant, agent, data.avParents, data.hidden, data.configAgents),
+        variant,
       })
       walk(node.children, depth + 1)
     }
@@ -87,6 +114,10 @@ export function explorerRows(tree: SessionTreeNode[], data: ExplorerData): Explo
   return rows
 }
 
+export function agentLabelOf(row: Pick<ExplorerRow, "session" | "variant">): string {
+  return row.variant?.alias ?? row.session.agent ?? "unknown"
+}
+
 function themeOf(api: TuiPluginApi) {
   return api.theme.current
 }
@@ -327,7 +358,7 @@ export function SubagentTreeDialog(props: {
                     onMouseUp={() => props.onDone({ type: "delete", row })}
                   >
                     <text fg={titleFg()} flexShrink={0}>{row.running ? "▶" : "·"}</text>
-                    <text width={agentWidth} flexShrink={0} fg={active() ? theme().background : theme().textMuted} wrapMode="none" overflow="hidden"><b>{truncate(row.session.agent ?? "agent", agentWidth)}</b></text>
+                    <text width={agentWidth} flexShrink={0} fg={active() ? theme().background : theme().textMuted} wrapMode="none" overflow="hidden"><b>{truncate(agentLabelOf(row), agentWidth)}</b></text>
                     <Show when={row.hidden}>
                       <text width={badgeWidth} flexShrink={0} fg={badgeFg()} wrapMode="none" overflow="hidden">{"[hidden]"}</text>
                     </Show>
@@ -480,7 +511,7 @@ function showConfirm(api: TuiPluginApi, props: { title: string; message: string
 
 async function deleteOne(api: TuiPluginApi, row: ExplorerRow): Promise<boolean> {
   const label = `${rowTitle(row)}${row.hidden ? " [hidden agent]" : ""}`
-  const summary = `${label}\nagent: ${row.session.agent ?? "unknown"}\nlast activity: ${formatAge(row.session.updated ?? row.session.created)}\n\nDeleting a session permanently removes it, its messages, and its history. The parent session keeps the task result text; only the jump target is lost.`
+  const summary = `${label}\n${row.variant ? `variant: ${row.variant.alias} (of ${row.variant.parent})` : `agent: ${row.session.agent ?? "unknown"}`}\nlast activity: ${formatAge(row.session.updated ?? row.session.created)}\n\nDeleting a session permanently removes it, its messages, and its history. The parent session keeps the task result text; only the jump target is lost.`
   const confirmed = row.running
     ? await showDangerConfirm(api, {
         title: "Delete RUNNING subagent session?",
@@ -498,7 +529,26 @@ async function deleteOne(api: TuiPluginApi, row: ExplorerRow): Promise<boolean>
   return ok
 }
 
-async function runCleanup(api: TuiPluginApi, plan: CleanupPlan, rootTitle: string): Promise<number> {
+function CleanupProgressDialog(props: { api: TuiPluginApi; done: () => number; total: number }) {
+  const theme = () => themeOf(props.api)
+  const popMode = props.api.mode.push("subagent-explorer.cleanup")
+  onCleanup(() => popMode())
+  const done = props.done
+  const total = props.total
+  return (
+    <box flexDirection="column" width="100%" paddingLeft={2} paddingRight={2} paddingTop={2} paddingBottom={2} gap={1}>
+      <text fg={theme().text}><b>{`Cleaning up idle subagent sessions…`}</b></text>
+      <text fg={theme().textMuted}>{`${done()} / ${total} deleted`}</text>
+      <text fg={theme().textMuted}>{"This dialog closes when the batch finishes."}</text>
+    </box>
+  )
+}
+
+function showCleanupProgress(api: TuiPluginApi, done: () => number, total: number): void {
+  api.ui.dialog.replace(() => <CleanupProgressDialog api={api} done={done} total={total} />, () => {})
+}
+
+async function runCleanup(api: TuiPluginApi, plan: CleanupPlan, rootTitle: string, directory: string, rootID: string): Promise<number> {
   if (plan.deletable.length === 0) {
     await showInfo(api, {
       title: "Nothing to clean up",
@@ -514,18 +564,49 @@ async function runCleanup(api: TuiPluginApi, plan: CleanupPlan, rootTitle: strin
   })
   if (!confirmed) return 0
   let deleted = 0
+  const [progressDone, setProgressDone] = createSignal(0)
+  showCleanupProgress(api, progressDone, plan.deletable.length)
   for (const session of plan.deletable) {
-    if (await deleteSession(api.client, session.id)) deleted += 1
+    if (await deleteSession(api.client, session.id)) {
+      deleted += 1
+      setProgressDone(deleted)
+    }
   }
+  // Verify against a fresh (full, un-capped) fetch: the server's remove
+  // handler swallows internal errors and still answers, and the host may
+  // spawn new children while we work - report what actually remains.
+  const remainingIdle = await remainingIdleCount(api, directory, rootID)
+  api.ui.dialog.clear()
   const failed = plan.deletable.length - deleted
   api.ui.toast({
-    variant: failed > 0 ? "warning" : "default",
+    variant: failed > 0 || remainingIdle > 0 ? "warning" : "default",
     title: "Cleanup finished",
-    message: failed > 0 ? `Deleted ${deleted}, failed ${failed}.` : `Deleted ${deleted} session(s).`,
+    message:
+      remainingIdle > 0
+        ? `Deleted ${deleted}. ${remainingIdle} idle session(s) still remain${failed > 0 ? ` (${failed} delete call(s) failed - re-run cleanup or delete rows individually)` : " - re-run cleanup for the newly-idle"}.`
+        : failed > 0
+          ? `Deleted ${deleted}, failed ${failed}.`
+          : `Deleted ${deleted} session(s).`,
   })
   return deleted
 }
 
+async function remainingIdleCount(api: TuiPluginApi, directory: string, rootID: string): Promise<number> {
+  const sessions = await fetchSessions(api.client, directory)
+  if (!sessions) return 0
+  const active = await fetchActiveSessionIDs(api.client)
+  const rows = explorerRows(buildSessionTree(sessions, rootID), {
+    sessions,
+    activeIDs: active,
+    activeKnown: active !== undefined,
+    hidden: new Set(),
+    configAgents: new Set(),
+    variantOf: new Map(),
+    avParents: new Map(),
+  })
+  return rows.filter((row) => !row.running).length
+}
+
 function showRootPicker(api: TuiPluginApi, sessions: SessionLite[], currentRoot: string | undefined): Promise<string | undefined> {
   return new Promise((resolve) => {
     let settled = false
@@ -556,16 +637,29 @@ function showRootPicker(api: TuiPluginApi, sessions: SessionLite[], currentRoot:
   })
 }
 
-async function showDetails(api: TuiPluginApi, row: ExplorerRow): Promise<void> {
+async function showDetails(api: TuiPluginApi, row: ExplorerRow, data: ExplorerData): Promise<void> {
   const details = await fetchSessionDetails(api.client, row.session.id)
+  const parentAgent = row.session.agent ?? "unknown"
   const lines = [
     `title: ${rowTitle(row)}`,
-    `agent: ${row.session.agent ?? "unknown"}${row.hidden ? " (hidden/background)" : ""}`,
+    row.variant
+      ? `variant: ${row.variant.alias} (of ${row.variant.parent})`
+      : `agent: ${parentAgent}${row.hidden ? " (hidden/background)" : ""}`,
+  ]
+  if (row.variant) {
+    const parentEntry = data.avParents.get(row.variant.parent)
+    if (parentEntry) {
+      lines.push(`base ${row.variant.parent}: ${parentEntry.disableBase ? "disabled (variants only)" : "enabled"}`)
+    }
+  } else if (data.avParents.has(parentAgent)) {
+    lines.push(`base ${parentAgent}: ${data.avParents.get(parentAgent)?.disableBase ? "disabled (variants only)" : "enabled"}`)
+  }
+  lines.push(
     `session: ${row.session.id}`,
     `status: ${row.running ? "running" : "idle"}`,
     `created: ${formatAge(row.session.created)}`,
     `last activity: ${formatAge(row.session.updated ?? row.session.created)}`,
-  ]
+  )
   if (details) {
     lines.push(`messages: ${details.messageCount}`)
     if (details.model) lines.push(`last model: ${details.model}`)
@@ -793,7 +887,7 @@ export async function mainMenu(api: TuiPluginApi): Promise<void> {
   }
   let rootOverride: string | undefined
   while (true) {
-    const data = await loadExplorerData(api, directory)
+    const data = await loadExplorerData(api, directory, rootOverride)
     if (!data) {
       await showInfo(api, {
         title: "Subagent Explorer",
@@ -833,11 +927,11 @@ export async function mainMenu(api: TuiPluginApi): Promise<void> {
       continue
     }
     if (action.type === "details") {
-      await showDetails(api, action.row)
+      await showDetails(api, action.row, data)
       continue
     }
     if (action.type === "cleanup") {
-      await runCleanup(api, cleanupTargets(tree, data.activeIDs), rootSession?.title ?? rootID)
+      await runCleanup(api, cleanupTargets(tree, data.activeIDs), rootSession?.title ?? rootID, directory, rootID)
       continue
     }
   }