@signalridge/pi-subagents 1.11.1 → 1.12.0

package/src/question-origin.ts

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** Native ancestry, including metadata that does not participate in model context. */
+export function captureQuestionOrigin(ctx: ExtensionContext): (current: ExtensionContext | undefined) => boolean {
+  const manager = ctx.sessionManager;
+  const sessionId = manager.getSessionId();
+  const prefix = manager.getBranch().map(entry => createHash("sha256").update(JSON.stringify(entry)).digest("hex"));
+  let retired = false;
+  return current => {
+    if (retired) return false;
+    try {
+      const branch = manager.getBranch();
+      const valid = current !== undefined && current.sessionManager === manager &&
+        manager.getSessionId() === sessionId && branch.length >= prefix.length &&
+        prefix.every((hash, index) => createHash("sha256").update(JSON.stringify(branch[index])).digest("hex") === hash);
+      if (!valid) retired = true;
+      return valid;
+    } catch {
+      retired = true;
+      return false;
+    }
+  };
+}

package/src/supervisor.ts

@@ -5,7 +5,7 @@
  * subagent that hit a genuine fork in the road could only guess, finish wrong,
  * and have the guess discovered later in its result.
  *
- * The answer comes from the HUMAN, not from a supervising model. Our subagents
+ * By default the answer comes from the HUMAN. Our subagents
  * share the parent's `ExtensionContext`, so the parent's UI is directly
  * reachable — asking the person who is sitting there is both cheaper and more
  * correct than delegating the judgement to another model, and it is the same
@@ -13,10 +13,14 @@
  *
  * That reachability is also why this is ~80 lines rather than a filesystem
  * channel with a poller on each end: in-process, the question is one promise.
+ * Explicit background-only parent mode delegates ordinary clarification to the
+ * existing main session through parent-questions.ts; permission/approval tools
+ * still reach the human and no separate supervising model is created.
  */
 
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
+import type { ParentQuestionHandler } from "./parent-questions.js";
 import { sanitizeDisplayText, truncateCodePoints } from "./ui/safe-text.js";
 
 /** Longest question a child may put to the parent, in characters. */
