@howarewoo/pi-subagents 0.2.0 → 0.3.0

package/src/child-execution.ts

@@ -34,6 +34,9 @@ export type ExecutionRecord = {
   timer?: ReturnType<typeof setTimeout>;
   run?: Promise<void>;
   session?: AgentSession;
+  /** Canonical entry tree survives runtime disposal; never substitute a result summary. */
+  sessionManager?: SessionManager;
+  resourcePrompt?: string;
   unsubscribe?: () => void;
   paused?: boolean;
   prompt?: (text: string) => Promise<void>;
@@ -89,11 +92,15 @@ export async function createChildExecution(
         ? entry.state.id
         : `${entry.state.id}-g${entry.state.generation}`,
     );
-    await mkdir(taskDir, { mode: 0o700 }); // exclusive ownership: never reuse an existing task record
+    const restoring = !!entry.sessionManager;
+    if (!restoring) await mkdir(taskDir, { mode: 0o700 }); // exclusive initial ownership
     const agentDir = join(taskDir, "agent");
-    await mkdir(agentDir, { mode: 0o700 });
+    if (!restoring) await mkdir(agentDir, { mode: 0o700 });
     const transcriptDir = join(taskDir, "transcripts");
-    await mkdir(transcriptDir, { mode: 0o700 });
+    if (!restoring) await mkdir(transcriptDir, { mode: 0o700 });
+    // Each completed window publishes exclusively, leaving all earlier artifacts intact.
+    const outcomeDir = restoring ? join(taskDir, `window-${entry.state.window}`) : taskDir;
+    if (restoring) await mkdir(outcomeDir, { mode: 0o700 });
     const target =
       entry.state.prewalk?.status === "armed"
         ? validateModelSelection(input.context, entry.state.prewalk.target)
@@ -116,14 +123,15 @@ export async function createChildExecution(
       target ? [target] : [],
     );
     const resources = childResources(
-      input.profile.prompt +
+      (entry.resourcePrompt ??=
+        input.profile.prompt +
         (target
           ? "\nPrewalk: investigate and plan using only granted context/tools. After the first completed edit or write the same conversation switches once to the explicitly granted implementation target; all normal budgets still apply."
           : "") +
         `\nYour delegation identity is ${entry.state.id} generation ${entry.state.generation}; parent ${entry.state.parentId}. Coordination, if granted, is limited to family identities explicitly supplied to you.` +
         (entry.validator
           ? "\nThis assignment requires a structured result. Call submit_result with the actual value; final prose is not a submission."
-          : ""),
+          : "")),
       input.skills,
     );
     const loader = new DefaultResourceLoader({
@@ -316,9 +324,10 @@ export async function createChildExecution(
         compaction: { enabled: false },
         retry: { enabled: false },
       }),
-      sessionManager: SessionManager.create(selection.cwd, transcriptDir),
+      sessionManager: entry.sessionManager ?? SessionManager.create(selection.cwd, transcriptDir),
     });
     entry.session = session;
