@mirrowel/opencode-subagent-explorer 0.2.0-dev.1 → 0.2.0-dev.3

package/src/sessions.ts

@@ -82,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
@@ -170,10 +180,16 @@ function stripJsoncComments(text: string): string {
 }
 
 /** child session id -> the AV variant that created it (from the parent's
- * task-part metadata). Windowed like AV's own correlation: only recent
- * history is scanned, deep/old tasks simply stay unattributed. */
+ * 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,
@@ -184,32 +200,55 @@ export async function fetchVariantAttribution(
   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 messages = await withTimeout(() => {
-    // Try the flat (v2-gen) shape first, then the legacy {query} wrapper.
-    const flat = namespace.messages({ sessionID: parentSessionID, directory, limit: 50 })
-    return flat instanceof Promise ? flat : namespace.messages({ path: { id: parentSessionID }, query: { directory, limit: 50 } })
-  })
-  const list = Array.isArray(messages)
-    ? messages
-    : messages && typeof messages === "object"
-      ? ((messages as { data?: unknown }).data ?? messages)
-      : undefined
-  if (!Array.isArray(list)) return map
-  for (const message of list as Array<{ parts?: Array<Record<string, any>> }>) {
-    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-]+$/, ""),
-        })
+  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
+        // Two alias sources: the after-hook metadata stamp (terminal
+        // completed parts) and the before-hook description annotation -
+        // aborted/error parts never receive the metadata stamp, but the
+        // annotation ("(@alias variant)" appended at call time) persists.
+        const description = part.state?.input?.description
+        const descriptionMatch = typeof description === "string" ? description.match(/\s+\(@(\S+) variant\)$/) : undefined
+        const alias = (typeof variantMeta?.alias === "string" ? variantMeta.alias : undefined) ?? descriptionMatch?.[1]
+        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
 }
@@ -309,12 +348,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 }))
@@ -324,7 +386,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

@@ -27,9 +27,9 @@ import {
   fetchVariantAttribution,
   formatAge,
   hiddenAgentIDs,
-  isHiddenAgent,
   loadAvSidecar,
   parentCandidates,
+  rowHidden,
   type CleanupPlan,
   type SessionLite,
   type SessionTreeNode,
@@ -97,14 +97,14 @@ export function explorerRows(tree: SessionTreeNode[], data: ExplorerData): Explo
   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,
-        // Variant children are normal sessions re-attributed to their alias;
-        // only the base agent itself (or non-AV hidden agents) carries the
-        // hidden badge.
-        hidden: variant ? false : 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)
@@ -529,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",
@@ -545,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
@@ -881,7 +931,7 @@ export async function mainMenu(api: TuiPluginApi): Promise<void> {
       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
     }
   }