@@ -38,6 +42,8 @@ export interface SupervisorToolContext {
   ask?: SupervisorAsk;
   /** Actual type/name of the asking agent, for the prompt title. */
   agentLabel: string;
+  /** Explicit background-only ordinary-clarification channel, not approval. */
+  parentQuestion?: ParentQuestionHandler;
 }
 
 function textResult(text: string, isError = false) {
@@ -45,26 +51,30 @@ function textResult(text: string, isError = false) {
 }
 
 /**
- * Build the `contact_supervisor` tool, or nothing when no human can answer.
+ * Build `contact_supervisor`, or nothing without a human or explicit parent channel.
  *
  * Returning an empty array rather than a tool that always fails is deliberate,
  * and matches how nested tools are handled: injecting a tool whose every call
  * is an error spends context to teach the model an affordance it does not have.
- * Headless and RPC sessions therefore see no such tool at all.
+ * Default headless sessions therefore see no such tool. An explicit parent
+ * channel can answer ordinary clarification without a human UI.
  */
 export function createSupervisorTool(context: SupervisorToolContext) {
-  if (!context.ask) return [];
+  if (!context.ask && !context.parentQuestion) return [];
   const ask = context.ask;
 
   return [
     defineTool({
       name: "contact_supervisor",
       label: "Ask Supervisor",
-      description:
-        "Ask the human who started you a question and wait for their answer. Use ONLY for a decision you cannot make yourself and cannot defer: an ambiguous requirement where the readings lead to materially different work, a destructive step that needs confirmation, or missing information nothing available to you can supply. It interrupts a person, so prefer stating an assumption and continuing. Returns their answer, or tells you they declined — in which case proceed on your best judgement and say what you assumed.",
+      description: context.parentQuestion
+        ? "Ask the main agent an ordinary task clarification and await its answer. Only use for missing information or ambiguous requirements you cannot resolve or defer. Never use this channel for permission, destructive-action confirmation, or approval; the main agent cannot authorize new actions or override a human denial. Prefer stating an assumption and continuing. A timeout, cancellation, or decline is no answer, not approval."
+        : "Ask the human who started you a question and wait for their answer. Use ONLY for a decision you cannot make yourself and cannot defer: an ambiguous requirement where the readings lead to materially different work, a destructive step that needs confirmation, or missing information nothing available to you can supply. It interrupts a person, so prefer stating an assumption and continuing. Returns their answer, or tells you they declined — in which case proceed on your best judgement and say what you assumed.",
       parameters: Type.Object({
         question: Type.String({
-          description: "The question, self-contained. The human cannot see your conversation.",
+          description: context.parentQuestion
+            ? "A self-contained ordinary clarification. Only this explicit bounded question reaches the main agent; do not include credentials or request permission."
+            : "The question, self-contained. The human cannot see your conversation.",
           maxLength: MAX_QUESTION,
         }),
         options: Type.Optional(
@@ -74,7 +84,17 @@ export function createSupervisorTool(context: SupervisorToolContext) {
           }),
         ),
       }),
-      execute: async (_toolCallId, params) => {
+      execute: async (_toolCallId, params, signal) => {
+        if (context.parentQuestion) {
+          const reply = await context.parentQuestion(params.question, params.options, signal);
+          return {
+            content: [{ type: "text" as const, text: reply.status === "answered"
+              ? `Main agent clarification (NOT human approval or a permission grant): ${reply.answer}`
+              : `No answer (${reply.reason}). Proceed only within existing authorization, state any safe assumption, or stop if human authorization is required.` }],
+            details: reply,
+          };
+        }
+        if (!ask) return textResult("No supervisor is available.", true);
         // Both the question and any option labels are model-authored text about
         // to be drawn into the user's terminal, so they are sanitized and
         // bounded here — the same treatment any other child-supplied string

package/src/ui/agent-display.ts

@@ -7,10 +7,11 @@
  * sanitizer on the way out.
  */
 
+import { sanitizeDisplayText } from "@signalridge/pi-ui";
 import { getConfig } from "../agent-types.js";
 import type { AgentInvocation, SubagentType } from "../types.js";
 import type { LifetimeUsage, SessionLike } from "../usage.js";
-import { sanitizeDisplayText, truncateCodePoints } from "./safe-text.js";
+import { truncateCodePoints } from "./safe-text.js";
 
 // ---- Constants ----
 

package/src/ui/conversation-viewer.ts

@@ -7,13 +7,14 @@
 
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import { type Component, Input, matchesKey, type TUI, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { sanitizeDisplayText } from "@signalridge/pi-ui";
 import { renderAgentName } from "../agent-color.js";
 import { extractText } from "../context.js";
 import type { AgentRecordSnapshot } from "../types.js";
 import { getLifetimeTotal, getSessionContextPercent } from "../usage.js";
 import type { Theme } from "./agent-display.js";
 import { type AgentActivity, buildInvocationTags, describeActivity, fgPreservingNestedStyles, formatDuration, formatSessionTokens, getPromptModeLabel } from "./agent-display.js";
-import { PREVIEW_SCAN_LIMIT, safeTerminalText, sanitizeDisplayText, truncateCodePoints } from "./safe-text.js";
+import { PREVIEW_SCAN_LIMIT, safeTerminalText, truncateCodePoints } from "./safe-text.js";
 import { getAgentStatusColor, getAgentStatusLabel, getAgentStatusMark } from "./status-label.js";
 import { createViewerKeys, type ViewerKeybindings, type ViewerKeys } from "./viewer-keys.js";
 
@@ -56,6 +57,10 @@ function isBashExecutionMessage(message: { role: string }): message is BashExecu
     && typeof message.output === "string";
 }
 
+// biome-ignore lint/suspicious/noConfusingVoidType: preserve existing void-returning steering callbacks.
+export type SteerAcceptance = boolean | void;
+export type SteerHandler = (message: string) => SteerAcceptance | Promise<SteerAcceptance>;
+
 export class ConversationViewer implements Component {
   private scrollOffset = 0;
   private autoScroll = true;
@@ -67,6 +72,8 @@ export class ConversationViewer implements Component {
   private keys: ViewerKeys;
   /** Steering composer — present while the user is typing a message to the agent. */
   private composer: Input | undefined;
+  private steerError: string | undefined;
+  private sending = false;
 
   constructor(
     private tui: TUI,
@@ -80,7 +87,7 @@ export class ConversationViewer implements Component {
     /** User keybindings from `ctx.ui.custom()`. Omitted → hardcoded defaults. */
     keybindings?: ViewerKeybindings,
     /** Send a steering message to the agent. Omitted → no compose affordance. */
-    private onSteer?: (message: string) => void,
+    private onSteer?: SteerHandler,
     /** Retrieve a fresh public snapshot so the viewer reflects status changes. */
     private getRecord?: () => AgentRecordSnapshot | undefined,
   ) {
@@ -92,16 +99,19 @@ export class ConversationViewer implements Component {
   }
 
   private refreshRecord(): AgentRecordSnapshot {
-    const current = this.getRecord?.();
-    if (current) this.record = current;
+    try {
+      const current = this.getRecord?.();
+      if (current) this.record = current;
+    } catch { /* a disposed owner cannot erase the retained snapshot */ }
     return this.record;
   }
 
   handleInput(data: string): void {
+    if (this.closed) return;
     // While composing a steer message, the input owns all keys (Enter sends,
     // Esc cancels — both wired in openComposer()). Editing keys flow through.
     if (this.composer) {
-      this.composer.handleInput(data);
+      if (!this.sending || matchesKey(data, "escape")) this.composer.handleInput(data);
       this.tui.requestRender();
       return;
     }
@@ -206,9 +216,9 @@ export class ConversationViewer implements Component {
     const headerStats: string[] = [duration];
     const toolUses = this.activity?.toolUses ?? this.record.toolUses;
     if (toolUses > 0) headerStats.unshift(`tools ${toolUses}`);
-    const tokens = getLifetimeTotal(this.activity?.lifetimeUsage);
-    if (tokens > 0) {
-      const percent = getSessionContextPercent(this.activity?.session);
+    const tokens = getLifetimeTotal(this.activity?.lifetimeUsage ?? this.record.lifetimeUsage);
+    if (tokens > 0 || this.record.compactionCount > 0) {
+      const percent = getSessionContextPercent(this.activity?.session ?? this.session);
       headerStats.push(formatSessionTokens(tokens, percent, th, this.record.compactionCount));
     }
 
@@ -245,10 +255,8 @@ export class ConversationViewer implements Component {
       const renderedComposer = this.composer.render(innerW)[0] ?? "";
       const composerLine = renderedComposer.startsWith("> ") ? renderedComposer.slice(2) : renderedComposer;
       lines.push(row(composerLine));
-      const composeHint = th.fg("dim", "Enter send · Esc cancel");
-      const composeLeft = th.fg("accent", "chat");
-      const composeGap = Math.max(1, innerW - visibleWidth(composeLeft) - visibleWidth(composeHint));
-      lines.push(row(composeLeft + " ".repeat(composeGap) + composeHint));
+      const composeHint = this.sending ? "Sending..." : this.steerError ?? "Enter send · Esc cancel";
+      lines.push(row(th.fg(this.steerError ? "error" : "dim", composeHint)));
     } else {
       const sep = th.fg("dim", " · ");
       const actions: string[] = [];
@@ -278,13 +286,13 @@ export class ConversationViewer implements Component {
   /** Stoppable only when a stop handler exists and the agent is still active. */
   private isStoppable(): boolean {
     const record = this.refreshRecord();
-    return !!this.onStop && (record.status === "running" || record.status === "queued");
+    return !record.detached && !!this.onStop && (record.status === "running" || record.status === "queued");
   }
 
   /** Steerable only when a steer handler exists and the agent is still active. */
   private canSteer(): boolean {
     const record = this.refreshRecord();
-    return !!this.onSteer && (record.status === "running" || record.status === "queued");
+    return !record.detached && !!this.onSteer && (record.status === "running" || record.status === "queued");
   }
 
   /** Open the inline steering composer and route subsequent input to it. */
@@ -293,12 +301,34 @@ export class ConversationViewer implements Component {
     input.focused = true;
     input.onSubmit = (value: string) => {
       const message = value.trim();
-      this.composer = undefined;
-      if (message) this.onSteer?.(message);
+      if (!message) { this.composer = undefined; this.tui.requestRender(); return; }
+      if (!this.canSteer()) {
+        this.steerError = "Agent finished; draft retained · Esc cancel";
+        this.tui.requestRender();
+        return;
+      }
+      this.steerError = undefined;
+      const settle = (accepted: SteerAcceptance): void => {
+        if (this.closed || this.composer !== input) return;
+        this.sending = false;
+        if (accepted === false) this.steerError = "Steering rejected; draft retained · Esc cancel";
+        else this.composer = undefined;
+        this.tui.requestRender();
+      };
+      const reject = (): void => settle(false);
+      try {
+        const result = this.onSteer?.(message);
+        if (result && typeof result === "object") {
+          this.sending = true;
+          void result.then(settle, reject);
+        } else settle(result);
+      } catch { reject(); }
       this.tui.requestRender();
     };
     input.onEscape = () => {
       this.composer = undefined;
+      this.steerError = undefined;
+      this.sending = false;
       this.tui.requestRender();
     };
     this.composer = input;
@@ -336,14 +366,15 @@ export class ConversationViewer implements Component {
     const { modelName, tags } = buildInvocationTags(this.record.invocation);
     const parts = modelName ? [modelName, ...tags] : tags;
     if (parts.length === 0) return undefined;
-    return this.theme.fg("dim", `  invocation · ${parts.join(" · ")}`);
+    return this.theme.fg("dim", `  invocation · ${parts.map(part => sanitizeDisplayText(part)).join(" · ")}`);
   }
 
   private buildContentLines(width: number): string[] {
     if (width <= 0) return [];
 
     const th = this.theme;
-    const messages = this.session.messages;
+    let messages: AgentSession["messages"];
+    try { messages = this.session.messages; } catch { messages = []; }
     const lines: string[] = [];
 
     if (messages.length === 0) {

package/src/ui/fleet-list.ts

@@ -11,15 +11,15 @@
  * can `consume` keys — gated on `getEditorText() === ""` so normal typing is untouched.
  */
 
-import { Editor, isKeyRelease, Key, matchesKey, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { borderedComponent } from "@signalridge/pi-ui";
+import { type Component, isKeyRelease, Key, matchesKey, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { borderedComponent, sanitizeDisplayText } from "@signalridge/pi-ui";
 import { renderAgentName } from "../agent-color.js";
 import type { AgentManager } from "../agent-manager.js";
 import type { AgentRecord } from "../types.js";
 import { getLifetimeTotal } from "../usage.js";
 import { type AgentActivity, type Theme } from "./agent-display.js";
 import { ConversationViewer, VIEWPORT_HEIGHT_PCT } from "./conversation-viewer.js";
-import { sanitizeDisplayText } from "./safe-text.js";
+import { type OwnerGroup, OwnerGroupViewer, workflowGroupId } from "./owner-group.js";
 import { getAgentStatusColor, getAgentStatusLabel, getAgentStatusMark } from "./status-label.js";
 import type { ViewerKeybindings } from "./viewer-keys.js";
 
@@ -48,9 +48,10 @@ export type FleetUICtx = {
   ): Promise<T>;
 };
 
-type MainEntry = { kind: "main" };
-type AgentEntry = { kind: "agent"; record: AgentRecord };
-type FleetEntry = MainEntry | AgentEntry;
+type MainEntry = { kind: "main"; id: string };
+type AgentEntry = { kind: "agent"; id: string; record: AgentRecord };
+type GroupEntry = { kind: "group"; id: string; group: OwnerGroup };
+type FleetEntry = MainEntry | AgentEntry | GroupEntry;
 
 /** `11s` — integer seconds, no decimal/suffix (matches Claude Code, unlike formatMs). */
 export function formatFleetElapsed(ms: number): string {
@@ -91,6 +92,8 @@ export class FleetList {
   private active = false;
   /** 0 = `main`, 1..N = subagents. */
   private selectedIndex = 0;
+  private selectedId = "main";
+  private overlayGeneration = 0;
   /** Set while a conversation overlay is open; calling it closes the overlay. */
   private viewerClose: (() => void) | undefined;
   private viewingAgentId: string | undefined;
@@ -112,7 +115,7 @@ export class FleetList {
   /** Capture the UI context and (re)register the global input handler. */
   setUICtx(ui: FleetUICtx): void {
     if (ui === this.ui) return;
-    this.inputUnsub?.();
+    this.dispose();
     this.ui = ui;
     this.widgetRegistered = false;
     this.tui = undefined;
@@ -133,6 +136,7 @@ export class FleetList {
   }
 
   dispose(): void {
+    this.overlayGeneration++;
     if (this.timer) { clearInterval(this.timer); this.timer = undefined; }
     this.inputUnsub?.();
     this.inputUnsub = undefined;
@@ -149,7 +153,7 @@ export class FleetList {
   /** Re-register/refresh the below-editor widget; clears it when no agents remain. */
   update(): void {
     if (!this.ui) return;
-    const hasAgents = this.enabled && this.agentRecords().length > 0;
+    const hasAgents = this.enabled && this.roster().length > 1;
 
     if (!hasAgents) {
       if (this.widgetRegistered) {
@@ -160,6 +164,7 @@ export class FleetList {
       if (this.timer) { clearInterval(this.timer); this.timer = undefined; }
       this.active = false;
       this.selectedIndex = 0;
+      this.selectedId = "main";
       return;
     }
 
@@ -171,7 +176,8 @@ export class FleetList {
         this.tui = tui;
         return {
           render: (w: number) => this.renderBar(w, theme),
-          invalidate: () => { this.widgetRegistered = false; this.tui = undefined; },
+          invalidate: () => { /* no render cache; mounting/focus remain owned */ },
+          dispose: () => { if (this.tui === tui) { this.widgetRegistered = false; this.tui = undefined; } },
         };
       }, { placement: "belowEditor" });
       this.widgetRegistered = true;
@@ -193,7 +199,7 @@ export class FleetList {
   private agentRecords(): AgentRecord[] {
     const now = Date.now();
     return this.manager.listAgentsMutable()
-      .filter(a => !a.parentAgentId && a.session && (
+      .filter(a => !a.parentAgentId && !a.detached && !workflowGroupId(a) && a.session && (
         a.status === "running" || a.status === "queued"
         || a.id === this.viewingAgentId
         || (a.completedAt != null && now - a.completedAt < FINISHED_LINGER_MS)
@@ -201,14 +207,39 @@ export class FleetList {
       .sort((a, b) => a.startedAt - b.startedAt);
   }
 
+  private groups(): OwnerGroup[] {
+    const groups = new Map<string, OwnerGroup>();
+    for (const record of this.manager.listAgentsMutable()) {
+      if (record.parentAgentId || record.detached) continue;
+      const id = workflowGroupId(record);
+      if (!id) continue;
+      let group = groups.get(id);
+      if (!group) { group = { id, runId: record.owner!.runId, records: [] }; groups.set(id, group); }
+      group.records.push(record);
+    }
+    for (const group of groups.values()) group.records.sort((a, b) => a.startedAt - b.startedAt || a.id.localeCompare(b.id));
+    return [...groups.values()];
+  }
+
   private roster(): FleetEntry[] {
-    return [{ kind: "main" }, ...this.agentRecords().map(record => ({ kind: "agent" as const, record }))];
+    return [
+      { kind: "main", id: "main" },
+      ...this.groups().map(group => ({ kind: "group" as const, id: `group:${group.id}`, group })),
+      ...this.agentRecords().map(record => ({ kind: "agent" as const, id: `agent:${record.id}`, record })),
+    ];
   }
 
-  private clampSelection(): void {
-    const max = this.roster().length - 1;
-    if (this.selectedIndex > max) this.selectedIndex = Math.max(0, max);
-    if (this.selectedIndex < 0) this.selectedIndex = 0;
+  private clampSelection(roster = this.roster()): void {
+    const index = roster.findIndex(entry => entry.id === this.selectedId);
+    // Missing identity returns explicitly to main, never to a different child.
+    this.selectedIndex = index >= 0 ? index : 0;
+    this.selectedId = roster[this.selectedIndex].id;
+  }
+
+  private select(index: number): void {
+    const roster = this.roster();
+    this.selectedIndex = Math.max(0, Math.min(roster.length - 1, index));
+    this.selectedId = roster[this.selectedIndex].id;
   }
 
   // ---- Key handling ----
@@ -234,25 +265,27 @@ export class FleetList {
     if (!this.active) {
       // Activate: ↓ or ← at an empty prompt moves focus into the list.
       const isActivator = matchesKey(data, "down") || matchesKey(data, "left");
-      if (isActivator && this.agentRecords().length > 0 && this.ui.getEditorText() === "") {
+      if (isActivator && this.roster().length > 1 && this.ui.getEditorText() === "") {
         this.active = true;
-        this.selectedIndex = 0;
+        this.select(0);
         this.update();
         return { consume: true };
       }
       return undefined;
     }
 
+    // Reconcile identity before both navigation and opening, even between ticks.
+    this.clampSelection();
     // Active — arrows navigate, Enter opens, Esc / Up-past-top exits.
     if (matchesKey(data, "down")) {
       const max = this.roster().length - 1;
-      this.selectedIndex = Math.min(max, this.selectedIndex + 1);
+      this.select(Math.min(max, this.selectedIndex + 1));
       this.update();
       return { consume: true };
     }
     if (matchesKey(data, "up")) {
       if (this.selectedIndex === 0) { this.deactivate(); return { consume: true }; }
-      this.selectedIndex -= 1;
+      this.select(this.selectedIndex - 1);
       this.update();
       return { consume: true };
     }
@@ -265,64 +298,91 @@ export class FleetList {
   }
 
   /**
-   * True when pi's prompt editor owns the keyboard. pi's editor is an `Editor`
-   * subclass (CustomEditor) while every dialog/selector is not, and the loader
-   * aliases pi-tui to pi's own copy, so `instanceof` is a reliable identity
-   * check. `focusedComponent` is TUI-private (no public accessor), hence the
-   * best-effort peek: unknowable focus (no tui seen yet, nothing focused)
-   * counts as the editor so activation keeps working.
+   * True when pi's prompt editor owns the keyboard. The editor is pluggable
+   * (ui.setEditorComponent) and need not extend `Editor` (#374), so match pi-tui's
+   * `EditorComponent` contract instead: `getText` + `setText`, which pi calls on
+   * every editor and none of pi's dialogs, selectors or overlays implement.
+   * Use the public structural focus getter (not present in every TUI interface
+   * declaration). Unknown focus retains the initial editor fallback.
    */
   private editorHasFocus(): boolean {
-    const focused = (this.tui as { focusedComponent?: unknown } | undefined)?.focusedComponent;
-    return focused == null || focused instanceof Editor;
+    const focusHost = this.tui as { getFocusedComponent?: () => unknown } | undefined;
+    const focused = typeof focusHost?.getFocusedComponent === "function" ? focusHost.getFocusedComponent() : undefined;
+    if (focused == null) return true;
+    const c = focused as { getText?: unknown; setText?: unknown };
+    return typeof c.getText === "function" && typeof c.setText === "function";
   }
 
   private deactivate(): void {
     this.active = false;
-    this.selectedIndex = 0;
+    this.select(0);
     this.update();
   }
 
   private openSelected(): void {
-    const entry = this.roster()[this.selectedIndex];
+    const roster = this.roster();
+    this.clampSelection(roster);
+    const entry = roster[this.selectedIndex];
     if (!entry || entry.kind === "main") {
       // `main` = return to the prompt; the native transcript is already shown.
       this.deactivate();
       return;
     }
-    const record = entry.record;
     if (!this.ui) return;
+    if (entry.kind === "group") { this.openGroup(entry.group); return; }
+    const record = entry.record;
     if (!record.session) {
       this.ui.notify(`Agent is ${record.status}; no session available.`, "info");
       return;
     }
-    const session = record.session;
-    const activity = this.agentActivity.get(record.id);
     this.viewingAgentId = record.id;
+    void this.openOverlay((tui, theme, keys, done) => this.conversation(record, tui, theme, keys, done));
+  }
+
+  private conversation(record: AgentRecord, tui: TUI, theme: Theme, keys: ViewerKeybindings, done: (result: undefined) => void): ConversationViewer {
+    const session = record.session;
+    if (!session) throw new Error("No session available");
+    const owner = record.owner ? { ...record.owner } : undefined;
+    // An id can be reused for another thread attempt. Bind controls to this
+    // session and immutable owner generation, never to id alone.
+    const current = (): AgentRecord | undefined => this.manager.listAgentsMutable().find(candidate =>
+      candidate.id === record.id && candidate.session === session && !candidate.detached &&
+      candidate.owner?.extension === owner?.extension && candidate.owner?.runId === owner?.runId &&
+      candidate.owner?.nodeId === owner?.nodeId && candidate.owner?.attemptId === owner?.attemptId);
+    return new ConversationViewer(tui, session, record, this.agentActivity.get(record.id), theme, done,
+      () => { if (current() && this.manager.abort(record.id)) this.ui?.notify(`Stopped "${sanitizeDisplayText(record.description)}".`, "info"); },
+      keys,
+      message => !!current() && this.manager.steer(record.id, message),
+      () => current() ?? { ...record, status: record.status === "running" || record.status === "queued" ? "stopped" : record.status, detached: true },
+    );
+  }
 
-    void this.ui.custom<undefined>(
-      (tui, theme, keybindings, done) => {
+  private openGroup(group: OwnerGroup): void {
+    void this.openOverlay((tui, theme, keys, done) => new OwnerGroupViewer(tui, theme, group.runId,
+      () => this.groups().find(candidate => candidate.id === group.id)?.records ?? [],
+      (record, back) => this.conversation(record, tui, theme, keys, back),
+      () => done(undefined), keys));
+  }
+
+  private async openOverlay(factory: (tui: TUI, theme: Theme, keys: ViewerKeybindings, done: (result: undefined) => void) => Component): Promise<void> {
+    const ui = this.ui;
+    if (!ui) return;
+    const generation = ++this.overlayGeneration;
+    this.viewerClose = () => {}; // reserve input during asynchronous construction
+    try {
+      await ui.custom<undefined>((tui, theme, keys, done) => {
+        if (generation !== this.overlayGeneration || ui !== this.ui) {
+          done(undefined);
+          return { render: () => [], invalidate: () => {} };
+        }
         this.viewerClose = () => done(undefined);
-        return borderedComponent(new ConversationViewer(
-          tui,
-          session,
-          record,
-          activity,
-          theme,
-          done,
-          () => {
-            if (this.manager.abort(record.id)) this.ui?.notify(`Stopped "${sanitizeDisplayText(record.description)}".`, "info");
-          },
-          keybindings,
-          (message: string) => this.manager.steer(record.id, message),
-          () => this.manager.getRecord?.(record.id),
-        ), (text) => theme.fg("borderAccent", text));
-      },
-      {
-        overlay: true,
-        overlayOptions: { anchor: "center", width: "90%", maxHeight: `${VIEWPORT_HEIGHT_PCT}%` },
-      },
-    ).then(() => this.clearViewer(), () => this.clearViewer());
+        return borderedComponent(factory(tui, theme, keys, done), text => theme.fg("borderAccent", text));
+      }, { overlay: true, overlayOptions: { anchor: "center", width: "90%", maxHeight: `${VIEWPORT_HEIGHT_PCT}%` } });
+    } catch {
+      if (generation === this.overlayGeneration) ui.notify("Cannot open conversation; try again.", "error");
+    } finally {
+      if (generation === this.overlayGeneration) this.clearViewer();
+    }
   }
 
   /** Reset overlay state and return to the list (on close, auto-close, or error). */
@@ -333,7 +393,7 @@ export class FleetList {
     // update()'s clamp to settle.
     if (this.viewingAgentId) {
       const idx = this.roster().findIndex(e => e.kind === "agent" && e.record.id === this.viewingAgentId);
-      if (idx >= 0) this.selectedIndex = idx;
+      if (idx >= 0) this.select(idx);
     }
     this.viewerClose = undefined;
     this.viewingAgentId = undefined;
@@ -343,9 +403,11 @@ export class FleetList {
   // ---- Rendering ----
 
   private renderBar(width: number, theme: Theme): string[] {
-    const agents = this.roster().slice(1) as AgentEntry[];
+    const roster = this.roster();
+    this.clampSelection(roster);
+    const agents = roster.slice(1);
     if (agents.length === 0) return [];
-    const sel = Math.min(this.selectedIndex, agents.length);
+    const sel = this.selectedIndex;
 
     // Key names read as proper nouns, the verbs after them stay lowercase, and
     // segments are separated by " · " — the same shape every hint line in the
@@ -372,7 +434,12 @@ export class FleetList {
 
     if (start > 0) lines.push(rightAlign("", theme.fg("dim", `${start} more above`), width));
     for (let a = start; a < start + visible; a++) {
-      lines.push(this.renderAgentRow(a + 1, sel, agents[a].record, width, theme));
+      const entry = agents[a];
+      if (entry.kind === "agent") lines.push(this.renderAgentRow(a + 1, sel, entry.record, width, theme));
+      else if (entry.kind === "group") {
+        const label = `  ▸ Workflow ${sanitizeDisplayText(entry.group.runId)} · ${entry.group.records.length} retained children`;
+        lines.push(truncateToWidth(theme.fg(a + 1 === sel ? "accent" : "muted", label), width));
+      }
     }
     if (hiddenBelow > 0) lines.push(rightAlign("", theme.fg("dim", `${hiddenBelow} more below`), width));