+    entry.sessionManager = session.sessionManager;
     if (session.thinkingLevel !== selection.thinkingLevel)
       throw new Error("SDK did not preserve selected effort");
     if (
@@ -389,7 +398,7 @@ export async function createChildExecution(
           const artifacts: NonNullable<ChildSnapshot["artifacts"]> = {};
           try {
             artifacts.text = await saveOutcomeArtifact(
-              taskDir,
+              outcomeDir,
               "result.txt",
               last?.content
                 .filter((block) => block.type === "text")
@@ -398,7 +407,7 @@ export async function createChildExecution(
             );
             if (entry.state.outcome?.validation === "submitted")
               artifacts.structured = await saveOutcomeArtifact(
-                taskDir,
+                outcomeDir,
                 "structured.json",
                 JSON.stringify(entry.state.outcome.value),
               );

package/src/coordinator.ts

@@ -1,6 +1,7 @@
 import { requireSupportedHost } from "./supported-host.ts";
 import { leafDenial, toolProvenance, type CapabilityDenial } from "./capabilities.ts";
 import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
 import {
   SessionManager,
   type AgentSession,
@@ -110,12 +111,14 @@ export class DelegationCoordinator {
       presence: this.presence.get(state.id),
     }));
   }
-  generations(id: string): ChildSnapshot[] {
+  /** Full parent-lifetime session roster, including retained historical generations. */
+  sessions(): ChildSnapshot[] {
     return [...this.history.values()]
-      .map((record) => record.state)
-      .concat(this.list())
-      .filter((state) => state.id === id)
-      .map((state) => structuredClone(state));
+      .map((record) => structuredClone(record.state))
+      .concat(this.list());
+  }
+  generations(id: string): ChildSnapshot[] {
+    return this.sessions().filter((state) => state.id === id);
   }
   private listeners = new Set<(event: RegistryEvent) => void>();
   private parentMutations = new Set<string>();
@@ -224,6 +227,15 @@ export class DelegationCoordinator {
         throw new Error("Prewalk target requires an exact model grant");
       validateModelSelection(selection, input.profile.prewalk);
     }
+    this.validateAdmission(input, effective, input.model);
+    return selection;
+  }
+  /** Shared writer/lineage checks; resume supplies its retained selection, not admission defaults. */
+  private validateAdmission(
+    input: StartTask,
+    effective: ModelSelection,
+    explicit?: ModelSelection,
+  ): void {
     const writer = this.writer ? this.entries.get(this.writer) : undefined;
     if (
       isWriter(input.profile) &&
@@ -234,7 +246,7 @@ export class DelegationCoordinator {
       const parent = this.entry(input.parent);
       if (parent.cancelled || parent.paused || parent.state.disposed)
         throw new Error("Delegating parent is no longer active");
-      this.assertDescendantModels(parent, input.profile, effective, input.model);
+      this.assertDescendantModels(parent, input.profile, effective, explicit);
       if (!parent.input.profile.spawn?.includes(input.profile.name))
         throw new Error("Ancestor spawn role denied");
       if (parent.state.depth >= Math.min(this.policy.depth, parent.state.limits.depth))
@@ -248,7 +260,6 @@ export class DelegationCoordinator {
         ancestor = this.entries.get(ancestor.state.parentId);
       }
     }
-    return selection;
   }
   private assertDescendantModels(
     parent: Entry,
@@ -721,15 +732,56 @@ export class DelegationCoordinator {
   async resume(ref: ChildRef, text: string): Promise<ChildRef> {
     requireSupportedHost();
     const entry = this.entry(ref);
-    if (entry.resuming || entry.state.status !== "paused" || entry.cancelled || this.closing)
-      throw new Error("Resume requires a drained paused assignment; duplicate resume rejected");
+    const completed = entry.state.status === "settled" && entry.state.disposed;
+    const eligible = entry.state.status === "paused" || completed;
+    if (
+      entry.resuming ||
+      !eligible ||
+      entry.cancelled ||
+      this.closing ||
+      this.presence.get(ref.id) === "stopped"
+    )
+      throw new Error(
+        "Resume requires a drained paused or completed conversation; stopped/failed identities and duplicate resume rejected",
+      );
+    if ((entry.state.window ?? 1) >= MAX_GENERATIONS)
+      throw new Error("Resume window limit (64) reached");
+    if (
+      completed &&
+      (!entry.sessionManager ||
+        !entry.finalizedMessages?.length ||
+        JSON.stringify(entry.sessionManager.buildSessionContext().messages) !==
+          JSON.stringify(entry.finalizedMessages))
+    )
+      throw new Error("Resume unavailable: canonical conversation state was not retained");
+    if (completed) {
+      // SessionManager.open() can silently initialize missing/empty files. Never use that
+      // fallback here: the retained tree AND its original persisted transcript must agree.
+      try {
+        const persisted = readFileSync(entry.state.transcript!, "utf8")
+          .trim()
+          .split("\n")
+          .map((line) => JSON.parse(line));
+        const manager = entry.sessionManager!;
+        if (
+          JSON.stringify(persisted) !==
+          JSON.stringify([manager.getHeader(), ...manager.getEntries()])
+        )
+          throw new Error("transcript differs from retained canonical entries");
+      } catch (error) {
+        throw new Error(
+          `Resume unavailable: original transcript cannot be restored: ${String(error)}`,
+        );
+      }
+    } else if (entry.prompted && !entry.session) {
+      throw new Error("Resume unavailable: paused SDK conversation was not retained");
+    }
     if (!text.trim()) throw new Error("Nonempty continuation text is required");
     entry.resuming = true;
     try {
       const parent = this.renewalParent(ref);
       const input = entry.input;
       const policy = await resolveScheduling(input.context.cwd, input.context.isProjectTrusted());
-      this.configure(policy);
       const limits = { ...entry.state.limits };
       for (const key of Object.keys(limits) as (keyof ExecutionLimits)[])
         limits[key] = Math.min(
@@ -810,21 +862,52 @@ export class DelegationCoordinator {
         throw new Error("Resume denied: delegation depth limit");
       // Reuse the original admission's writer and nested no-lending checks, without
       // admitting another task or charging another spawn.
-      this.validate(input);
+      this.validateAdmission(
+        input,
+        selected,
+        entry.state.prewalk?.status === "armed" ? undefined : selected,
+      );
       this.renewalParent(ref);
       const available =
         this.active().length < policy.concurrency &&
         (!isWriter(input.profile) || (!this.writer && !this.parentMutations.size));
       if (parent && (this.queue.size || !available))
         throw new Error("Nested capacity unavailable; no permit lending");
-      this.assertQueueCapacity([input]);
+      const previousPolicy = this.policy;
+      this.policy = policy;
+      try {
+        this.assertQueueCapacity([input]);
+      } finally {
+        this.policy = previousPolicy;
+      }
       if (
         entry.cancelled ||
         this.closing ||
-        entry.state.disposed ||
-        entry.state.status !== "paused"
+        this.presence.get(ref.id) === "stopped" ||
+        (completed ? entry.state.status !== "settled" : entry.state.status !== "paused")
       )
         throw new Error("Resume cancelled by stop or shutdown");
+      if (completed) {
+        const { window, status, result, outcome, artifacts, error, endedAt } = entry.state;
+        entry.state = {
+          ...entry.state,
+          completedWindows: [
+            ...(entry.state.completedWindows ?? []),
+            structuredClone({ window, status, result, outcome, artifacts, error, endedAt }),
+          ],
+          disposed: false,
+          endedAt: null,
+          outcome: entry.validator
+            ? { validation: "awaiting", attempts: 0, errors: [], finalized: false }
+            : undefined,
+          artifacts: undefined,
+          result: "",
+          progress: "",
+        };
+        entry.selection.model = validateModelSelection(input.context, selected);
+        entry.selection.thinkingLevel = selected.effort;
+      }
+      this.policy = policy;
       entry.done = new Promise<void>((resolve) => {
         entry.finish = resolve;
       });
@@ -989,24 +1072,27 @@ export class DelegationCoordinator {
       dispose: () => this.dispose(entry),
     });
   }
-  private closeDescendantPresence(entry: Entry): void {
+  private closeDescendantPresence(entry: Entry, completed = false): void {
     for (const child of this.entries.values())
       if (
         child.state.parentId === entry.state.id &&
         child.state.parentGeneration === entry.state.generation
       ) {
-        this.presence.set(child.state.id, "stopped");
-        this.closeDescendantPresence(child);
+        // Ancestor completion closes live/paused descendants, but does not retire a
+        // successful retained conversation. Explicit stop remains sticky.
+        if (!(completed && child.state.disposed && child.state.status === "settled"))
+          this.presence.set(child.state.id, "stopped");
+        this.closeDescendantPresence(child, completed);
       }
   }
   private dispose(entry: Entry): void {
     if (entry.state.disposed) return;
     this.queue.delete(entry);
     clearTimeout(entry.timer);
-    entry.finalizedMessages = structuredClone(entry.session?.messages ?? []);
+    if (entry.session) entry.finalizedMessages = structuredClone(entry.session.messages);
     entry.unsubscribe?.();
     entry.session?.dispose();
-    // Retain immutable evidence, not the disposed SDK session graph, while idle/parked.
+    // Retain the authoritative SessionManager and immutable evidence, not the SDK runtime graph.
     entry.unsubscribe = undefined;
     entry.session = undefined;
     entry.prompt = undefined;
@@ -1015,11 +1101,14 @@ export class DelegationCoordinator {
     entry.run = undefined;
     entry.pauseDrain = undefined;
     if (this.writer === entry.state.id) this.writer = undefined;
-    this.closeDescendantPresence(entry);
+    this.closeDescendantPresence(
+      entry,
+      entry.state.status === "settled" && !entry.cancelled && !this.closing,
+    );
     this.presence.set(entry.state.id, entry.cancelled || this.closing ? "stopped" : "idle");
     this.update(entry, {
       disposed: true,
-      retainedContext: false,
+      retainedContext: !!entry.sessionManager && entry.state.status === "settled",
       endedAt: Date.now(),
       writerLease: false,
       outcome: entry.state.outcome ? { ...entry.state.outcome, finalized: true } : undefined,

package/src/delegation-types.ts

@@ -42,6 +42,13 @@ export type ChildSnapshot = Readonly<
     pauseReason?: string;
     retainedContext?: boolean;
     window?: number;
+    /** Immutable completion evidence from earlier windows of this same conversation. */
+    completedWindows?: ReadonlyArray<
+      Pick<
+        ChildSnapshot,
+        "window" | "status" | "result" | "outcome" | "artifacts" | "error" | "endedAt"
+      >
+    >;
     status:
       | "queued"
       | "setup"

package/src/hub.ts

@@ -27,6 +27,7 @@ import {
   assignmentHeadline,
   lineText,
   taskDetails,
+  taskTree,
   transcriptLines,
 } from "./task-presentation.ts";
 
@@ -82,26 +83,27 @@ export function createHub(
   });
   const identity = (ref: ChildRef) => `${ref.id}/${ref.generation}`;
   const roster = () =>
-    coordinator
-      .list()
-      .flatMap((child) => coordinator.generations(child.id))
-      .filter((child) =>
-        lineText(
-          [
-            child.id,
-            child.parentId,
-            child.profile,
-            child.status,
-            child.assignment,
-            child.progress,
-            child.result,
-            child.error,
-            child.model.id,
-          ].join(" "),
-        )
-          .toLowerCase()
-          .includes(query.toLowerCase()),
-      );
+    taskTree(
+      coordinator
+        .sessions()
+        .filter((child) =>
+          lineText(
+            [
+              child.id,
+              child.parentId,
+              child.profile,
+              child.status,
+              child.assignment,
+              child.progress,
+              child.result,
+              child.error,
+              child.model.id,
+            ].join(" "),
+          )
+            .toLowerCase()
+            .includes(query.toLowerCase()),
+        ),
+    ).map(({ child }) => child);
   const selection = () => {
     const children = roster();
     if (!children.some((child) => identity(child) === selected)) {
@@ -205,7 +207,7 @@ export function createHub(
           paint(
             interactionTarget
               ? "Resize · Esc cancels"
-              : "Subagent Hub " + coordinator.list().length,
+              : "Subagent Hub " + coordinator.sessions().length,
           ),
         ];
       const inner = Math.max(0, width - 4);
@@ -397,25 +399,27 @@ export function createHub(
       const position = `${tab === "thread" ? (following ? "LIVE · " : "READING · ") : ""}${offset + 1}–${Math.min(wrapped.length, offset + viewport)}/${wrapped.length} lines${tab === "thread" ? (following ? " · k/PgUp read" : " · End: live") : offset < maxOffset ? " · more ↓" : ""}`;
       const pane: string[] = [];
       if (wide) {
-        const slots = Math.max(1, Math.floor((paneHeight - 2) / 3));
+        const slots = Math.max(1, Math.floor((paneHeight - 2) / 2));
         const start = Math.max(0, index - slots + 1);
         const left = [
           theme.fg("accent", `SUBAGENTS · ${children.length} generations`),
-          ...children.slice(start, start + slots).flatMap((item) => {
-            const indent = " ".repeat(Math.min(4, Math.max(0, item.depth - 1)));
-            const prefix = `${identity(item) === selected ? ">" : " "} ${indent}└ `;
-            return [
-              theme.fg(
-                identity(item) === selected ? "accent" : "text",
-                `${prefix}${assignmentHeadline(item)}${historical(item) ? " · history" : ""}`,
-              ),
-              theme.fg(
-                statusColor(item),
-                `${" ".repeat(visibleWidth(prefix))}${lineText(item.profile)} · ${item.status}`,
-              ),
-              "", // Separate agents without exposing internal generation numbers.
-            ];
-          }),
+          ...taskTree(children)
+            .slice(start, start + slots)
+            .flatMap(({ child: item, indent, last, continuation }) => {
+              const prefix = `${identity(item) === selected ? ">" : " "} ${indent}${last ? "└" : "├"} `;
+              return [
+                theme.fg(identity(item) === selected ? "accent" : "text", prefix[0]) +
+                  theme.fg("text", prefix.slice(1)) +
+                  theme.fg(statusColor(item), "● ") +
+                  theme.fg(
+                    identity(item) === selected ? "accent" : "text",
+                    `${assignmentHeadline(item)}${historical(item) ? " · history" : ""}`,
+                  ),
+                theme.fg("text", `  ${continuation}`) +
+                  theme.fg(statusColor(item), lineText(item.profile)) +
+                  theme.fg("text", ` · ${item.status}`),
+              ];
+            }),
         ];
         const right = [
           theme.fg("accent", lineText(selectedLabel)),
@@ -446,19 +450,23 @@ export function createHub(
       } else {
         const suffix = child ? ` · ${index + 1}/${children.length}` : "";
         pane.push(
-          theme.fg(
-            "accent",
-            child
-              ? `> └ ${truncateToWidth(agentLabel(child), Math.max(0, inner - 4 - visibleWidth(suffix)))}${suffix}`
-              : "No selection",
-          ),
+          child
+            ? theme.fg("accent", ">") +
+                theme.fg("text", " └ ") +
+                theme.fg(statusColor(child), "● ") +
+                theme.fg(
+                  "accent",
+                  `${truncateToWidth(agentLabel(child), Math.max(0, inner - 6 - visibleWidth(suffix)))}${suffix}`,
+                )
+            : theme.fg("accent", "No selection"),
         );
         if (paneHeight > 1)
           pane.push(
-            theme.fg(
-              child ? statusColor(child) : "muted",
-              `${tab.toUpperCase()}${child ? ` · ${child.profile} · ${child.status}` : ""}`,
-            ),
+            child
+              ? theme.fg("text", `${tab.toUpperCase()} · `) +
+                  theme.fg(statusColor(child), lineText(child.profile)) +
+                  theme.fg("text", ` · ${child.status}`)
+              : theme.fg("muted", tab.toUpperCase()),
           );
         if (paneHeight > 2)
           pane.push(

package/src/pi-extended-subagents.ts

@@ -107,7 +107,7 @@ export default function delegation(pi: ExtensionAPI) {
       (tui, theme) => {
         renderWidget = () => tui.requestRender();
         return createChildWidget(
-          () => coordinator.list(),
+          () => coordinator.sessions(),
           theme,
           () => tui.terminal.rows,
         );
@@ -373,7 +373,7 @@ export default function delegation(pi: ExtensionAPI) {
     label: "Coordinate delegation",
     exposure: "model-only",
     description:
-      "Live-parent identity-pinned coordination. message targets a running family agent (omit target for root inbox, direct children only); inbox reads own bounded mailbox; wait targets an outcome or own inbox with required 1–60000ms timeout, retaining capacity. No transcript access. Child actions require explicit operator grants. Root additionally has status/stop/park, paused resume (assignment is the appended continuation), and idle followup/parked revive. Resume retains identity and full context, resets only the deadline window, and requires explicit child resumes after parent resume. Followup/revive create a fresh generation/session with current model/auth and narrowed current grants, no old tool replay or historical recovery. Message accepted/queued is NOT model acknowledgment; delivered means transcript/inbox visibility only. 4096-byte messages, 64 mailbox/waiters, 512 messages and 64 generations per live parent.",
+      "Live-parent identity-pinned coordination. message targets a running family agent (omit target for root inbox, direct children only); inbox reads own bounded mailbox; wait targets an outcome or own inbox with required 1–60000ms timeout, retaining capacity. No transcript access. Child actions require explicit operator grants. Root additionally has status/stop/park, paused/completed resume (assignment is the appended continuation), and idle followup/parked revive. Resume retains identity and full context, resets only the deadline window, and requires explicit child resumes after parent resume. Followup/revive create a fresh generation/session with current model/auth and narrowed current grants, no old tool replay or historical recovery. Message accepted/queued is NOT model acknowledgment; delivered means transcript/inbox visibility only. 4096-byte messages, 64 mailbox/waiters, 512 messages and 64 generations per live parent.",
     parameters: coordinationParameters,
     async execute(callerId, args, signal, _update, ctx) {
       if (["resume", "followup", "revive"].includes(args.action)) requireSupportedHost();
@@ -493,10 +493,10 @@ export default function delegation(pi: ExtensionAPI) {
     promptGuidelines: [
       "Use subagent for native worker delegation requested by the user or an active workflow; no extension-specific user instruction or enable call is needed. Use agent worker for implementation, scout for research, review for review, or general for restricted inherited capabilities.",
       "Pass subagent the approved task handoff and existing workspace cwd. Preserve selected model routing; no model override is needed to inherit the parent. Pass accessible skill/reference paths in the task; general inherits available skills and callable builtins, plus operator-reviewed leaf tools only; parent instructions/history and project trust are not inherited.",
-      "subagent launches are async by default and wake this session after actual drain. Continue independent work or yield; do not poll or sleep. Use the exact returned id (UUID@generation) for status, steer, stop or resume. Resume continues a paused conversation with its full context and cumulative budgets; completed idle/parked work starts a fresh generation.",
+      "subagent launches are async by default and wake this session after actual drain. Continue independent work or yield; do not poll or sleep. Use the exact returned id (UUID@generation) for status, steer, stop or resume. Resume continues a drained paused or completed conversation with its same identity/generation, full SDK context and cumulative budgets; unavailable context and stopped/failed identities reject. Use explicit delegate_coordinate followup/revive for fresh completed work.",
     ],
     description:
-      "Native delegation for orchestration and coding task owners. Launch {agent,task,cwd?,model?,async?} or an ordered {tasks:[...],async?,cwd?} batch. worker maps explicitly to the implementation profile; unknown/custom agent names reject. Model strings require exact provider/id[:effort] and operator grants. Actions: agents, list, status/stop with exact returned id, steer/resume with id and message. Uses the same registry, parent permissions, limits and global writer lease as delegate_task. Existing workspaces only: file paths and shell cwd are explicitly adapted through root builtin hooks. No automatic worktree creation/commits/apply/deletion, detached survival, script workflows or blanket competing API parity. Do not load another provider of the subagent tool alongside this extension.",
+      "Native delegation for orchestration and coding task owners. Launch {agent,task,cwd?,model?,async?} or an ordered {tasks:[...],async?,cwd?} batch. worker maps explicitly to the implementation profile; unknown/custom agent names reject. Model strings require exact provider/id[:effort] and operator grants. Actions: agents, list, status/stop with exact returned id, steer/resume with id and message. Resume requires a drained paused or completed session and restores its full conversation with the same identity/generation and session count; unavailable context and stopped/failed identities reject. Uses the same registry, parent permissions, limits and global writer lease as delegate_task. Existing workspaces only: file paths and shell cwd are explicitly adapted through root builtin hooks. No automatic worktree creation/commits/apply/deletion, detached survival, script workflows or blanket competing API parity. Do not load another provider of the subagent tool alongside this extension.",
     parameters: compatibleParameters,
     async execute(callerId, args, signal, onUpdate, ctx) {
       if (!("action" in args) || args.action === "resume" || args.action === "steer")
@@ -564,20 +564,10 @@ export default function delegation(pi: ExtensionAPI) {
       if (args.action === "stop") await owner.stop(target);
       else if (args.action === "steer") await owner.steer(target, args.message);
       else if ("message" in args) {
-        const presence = owner
-          .agents()
-          .find(
-            (state) => state.id === target.id && state.generation === target.generation,
-          )?.presence;
         const response = await coordinationTool(undefined, undefined, true).execute(
           callerId,
           {
-            action:
-              owner.snapshot(target)?.status === "paused"
-                ? "resume"
-                : presence === "parked"
-                  ? "revive"
-                  : "followup",
+            action: "resume",
             target,
             assignment: args.message,
           },
@@ -586,10 +576,6 @@ export default function delegation(pi: ExtensionAPI) {
           ctx,
         );
         const next = response.details as ChildSnapshot;
-        if (next.generation !== target.generation)
-          void owner.wait(next).then((state) => {
-            if (!closing && coordinator === owner) show(compatible(state), state.transcript, true);
-          });
         return result(compatible(next));
       }
       return result(compatible(owner.snapshot(target)!));

package/src/subagent-widget.ts

@@ -6,9 +6,16 @@ import {
 } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { ChildSnapshot } from "./coordinator.ts";
-import { active, activity, assignmentHeadline, lineText, statuses } from "./task-presentation.ts";
+import {
+  active,
+  activity,
+  assignmentHeadline,
+  lineText,
+  statuses,
+  taskTree,
+} from "./task-presentation.ts";
 
-/** Event-driven, bounded current-agent tree; history and full metrics remain in the Hub. */
+/** Full session totals with an event-driven, bounded active-agent tree; details remain in the Hub. */
 export function createChildWidget(
   snapshot: () => ChildSnapshot[],
   theme: Pick<Theme, "fg"> & Partial<Pick<Theme, "bold">>,
@@ -55,15 +62,31 @@ export function createChildWidget(
       const activityRows = live.length && room >= (live.length > 1 ? 3 : 2) ? 1 : 0;
       const slots = room - activityRows;
       const overflow = live.length > slots;
-      const shown = live.slice(0, Math.max(0, slots - (overflow ? 1 : 0)));
-      shown.forEach((child, index) => {
-        const last = index === shown.length - 1 && shown.length === live.length;
+      const visible = taskTree(live)
+        .slice(0, Math.max(0, slots - (overflow ? 1 : 0)))
+        .map(({ child }) => child);
+      // Close the last visible sibling; the root overflow row represents hidden tasks.
+      const shown = taskTree(visible, { laneWidth: 3, rootContinues: overflow });
+      const lead = visible[0];
+      const nestedUnderLead = (child: ChildSnapshot) =>
+        lead &&
+        child.parentId === lead.id &&
+        (child.parentGeneration ?? child.generation) === lead.generation;
+      const hiddenRunning = activityRows
+        ? live.filter(
+            (child) =>
+              nestedUnderLead(child) && child.status === "running" && !visible.includes(child),
+          ).length
+        : 0;
+      shown.forEach(({ child, indent, last, continuation }, index) => {
         const color =
           child.status === "draining" || child.status === "pausing" ? "warning" : "accent";
         const role = lineText(child.profile);
-        const indent = "  ".repeat(Math.min(3, Math.max(0, child.depth - 1)));
         const prefix =
-          theme.fg("muted", `${indent}${last ? "└─" : "├─"} `) +
+          theme.fg(
+            "muted",
+            `${indent}${last && !(hiddenRunning && nestedUnderLead(child)) ? "└─" : "├─"} `,
+          ) +
           theme.fg(color, "● ") +
           (theme.bold?.(role) ?? role) +
           " ";
@@ -92,8 +115,12 @@ export function createChildWidget(
             ) +
             theme.fg("muted", " · " + metric),
         );
-        if (!index && activityRows) {
-          const prefix = `${indent}${last ? "   " : "│  "} └ `;
+        if (!index && activityRows && !hiddenRunning) {
+          const next = shown[index + 1]?.child;
+          const hasVisibleChild =
+            next?.parentId === child.id &&
+            (next.parentGeneration ?? next.generation) === child.generation;
+          const prefix = `${continuation}${hasVisibleChild ? "├" : "└"} `;
           const text = lineText(activity(child));
           const columns = Math.max(0, width - visibleWidth(prefix));
           const length = visibleWidth(text);
@@ -106,6 +133,14 @@ export function createChildWidget(
           rows.push(theme.fg("muted", prefix + preview));
         }
       });
+      if (hiddenRunning) {
+        rows.push(
+          theme.fg(
+            "muted",
+            `${shown[0].continuation}└─ ${hiddenRunning} more nested subagent${hiddenRunning === 1 ? "" : "s"} running`,
+          ),
+        );
+      }
       if (shown.length < live.length && room)
         rows.push(theme.fg("muted", `└─ ${live.length - shown.length} more · /subagent-hub`));
       return rows.slice(0, budget).map((line) => truncateToWidth(line, width));

package/src/task-presentation.ts

@@ -20,6 +20,37 @@ export const activity = (child: ChildSnapshot) =>
   child.progress ||
   "Waiting for SDK activity";
 export const writerWarning = "Model-tool writer only: no conflicting manual !/!! or external edits";
+/** Presentation-only preorder, keyed by exact parent generation. */
+export function taskTree(children: ChildSnapshot[], { laneWidth = 4, rootContinues = false } = {}) {
+  const byIdentity = new Map(children.map((child) => [`${child.id}/${child.generation}`, child]));
+  const siblings = new Map<ChildSnapshot | undefined, ChildSnapshot[]>();
+  for (const child of children) {
+    const candidate = byIdentity.get(
+      `${child.parentId}/${child.parentGeneration ?? child.generation}`,
+    );
+    const parent = candidate && candidate.depth < child.depth ? candidate : undefined;
+    const group = siblings.get(parent) ?? [];
+    group.push(child);
+    siblings.set(parent, group);
+  }
+  const rows: { child: ChildSnapshot; indent: string; last: boolean; continuation: string }[] = [];
+  const visit = (parent: ChildSnapshot | undefined, lanes: string) => {
+    const group = siblings.get(parent) ?? [];
+    group.forEach((child, index) => {
+      const last = index === group.length - 1 && (parent !== undefined || !rootContinues);
+      // Missing/filtered ancestors retain depth without inventing continuation pipes.
+      const indent = parent
+        ? lanes.slice(0, laneWidth * 3)
+        : " ".repeat(laneWidth * Math.min(3, Math.max(0, child.depth - 1)));
+      const continuation = indent + (last ? " " : "│") + " ".repeat(laneWidth - 1);
+      rows.push({ child, indent, last, continuation });
+      visit(child, continuation);
+    });
+  };
+  visit(undefined, "");
+  return rows;
+}
+
 export const statuses = [
   "queued",
   "setup",