oira666_pi-subagent 0.3.14 → 0.3.15

package/README.md

@@ -152,6 +152,22 @@ pi --no-subagent-prevent-cycles   # allow cycles (not recommended)
 | `PI_SUBAGENT_MAX_PARALLEL_TASKS` | `30`    | Max tasks per single call                |
 | `PI_SUBAGENT_MAX_CONCURRENCY`    | `8`     | Max subagents running simultaneously     |
 
+## Child Process Environment
+
+Children inherit all provider, authentication, proxy, home, temp, and Pi
+environment variables. The runner also repairs the executable search path for
+elevated Windows PowerShell and pnpm installations: it normalizes duplicate
+`Path`/`PATH` keys and adds the Node directory, `PNPM_HOME`, npm's user bin,
+`%LOCALAPPDATA%\\pnpm`, and `%SystemRoot%\\System32`. This also applies to every
+nested child, so tools and sub-subagents use the same working environment.
+
+Pi itself is relaunched with the current runtime and entrypoint
+(`process.execPath process.argv[1]`). The extension does not inspect npm/pnpm
+shims or assume package names, `node_modules` locations, or Pi `dist` layouts.
+This also supports Bun and other Node-compatible runtimes with the same process
+semantics. Embedded hosts without a script entrypoint can use
+`PI_SUBAGENT_PI_COMMAND` and `PI_SUBAGENT_PI_ARGS_PREFIX` explicitly.
+
 ## Subagent Liveness Timeouts
 
 A delegated process cannot block its parents forever. The runner applies a
@@ -176,11 +192,12 @@ reported immediately as failures.
 
 ## Timestamps & Status Footer
 
-Subagent tool calls and live activity lines render a dim `hh:mm:ss` timestamp
-(call start, per-subagent run start, and each live log entry). The collapsed tool
-row keeps the normal compact progress text. Press `Ctrl+O` to expand it into the
-subagent tree immediately; every running node shows its latest six activity
-lines (thinking, tool starts/completions, and completed turns).
+Subagent tool calls and live activity lines render a dim `hh:mm:ss` timestamp.
+The collapsed view shows every direct child as `Name (agent-type)`, two prompt
+lines, its current status, and `last action`. That timestamp is the newest
+activity anywhere in the child's recursive subtree, so active grandchildren
+keep their ancestor visibly alive. Press `Ctrl+O` to expand the full recursive
+tree, including every agent's complete prompt and latest activity lines.
 
 In the interactive TUI the extension publishes the combined `total` usage line
 (parent + all subagents, recursively) via Pi's normal `ctx.ui.setStatus()`
@@ -188,7 +205,7 @@ status line. Pi renders all extension statuses on the same footer status line.
 
 ## Steering Running Subagents
 
-While a `subagents` tool call is running, mid-stream steering input can be broadcast to one or more child agents. The extension uses Pi's `InputEvent.streamingBehavior` metadata when available, so idle prompts and queued follow-ups continue to the parent normally; only true `steer` inputs open the broadcast routing prompt.
+While a `subagents` tool call is running, mid-stream steering input can be broadcast to one or more child agents. Targets are selected by human name; nested targets use paths such as `John > Maria > Elena`. The extension uses Pi's `InputEvent.streamingBehavior` metadata when available, so idle prompts and queued follow-ups continue to the parent normally; only true `steer` inputs open the broadcast routing prompt.
 
 ## Subagent Session Resume
 
@@ -215,16 +232,16 @@ Note: crash-resume covers `subagents` calls only. An interrupted `resume_subagen
 
 ## Resumable Subagents by Name (`resume_subagents`)
 
-Every subagent run is assigned a unique, durable name derived from its agent
-type plus a per-type counter — `code-writer-01`, `code-writer-02`,
-`code-reviewer-01`, ... The name is returned together with the subagent's
-results and shown in the TUI tree.
+Every subagent run is assigned a random, durable human first name from a bundled
+list of 500 popular American names — for example `John`, `Maria`, or `Elena`.
+Names are never reused anywhere in the same delegation tree. The name is
+returned together with the agent type and shown in every TUI view.
 
 The `resume_subagents` tool continues named subagents with a new task while
 preserving their full previous context:
 
 ```json
-{ "resumes": [{ "subagent": "code-writer-01", "task": "Now also update the tests." }] }
+{ "resumes": [{ "subagent": "John", "task": "Now also update the tests." }] }
 ```
 
 Naming is deliberately unambiguous: `agent` (in `subagents`) selects an agent

package/american-names.ts

@@ -0,0 +1,56 @@
+/** 500 common American first names used for human-friendly subagent identities. */
+export const AMERICAN_NAMES = [
+  // Common masculine names
+  "James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Thomas", "Christopher",
+  "Charles", "Daniel", "Matthew", "Anthony", "Mark", "Donald", "Steven", "Andrew", "Paul", "Joshua",
+  "Kenneth", "Kevin", "Brian", "George", "Timothy", "Ronald", "Edward", "Jason", "Jeffrey", "Ryan",
+  "Jacob", "Gary", "Nicholas", "Eric", "Jonathan", "Stephen", "Larry", "Justin", "Scott", "Brandon",
+  "Benjamin", "Samuel", "Gregory", "Alexander", "Patrick", "Frank", "Raymond", "Jack", "Dennis", "Jerry",
+  "Tyler", "Aaron", "Jose", "Adam", "Nathan", "Henry", "Douglas", "Zachary", "Peter", "Kyle",
+  "Walter", "Ethan", "Jeremy", "Harold", "Keith", "Christian", "Roger", "Noah", "Gerald", "Carl",
+  "Terry", "Sean", "Austin", "Arthur", "Lawrence", "Jesse", "Dylan", "Bryan", "Joe", "Jordan",
+  "Billy", "Bruce", "Albert", "Willie", "Gabriel", "Logan", "Alan", "Juan", "Wayne", "Roy",
+  "Ralph", "Randy", "Eugene", "Vincent", "Russell", "Elijah", "Louis", "Bobby", "Philip", "Johnny",
+  "Howard", "Isaac", "Harry", "Victor", "Martin", "Ernest", "Phillip", "Todd", "Craig", "Shawn",
+  "Clarence", "Carlos", "Caleb", "Blake", "Mason", "Luke", "Liam", "Owen", "Nathaniel", "Cameron",
+  "Hunter", "Connor", "Adrian", "Julian", "Jeremiah", "Angel", "Isaiah", "Evan", "Colton", "Gavin",
+  "Dominic", "Cooper", "Ian", "Carson", "Jaxon", "Theodore", "Hudson", "Lincoln", "Asher", "Wyatt",
+  "Leo", "Ezra", "Miles", "Micah", "Silas", "Roman", "Wesley", "Brooks", "Bennett", "Parker",
+  "Beau", "Weston", "Damian", "Sawyer", "Emmett", "Harrison", "Cole", "Maxwell", "Holden", "Antonio",
+  "Miguel", "Oscar", "Diego", "Alejandro", "Marco", "Luis", "Javier", "Sergio", "Ricardo", "Manuel",
+  "Roberto", "Francisco", "Eduardo", "Fernando", "Ruben", "Raul", "Andres", "Hector", "Edgar", "Mario",
+  "Derek", "Trevor", "Travis", "Cody", "Dustin", "Corey", "Brett", "Chad", "Bradley", "Spencer",
+  "Grant", "Joel", "Dean", "Dale", "Glenn", "Stanley", "Leonard", "Francis", "Herbert", "Frederick",
+  "Norman", "Melvin", "Marvin", "Gordon", "Allen", "Bernard", "Clifford", "Warren", "Curtis", "Darren",
+  "Troy", "Marcus", "Derrick", "Andre", "Terrence", "Maurice", "Darius", "Malcolm", "Xavier", "Preston",
+  "Grayson", "Easton", "Nolan", "Everett", "Axel", "Emmanuel", "Kingston", "Elliot", "Tim", "Simon",
+  "Riley", "Finn", "Jasper", "Milo", "Rowan", "Declan", "Graham", "Max", "Nash", "Reid",
+  "Lane", "Tucker", "Carter", "Chase", "Coleman", "Bryce", "Hayden", "Aidan", "Jonah", "Jonas",
+
+  // Common feminine names
+  "Mary", "Patricia", "Jennifer", "Linda", "Elizabeth", "Barbara", "Susan", "Jessica", "Sarah", "Karen",
+  "Lisa", "Nancy", "Betty", "Margaret", "Sandra", "Ashley", "Kimberly", "Emily", "Donna", "Michelle",
+  "Carol", "Amanda", "Melissa", "Deborah", "Stephanie", "Dorothy", "Rebecca", "Sharon", "Laura", "Cynthia",
+  "Amy", "Kathleen", "Angela", "Shirley", "Brenda", "Emma", "Anna", "Pamela", "Nicole", "Samantha",
+  "Katherine", "Christine", "Debra", "Rachel", "Carolyn", "Janet", "Maria", "Heather", "Diane", "Julie",
+  "Joyce", "Victoria", "Kelly", "Christina", "Lauren", "Joan", "Evelyn", "Olivia", "Judith", "Megan",
+  "Cheryl", "Martha", "Andrea", "Frances", "Hannah", "Jacqueline", "Ann", "Gloria", "Jean", "Kathryn",
+  "Alice", "Teresa", "Sara", "Janice", "Doris", "Madison", "Julia", "Grace", "Judy", "Abigail",
+  "Marie", "Denise", "Beverly", "Amber", "Theresa", "Marilyn", "Danielle", "Diana", "Brittany", "Natalie",
+  "Sophia", "Rose", "Isabella", "Alexis", "Kayla", "Charlotte", "Lori", "Alexandra", "Savannah", "Brooklyn",
+  "Bella", "Claire", "Skylar", "Lucy", "Paisley", "Everly", "Caroline", "Nova", "Genesis", "Emilia",
+  "Kennedy", "Maya", "Willow", "Kinsley", "Naomi", "Aaliyah", "Elena", "Mckenna", "Ariana", "Allison",
+  "Gabriella", "Margot", "Madelyn", "Cora", "Ruby", "Eva", "Serenity", "Autumn", "Adeline", "Hailey",
+  "Gianna", "Valentina", "Isla", "Eliana", "Quinn", "Nevaeh", "Ivy", "Sadie", "Piper", "Lydia",
+  "Alexa", "Josephine", "Emery", "Phoebe", "Delilah", "Arianna", "Vivian", "Kaylee", "Sophie", "Brielle",
+  "Madeline", "Peyton", "Rylee", "Clara", "Hadley", "Melanie", "Mackenzie", "Reagan", "Adalynn", "Liliana",
+  "Aubree", "Jade", "Miranda", "Isabelle", "Natalia", "Raelynn", "Dakota", "Athena", "Ximena", "Arya",
+  "Leilani", "Taylor", "Faith", "Lena", "Kylie", "Miriam", "Kate", "Summer", "Lyla", "Brooke",
+  "Amaya", "Eliza", "Brianna", "Bailey", "Nina", "Khloe", "Jasmine", "Melody", "Isabel", "Norah",
+  "Annabelle", "Valeria", "Emerson", "Cecilia", "Valerie", "Molly", "Reese", "Aliyah", "Lilly", "Blair",
+  "Finley", "Morgan", "Sydney", "Jordyn", "Eloise", "Trinity", "Daisy", "Catherine", "Lola", "Genevieve",
+  "Marley", "Arabella", "Harmony", "Elise", "Remi", "Teagan", "Evie", "London", "Sloane", "Laila",
+  "Lucia", "Willa", "Juliana", "Gracie", "June", "Tessa", "Ada", "Camille", "Hope", "Samara",
+  "Rosalie", "Ruth", "Fiona", "Georgia", "Noelle", "Vanessa", "Daniela", "Paige", "Violet", "Presley",
+  "Adriana", "Joanna", "Giselle", "Harper", "Avery", "Scarlett", "Aria", "Ellie", "Chloe", "Layla",
+] as const;

package/index.ts

@@ -45,7 +45,6 @@ import {
   renderCall,
   renderResult,
   renderResumeCall,
-  setBroadcastNumberingActive,
 } from "./render.js";
 import { runAgentSubprocess, executeParallelSubprocess, type RunningSubagentHandle } from "./runner.js";
 import {
@@ -166,7 +165,7 @@ const SubagentParams = Type.Object({
 
 const ResumeItem = Type.Object({
   subagent: Type.String({
-    description: "Unique subagent name returned by a previous subagents run (e.g. code-writer-01)",
+    description: "Unique human name returned by a previous subagents run (e.g. John)",
   }),
   task: Type.String({
     description: "New task for the resumed subagent. It keeps its previous context.",
@@ -1001,7 +1000,7 @@ export default function (pi: ExtensionAPI) {
   let pendingResumePlans: ResumableSubagentCall[] = [];
   let modelToRestoreAfterResume: any | undefined;
   const approvedProjectAgentDirsForSession = new Set<string>();
-  const activeSubagents = new Map<number, { agent: string; task: string; taskIndex: number; handle: RunningSubagentHandle; name?: string }>();
+  const activeSubagents = new Map<number, { agent: string; task: string; handle: RunningSubagentHandle; name?: string }>();
   /** Names with a resume in flight in this process (same-process race guard). */
   const activeResumeNames = new Set<string>();
   /** Tool calls whose execute result requested an actual Pi error result. */
@@ -1083,9 +1082,10 @@ export default function (pi: ExtensionAPI) {
   const BROADCAST_STEER_PREFIX = "__PI_SUBAGENT_BROADCAST_STEER__";
 
   interface BroadcastTarget {
+    /** Human-name path, e.g. "John > Maria > Elena". */
     display: string;
     topLevelId: number;
-    restPath: number[];
+    restPath: string[];
   }
 
   interface ParsedBroadcastSelection {
@@ -1093,83 +1093,40 @@ export default function (pi: ExtensionAPI) {
     errors: string[];
   }
 
-  function parseBroadcastPath(raw: string): number[] | null {
-    const parts = raw.trim().split(".");
-    if (parts.length === 0) return null;
-    const path: number[] = [];
-    for (const part of parts) {
-      if (!/^\d+$/.test(part)) return null;
-      const value = Number(part);
-      if (!Number.isSafeInteger(value) || value < 1) return null;
-      path.push(value);
+  function parseBroadcastSelection(input: string, available: BroadcastTarget[]): ParsedBroadcastSelection {
+    if (input.trim().toUpperCase() === "ALL") return { targets: [...available], errors: [] };
+    const byName = new Map<string, BroadcastTarget>();
+    for (const target of available) {
+      byName.set(target.display.toLowerCase(), target);
+      // Names are globally unique across the delegation tree, so a nested leaf
+      // can be addressed as "Maria" without spelling "John > Maria".
+      const leafName = target.display.split(" > ").at(-1);
+      if (leafName) byName.set(leafName.toLowerCase(), target);
     }
-    return path;
-  }
-
-  function parseBroadcastSelection(input: string, available: number[]): ParsedBroadcastSelection {
-    const normalized = input.trim().toUpperCase();
-    if (normalized === "ALL") {
-      return {
-        targets: available.map((id) => ({ display: String(id), topLevelId: id, restPath: [] })),
-        errors: [],
-      };
-    }
-
+    const targets: BroadcastTarget[] = [];
     const errors: string[] = [];
-    const targetMap = new Map<string, BroadcastTarget>();
     for (const rawPart of input.split(",")) {
-      const part = rawPart.trim();
-      if (!part) continue;
-
-      if (part.includes("-")) {
-        const [startRaw, endRaw, extra] = part.split("-").map((p) => p.trim());
-        const startPath = parseBroadcastPath(startRaw);
-        const endPath = parseBroadcastPath(endRaw);
-        if (extra !== undefined || !startPath || !endPath || startPath.length !== 1 || endPath.length !== 1) {
-          errors.push(`Invalid range "${part}". Use top-level ranges like 1-3.`);
-          continue;
-        }
-        const start = startPath[0];
-        const end = endPath[0];
-        for (let id = Math.min(start, end); id <= Math.max(start, end); id++) {
-          if (!available.includes(id)) {
-            errors.push(`Subagent ${id} is not running.`);
-            continue;
-          }
-          targetMap.set(String(id), { display: String(id), topLevelId: id, restPath: [] });
-        }
-        continue;
-      }
-
-      const path = parseBroadcastPath(part);
-      if (!path) {
-        errors.push(`Invalid target "${part}". Use ALL, numbers, paths, or top-level ranges (e.g. 1, 2, 4.1, 1-3).`);
-        continue;
-      }
-      const [topLevelId, ...restPath] = path;
-      if (!available.includes(topLevelId)) {
-        errors.push(`Subagent ${topLevelId} is not running.`);
-        continue;
-      }
-      const display = path.join(".");
-      targetMap.set(display, { display, topLevelId, restPath });
+      const requested = rawPart.trim();
+      if (!requested) continue;
+      const target = byName.get(requested.toLowerCase());
+      if (target) targets.push(target);
+      else errors.push(`Subagent "${requested}" is not running. Use its human name.`);
     }
-
     return {
-      targets: Array.from(targetMap.values()).sort((a, b) => a.display.localeCompare(b.display, undefined, { numeric: true })),
+      targets: Array.from(new Map(targets.map((target) => [target.display, target])).values()),
       errors,
     };
   }
 
-  function encodeNestedBroadcast(message: string, path: number[]): string {
+  function encodeNestedBroadcast(message: string, path: string[]): string {
     return `${BROADCAST_STEER_PREFIX}${JSON.stringify({ path, message })}`;
   }
 
-  function decodeNestedBroadcast(text: string): { path: number[]; message: string } | null {
+  function decodeNestedBroadcast(text: string): { path: string[]; message: string } | null {
     if (!text.startsWith(BROADCAST_STEER_PREFIX)) return null;
     try {
       const parsed = JSON.parse(text.slice(BROADCAST_STEER_PREFIX.length));
-      if (!Array.isArray(parsed?.path) || !parsed.path.every((n: unknown) => Number.isSafeInteger(n) && (n as number) >= 1)) return null;
+      if (!Array.isArray(parsed?.path) || !parsed.path.every((name: unknown) => typeof name === "string" && name.length > 0)) return null;
       if (typeof parsed?.message !== "string") return null;
       return { path: parsed.path, message: parsed.message };
     } catch {
@@ -1177,66 +1134,37 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
-  function extractPendingSubagentTaskCounts(result: SingleResult): number[] {
-    const messages = Array.isArray((result as any).messages) ? (result as any).messages : [];
-    const completedToolCallIds = new Set(getNestedSubagentResults(messages).map((nested) => nested.toolCallId));
-    const counts: number[] = [];
-    for (const message of messages) {
-      if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
-      for (const part of message.content) {
-        if (part?.type !== "toolCall" || !isSubagentToolName(part?.name)) continue;
-        const toolCallId = typeof part.toolCallId === "string" ? part.toolCallId : typeof part.id === "string" ? part.id : undefined;
-        if (toolCallId && completedToolCallIds.has(toolCallId)) continue;
-        const rawResumes = part.arguments?.resumes;
-        const tasks = Array.isArray(part.arguments?.tasks)
-          ? part.arguments.tasks
-          : Array.isArray(rawResumes)
-            ? rawResumes
-            : rawResumes && typeof rawResumes === "object"
-              ? [rawResumes]
-              : [];
-        if (tasks.length > 0) counts.push(tasks.length);
-      }
-    }
-    return counts;
-  }
-
   function collectRunningBroadcastTargetsFromResult(
     result: SingleResult,
-    path: number[],
+    namePath: string[],
+    topLevelId: number,
     targets: { all: BroadcastTarget[]; youngest: BroadcastTarget[] },
   ): boolean {
-    const nestedRunningPaths: number[][] = [];
-
+    let hasRunningDescendant = false;
+    const completedIds = new Set<string>();
+    const nestedDetails: SubagentDetails[] = [];
     for (const nested of getNestedSubagentResults(result.messages)) {
       if (!isSubagentDetails(nested.details)) continue;
-      nested.details.results.forEach((child, index) => {
-        const childPath = [...path, index + 1];
-        if (collectRunningBroadcastTargetsFromResult(child, childPath, targets)) {
-          nestedRunningPaths.push(childPath);
-        }
-      });
+      if (nested.toolCallId) completedIds.add(nested.toolCallId);
+      nestedDetails.push(nested.details);
     }
-
-    if (result.exitCode === -1) {
-      for (const taskCount of extractPendingSubagentTaskCounts(result)) {
-        for (let i = 1; i <= taskCount; i++) {
-          const childPath = [...path, i];
-          const [topLevelId, ...restPath] = childPath;
-          targets.all.push({ display: childPath.join("."), topLevelId, restPath });
-          targets.youngest.push({ display: childPath.join("."), topLevelId, restPath });
-          nestedRunningPaths.push(childPath);
+    for (const [toolCallId, live] of Object.entries(result.liveNestedSubagents ?? {})) {
+      if (!completedIds.has(toolCallId) && isSubagentDetails(live)) nestedDetails.push(live);
+    }
+    for (const details of nestedDetails) {
+      for (const child of details.results) {
+        const childName = child.name || child.agent;
+        if (collectRunningBroadcastTargetsFromResult(child, [...namePath, childName], topLevelId, targets)) {
+          hasRunningDescendant = true;
         }
       }
     }
 
-    const isRunning = result.exitCode === -1;
-    if (!isRunning) return nestedRunningPaths.length > 0;
-
-    const [topLevelId, ...restPath] = path;
-    const self = { display: path.join("."), topLevelId, restPath };
+    if (result.exitCode !== -1) return hasRunningDescendant;
+    const restPath = namePath.slice(1);
+    const self = { display: namePath.join(" > "), topLevelId, restPath };
     targets.all.push(self);
-    if (nestedRunningPaths.length === 0) targets.youngest.push(self);
+    if (!hasRunningDescendant) targets.youngest.push(self);
     return true;
   }
 
@@ -1244,28 +1172,34 @@ export default function (pi: ExtensionAPI) {
     latestBroadcastTargets.all = [];
     latestBroadcastTargets.youngest = [];
     if (!details) {
-      for (const id of activeSubagents.keys()) {
-        const target = { display: String(id), topLevelId: id, restPath: [] };
+      for (const [id, active] of activeSubagents) {
+        const display = active.name || active.agent;
+        const target = { display, topLevelId: id, restPath: [] };
         latestBroadcastTargets.all.push(target);
         latestBroadcastTargets.youngest.push(target);
       }
       return;
     }
     details.results.forEach((result, index) => {
-      collectRunningBroadcastTargetsFromResult(result, [topLevelBaseId + index], latestBroadcastTargets);
+      collectRunningBroadcastTargetsFromResult(
+        result,
+        [result.name || result.agent],
+        topLevelBaseId + index,
+        latestBroadcastTargets,
+      );
     });
     const dedupe = (targets: BroadcastTarget[]) =>
       Array.from(new Map(targets.map((target) => [target.display, target])).values())
         .filter((target) => activeSubagents.has(target.topLevelId))
-        .sort((a, b) => a.display.localeCompare(b.display, undefined, { numeric: true }));
+        .sort((a, b) => a.display.localeCompare(b.display));
     latestBroadcastTargets.all = dedupe(latestBroadcastTargets.all);
     latestBroadcastTargets.youngest = dedupe(latestBroadcastTargets.youngest);
   }
 
   function getFallbackTopLevelTargets(): BroadcastTarget[] {
-    return Array.from(activeSubagents.keys())
-      .sort((a, b) => a - b)
-      .map((id) => ({ display: String(id), topLevelId: id, restPath: [] }));
+    return Array.from(activeSubagents.entries())
+      .sort(([a], [b]) => a - b)
+      .map(([id, active]) => ({ display: active.name || active.agent, topLevelId: id, restPath: [] }));
   }
 
   function sendBroadcastToTargets(message: string, targets: BroadcastTarget[], ctx: any): void {
@@ -1297,30 +1231,24 @@ export default function (pi: ExtensionAPI) {
     if (nested) {
       if (activeSubagents.size === 0) return "handled";
       const [rawTarget, ...restPath] = nested.path;
-      // Path components below the top level are 1-based task indexes within the
-      // subagent tool call running in THIS process. Internal active ids keep
-      // growing across sequential tool calls (and process restarts), so resolve
-      // by task index first; fall back to a direct id match for compatibility.
       let resolvedId: number | undefined;
       for (const [id, item] of activeSubagents) {
-        if (item.taskIndex === rawTarget - 1 && (resolvedId === undefined || id > resolvedId)) {
+        if ((item.name || item.agent).toLowerCase() === rawTarget.toLowerCase()) {
           resolvedId = id;
+          break;
         }
       }
-      if (resolvedId === undefined && activeSubagents.has(rawTarget)) resolvedId = rawTarget;
       if (resolvedId === undefined) return "handled";
-      sendBroadcastToTargets(nested.message, [{ display: nested.path.join("."), topLevelId: resolvedId, restPath }], ctx);
+      sendBroadcastToTargets(nested.message, [{ display: nested.path.join(" > "), topLevelId: resolvedId, restPath }], ctx);
       return "handled";
     }
 
     if (!ctx.hasUI || activeSubagents.size === 0) return "continue";
 
-    setBroadcastNumberingActive(true);
     try {
-      const available = Array.from(activeSubagents.keys()).sort((a, b) => a - b);
       const choice = await ctx.ui.select(
         "Broadcast this steering message to subagents?",
-        ["No", "All (+nested)", "Youngest", "Numbers (e.g. 1, 2, 4.1)"],
+        ["No", "All (+nested)", "Youngest", "Names (e.g. John, Maria)"],
       );
       if (choice === "All (+nested)" || choice === "Youngest") {
         const fallback = getFallbackTopLevelTargets();
@@ -1335,29 +1263,19 @@ export default function (pi: ExtensionAPI) {
         sendBroadcastToTargets(message, current, ctx);
         return "handled";
       }
-      if (choice !== "Numbers (e.g. 1, 2, 4.1)") return "continue";
+      if (choice !== "Names (e.g. John, Maria)") return "continue";
 
       const answer = await ctx.ui.input(
-        "Subagent numbers/ranges to broadcast to (e.g. 1, 2, 4.1)",
+        "Subagent names to broadcast to (comma-separated)",
         "",
       );
       if (!answer) return "continue";
-      const current = Array.from(new Set([
-        ...available,
-        ...latestBroadcastTargets.all.map((target) => target.topLevelId),
-      ])).sort((a, b) => a - b);
+      const current = latestBroadcastTargets.all.length > 0
+        ? latestBroadcastTargets.all
+        : getFallbackTopLevelTargets();
       const parsed = parseBroadcastSelection(answer, current);
-      const knownDisplays = new Set(latestBroadcastTargets.all.map((target) => target.display));
-      const validatedTargets = knownDisplays.size > 0
-        ? parsed.targets.filter((target) => knownDisplays.has(target.display))
-        : parsed.targets;
-      const unknownNested = knownDisplays.size > 0
-        ? parsed.targets.filter((target) => !knownDisplays.has(target.display)).map((target) => target.display)
-        : [];
-      const errors = [
-        ...parsed.errors,
-        ...unknownNested.map((display) => `Subagent ${display} is not running.`),
-      ];
+      const validatedTargets = parsed.targets;
+      const errors = parsed.errors;
       if (errors.length > 0) {
         ctx.ui.notify(errors.slice(0, 4).join("\n"), "warning");
       }
@@ -1368,7 +1286,7 @@ export default function (pi: ExtensionAPI) {
       sendBroadcastToTargets(message, validatedTargets, ctx);
       return "handled";
     } finally {
-      setBroadcastNumberingActive(false);
+      // No persistent steering UI state.
     }
   }
 
@@ -1790,13 +1708,13 @@ ${preventCycles
         ? ""
         : configuredToolPrompts[RESUME_SUBAGENTS_TOOL_NAME] ?? `### Resumable subagents
 
-Every subagent run is assigned a unique, durable name (e.g. \`code-writer-01\`,
-\`code-reviewer-02\`) which is returned together with its results. Use the
+Every subagent run is assigned a unique, durable human name (e.g. \`John\`,
+\`Maria\`) which is returned together with its results. Use the
 \`resume_subagents\` tool to continue named subagents with a new task while
 keeping their full previous context:
 
 \`\`\`json
-{ "resumes": [{ "subagent": "code-writer-01", "task": "Now also update the tests." }] }
+{ "resumes": [{ "subagent": "John", "task": "Now also update the tests." }] }
 \`\`\`
 
 - \`agent\` (in \`subagents\`) is an agent TYPE; \`subagent\` (in \`resume_subagents\`)
@@ -1937,7 +1855,7 @@ ${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidan
             pendingResumePlans.splice(resumePlanIndex, 1);
           }
 
-          // Assign durable, tree-unique names (code-writer-01, ...). Resumed
+          // Assign random durable human names unique across the whole tree. Resumed
           // runs keep the names already recorded in the previous results.
           const names: Array<string | undefined> = tasks.map(
             (_task, index) => resumePlan?.details?.results[index]?.name,
@@ -1969,7 +1887,7 @@ ${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidan
                   names[index] = allocated[allocIndex];
                 });
               } catch (err) {
-                console.warn("[pi-subagent] Failed to allocate subagent names (continuing without):", err);
+                throw new Error(`Failed to allocate unique subagent names: ${err instanceof Error ? err.message : String(err)}`);
               }
             }
           }
@@ -2037,10 +1955,10 @@ ${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidan
       description: configuredToolPrompts[RESUME_SUBAGENTS_TOOL_NAME] ?? [
         "Resume previously run subagents by name with a new task, keeping their full context.",
         "",
-        "Every subagent run returns a unique name (e.g. code-writer-01). Pass those names",
+        "Every subagent run returns a unique human name (e.g. John). Pass those names",
         "as `subagent` to continue them. All resumes in one call run IN PARALLEL.",
         "",
-        'Example: { resumes: [{ subagent: "code-writer-01", task: "Also update the tests." }] }',
+        'Example: { resumes: [{ subagent: "John", task: "Also update the tests." }] }',
       ].join("\n"),
       parameters: ResumeSubagentsParams,
       prepareArguments: prepareResumeArguments,
@@ -2274,7 +2192,9 @@ ${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidan
   // -----------------------------------------------------------------------
 
   function formatNameSuffix(result: SingleResult | undefined): string {
-    return result?.name ? `\n\n(subagent name: ${result.name} — resumable via resume_subagents)` : "";
+    return result?.name
+      ? `\n\n(subagent: ${result.name} (${result.agent}) — resume with the name ${result.name})`
+      : "";
   }
 
   async function executeSingle(
@@ -2326,7 +2246,7 @@ ${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidan
       fallbackModel,
       onHandle: (handle) => {
         activeId = topLevelBaseId;
-        activeSubagents.set(activeId, { agent: agentName, task, taskIndex: 0, handle, name: subagentName });
+        activeSubagents.set(activeId, { agent: agentName, task, handle, name: subagentName });
         updateLatestBroadcastTargets(undefined);
       },
     });
@@ -2345,7 +2265,7 @@ ${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidan
         content: [
           {
             type: "text" as const,
-            text: `Agent ${result.stopReason || "failed"}: ${errorMsg}`,
+            text: `${result.name ? `${result.name} (${result.agent})` : `Agent ${result.agent}`} ${result.stopReason || "failed"}: ${errorMsg}`,
           },
         ],
         details: makeDetails("single")([result]),
@@ -2398,7 +2318,7 @@ ${agentList}\n\n${subagentsGuidance}\n\n${delegationGuardGuidance}${resumeGuidan
         (index, task, handle) => {
           const id = topLevelBaseId + index;
           taskIds.set(index, id);
-          activeSubagents.set(id, { agent: task.agent, task: task.task, taskIndex: index, handle, name: extras?.names?.[index] });
+          activeSubagents.set(id, { agent: task.agent, task: task.task, handle, name: extras?.names?.[index] });
           updateLatestBroadcastTargets(undefined);
         },
         (index) => {

package/names.ts

@@ -1,9 +1,9 @@
 /**
  * Durable subagent name registry.
  *
- * Every spawned subagent gets a unique, human-friendly name derived from its
- * agent type plus a per-type counter (e.g. `code-writer-01`, `code-writer-02`,
- * `code-reviwer-01`). Names are unique within one delegation tree (the tree
+ * Every spawned subagent gets a random human first name from the bundled
+ * 500-name pool (e.g. `John`, `Maria`, `Elena`). Names are unique within one
+ * delegation tree (the tree
  * rooted at the top-level pi session) and are persisted in a JSON registry
  * file under the subagent session root, so they survive process restarts.
  *
@@ -20,6 +20,8 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { randomInt } from "node:crypto";
+import { AMERICAN_NAMES } from "./american-names.js";
 
 export const SUBAGENT_NAMES_FILE_ENV = "PI_SUBAGENT_NAMES_FILE";
 
@@ -168,7 +170,7 @@ export interface SubagentNameRecord {
 
 export interface NamesRegistry {
   version: 1;
-  /** Per-agent-type counters used to generate the next name. */
+  /** Retained in the file shape for simple migration from older registries. */
   counters: Record<string, number>;
   /** All allocated names in this delegation tree. */
   agents: Record<string, SubagentNameRecord>;
@@ -306,8 +308,8 @@ export function readNamesRegistry(file: string): NamesRegistry {
     /* fall through to corruption handling */
   }
   // Corrupt registry: keep a backup for forensics and warn instead of
-  // silently resetting (a reset restarts counters, so new names could clash
-  // with names the model remembers from the conversation transcript).
+  // silently resetting (a reset could reuse names the model remembers from
+  // the conversation transcript).
   try {
     const backup = `${file}.corrupt-${Date.now().toString(36)}`;
     fs.copyFileSync(file, backup);
@@ -347,8 +349,9 @@ export async function updateNamesRegistry<T>(
 // Name allocation
 // ---------------------------------------------------------------------------
 
-export function formatSubagentName(agent: string, index: number): string {
-  return `${agent}-${String(index).padStart(2, "0")}`;
+export function getAvailableSubagentNames(registry: NamesRegistry): string[] {
+  const used = new Set(Object.keys(registry.agents).map((name) => name.toLowerCase()));
+  return AMERICAN_NAMES.filter((name) => !used.has(name.toLowerCase()));
 }
 
 export interface AllocateNameRequest {
@@ -371,13 +374,15 @@ export async function allocateSubagentNames(
   if (requests.length === 0) return [];
   return updateNamesRegistry(file, (registry) => {
     const names: string[] = [];
+    const available = getAvailableSubagentNames(registry);
+    if (available.length < requests.length) {
+      throw new Error(
+        `The 500-name subagent pool is exhausted (${available.length} available, ${requests.length} requested).`,
+      );
+    }
     for (const request of requests) {
-      let name: string;
-      do {
-        const next = (registry.counters[request.agent] ?? 0) + 1;
-        registry.counters[request.agent] = next;
-        name = formatSubagentName(request.agent, next);
-      } while (registry.agents[name] !== undefined);
+      const selectedIndex = randomInt(available.length);
+      const [name] = available.splice(selectedIndex, 1);
       registry.agents[name] = {
         name,
         agent: request.agent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",
@@ -11,6 +11,7 @@
     "runner.ts",
     "resume.ts",
     "names.ts",
+    "american-names.ts",
     "shared.ts",
     "render.ts",
     "tree.ts",

package/render.ts

@@ -7,11 +7,36 @@
  */
 
 import { Container, Spacer, Text } from "@mariozechner/pi-tui";
+
+interface Component {
+	render(width: number): string[];
+	invalidate(): void;
+}
+
+function fitLine(text: string, width: number): string {
+	if (width <= 0) return "";
+	let visible = 0;
+	let output = "";
+	for (let i = 0; i < text.length && visible < width;) {
+		if (text[i] === "\u001b") {
+			const match = text.slice(i).match(/^\u001b(?:\[[0-?]*[ -\/]*[@-~]|\][^\u0007]*(?:\u0007|\u001b\\))/);
+			if (match) {
+				output += match[0];
+				i += match[0].length;
+				continue;
+			}
+		}
+		const codePoint = text.codePointAt(i)!;
+		const char = String.fromCodePoint(codePoint);
+		output += char;
+		i += char.length;
+		visible += 1;
+	}
+	return output;
+}
 import {
 	MAX_LIVE_LOG_ENTRIES,
-	isResultError,
 	isSubagentDetails,
-	type SingleResult,
 	type SubagentDetails,
 } from "./types.js";
 import {
@@ -21,6 +46,7 @@ import {
 	formatClockTime,
 	formatLiveLogEntry,
 	hasNestedChildren,
+	statusEmoji,
 	renderTreeLines,
 	setBroadcastNumberingActive,
 	topLevelSummary,
@@ -73,19 +99,8 @@ export function renderCall(
 ): Text {
 	const tasks = Array.isArray(args.tasks) ? args.tasks : [];
 	const count = tasks.length;
-	const icon = context?.isPartial === false
-		? context.isError
-			? theme.fg("error", "❌")
-			: theme.fg("success", "✅")
-		: theme.fg("warning", "⏳");
 	const stamp = getCallStartStamp(context, theme);
-	let text = `${stamp}${theme.fg("toolTitle", theme.bold("subagents "))}${theme.fg("accent", `${count} task${count === 1 ? "" : "s"}`)}`;
-	for (const task of tasks.slice(0, 6)) {
-		const agent = typeof task?.agent === "string" ? task.agent : "...";
-		const preview = typeof task?.task === "string" ? ` ${truncate(task.task, 56)}` : "";
-		text += `\n  ${icon} ${theme.fg("accent", agent)}${theme.fg("dim", preview)}`;
-	}
-	if (tasks.length > 6) text += `\n  ${theme.fg("muted", `... +${tasks.length - 6} more`)}`;
+	const text = `${stamp}${theme.fg("toolTitle", theme.bold("subagents "))}${theme.fg("accent", `${count} task${count === 1 ? "" : "s"}`)}`;
 	return new Text(text, 0, 0);
 }
 
@@ -104,24 +119,8 @@ export function renderResumeCall(
 			? [args.resumes]
 			: [];
 	const count = resumes.length;
-	const icon = context?.isPartial === false
-		? context.isError
-			? theme.fg("error", "❌")
-			: theme.fg("success", "✅")
-		: theme.fg("warning", "⏳");
 	const stamp = getCallStartStamp(context, theme);
-	let text = `${stamp}${theme.fg("toolTitle", theme.bold("resume subagents "))}${theme.fg("accent", `${count} subagent${count === 1 ? "" : "s"}`)}`;
-	for (const resume of resumes.slice(0, 6)) {
-		const name = typeof resume?.subagent === "string"
-			? resume.subagent
-			: typeof resume?.name === "string"
-				? resume.name
-				: "...";
-		const task = typeof resume?.task === "string" ? resume.task : typeof resume?.prompt === "string" ? resume.prompt : undefined;
-		const preview = task !== undefined ? ` ${truncate(task, 56)}` : "";
-		text += `\n  ${icon} ${theme.fg("accent", name)}${theme.fg("dim", preview)}`;
-	}
-	if (resumes.length > 6) text += `\n  ${theme.fg("muted", `... +${resumes.length - 6} more`)}`;
+	const text = `${stamp}${theme.fg("toolTitle", theme.bold("resume subagents "))}${theme.fg("accent", `${count} subagent${count === 1 ? "" : "s"}`)}`;
 	return new Text(text, 0, 0);
 }
 
@@ -143,52 +142,66 @@ function compactText(text: string, maxLength = 240): string {
 	return truncate(firstLine, maxLength);
 }
 
-function isRenderableResult(value: unknown): value is SingleResult {
-	return value !== null &&
-		typeof value === "object" &&
-		!Array.isArray(value) &&
-		typeof (value as Partial<SingleResult>).agent === "string" &&
-		typeof (value as Partial<SingleResult>).exitCode === "number";
+function takePromptLine(text: string, width: number): { line: string; rest: string } {
+	const normalized = text.replace(/\s+/g, " ").trim();
+	if (!normalized || width <= 0) return { line: "", rest: normalized };
+	if (normalized.length <= width) return { line: normalized, rest: "" };
+	let split = normalized.lastIndexOf(" ", width);
+	if (split < Math.max(1, Math.floor(width / 2))) split = width;
+	return { line: normalized.slice(0, split), rest: normalized.slice(split).trimStart() };
 }
 
-function getCollapsedResultText(details: SubagentDetails, fallbackText: string): string {
-	const results = details.results.filter(isRenderableResult);
-	if (results.length === 0) return compactText(fallbackText);
-
-	const running = results.filter((item) => item.exitCode === -1).length;
-	const finished = results.length - running;
-	const succeeded = results.filter((item) => item.exitCode === 0 && !isResultError(item)).length;
-	const failed = finished - succeeded;
+class CollapsedSubagentComponent implements Component {
+	constructor(
+		private readonly details: SubagentDetails,
+		private readonly theme: { fg: ThemeFg; bold: (s: string) => string },
+	) {}
 
-	if (details.mode === "parallel") {
-		return running > 0
-			? `Parallel: ${finished}/${results.length} done, ${running} running...`
-			: `Parallel: ${succeeded}/${results.length} succeeded${failed > 0 ? `, ${failed} failed` : ""}`;
+	render(width: number): string[] {
+		if (width <= 0) return [];
+		const nodes = buildTopLevelNodes(this.details);
+		const lines: string[] = [];
+		for (const node of nodes) {
+			const rawPrefix = `  ${node.status === "running" ? "⏳" : node.status === "error" ? "❌" : "✅"} ${node.label} `;
+			const firstWidth = Math.max(8, width - rawPrefix.length);
+			const first = takePromptLine(node.task ?? "", firstWidth);
+			const continuationIndent = " ".repeat(Math.min(rawPrefix.length, Math.max(2, width - 8)));
+			const second = takePromptLine(first.rest, Math.max(8, width - continuationIndent.length));
+			const firstLine = `  ${statusEmoji(node.status, this.theme)} ${this.theme.fg("accent", node.label)}${first.line ? ` ${this.theme.fg("dim", first.line)}` : ""}`;
+			lines.push(fitLine(firstLine, width));
+			if (first.rest) {
+				const hasMore = second.rest.length > 0;
+				const secondText = `${second.line}${hasMore ? "..." : ""}`;
+				lines.push(fitLine(`${continuationIndent}${this.theme.fg("dim", secondText)}`, width));
+			}
+			const actionAt = node.lastActionAt ?? node.startedAt;
+			if (actionAt !== undefined) {
+				lines.push(fitLine(`     ${this.theme.fg("muted", `last action: ${formatClockTime(actionAt)}`)}`, width));
+			}
+		}
+		const counts = countNodes(nodes);
+		if (lines.length > 0) lines.push("");
+		lines.push(fitLine(this.theme.fg("dim", topLevelSummary(this.details, counts)), width));
+		return lines;
 	}
 
-	const item = results[0];
-	if (item.exitCode === -1) return `Agent ${item.agent}: running...`;
-	if (isResultError(item)) {
-		const reason = [item.errorMessage, item.stderr, item.stopReason]
-			.find((value): value is string => typeof value === "string" && value.length > 0);
-		return `Agent ${item.agent}: failed${reason ? ` — ${compactText(reason, 180)}` : ""}`;
-	}
-	return `Agent ${item.agent}: completed`;
+	invalidate(): void {}
 }
 
 export function renderResult(
 	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
 	expanded: boolean,
 	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Container | Text {
+): Component | Container | Text {
 	const fallbackText = getResultText(result);
 
-	// Keep the normal row compact. Ctrl+O switches to the live tree below.
+	// The collapsed view remains live and shows each direct child separately.
+	// Its status icon comes from that child's result, not the outer tool state,
+	// so completed siblings update while other tasks are still running.
 	if (!expanded) {
-		const text = isSubagentDetails(result.details)
-			? getCollapsedResultText(result.details, fallbackText)
-			: compactText(fallbackText);
-		return new Text(text, 0, 0);
+		return isSubagentDetails(result.details) && result.details.results.length > 0
+			? new CollapsedSubagentComponent(result.details, theme)
+			: new Text(compactText(fallbackText), 0, 0);
 	}
 
 	if (!isSubagentDetails(result.details) || result.details.results.length === 0) {
@@ -216,7 +229,7 @@ export function renderResult(
 		);
 
 		container.addChild(new Spacer(1));
-		container.addChild(new Text(renderTreeLines(nodes, theme, showOutputPreview).join("\n"), 0, 0));
+		container.addChild(new Text(renderTreeLines(nodes, theme, showOutputPreview, 0, "", true).join("\n"), 0, 0));
 		return container;
 	} catch {
 		// Pi falls back to raw result.content when a custom renderer throws, which

package/runner.ts

@@ -150,77 +150,32 @@ function cleanupTempDir(dir: string | null): void {
   }
 }
 
-function getCurrentPiCliScript(): string | null {
-  const script = process.argv[1];
-  if (!script) return null;
-
-  // When this extension is loaded by pi, process.argv[1] is the pi entrypoint.
-  // Reusing it with process.execPath avoids relying on PATH while still running
-  // the exact same pi installation as the parent process.
-  //
-  // On Linux/macOS the launched entrypoint is usually the npm `bin` symlink
-  // (e.g. <prefix>/bin/pi) that points at .../pi-coding-agent/dist/cli.js, so
-  // argv[1] does NOT end in /dist/cli.js. Resolve symlinks before matching —
-  // otherwise this check fails and we fall back to scanning PATH, which can
-  // pick a different (e.g. much slower, cross-filesystem) pi install than the
-  // one actually running.
-  const candidates = [script];
-  try {
-    const real = fs.realpathSync(script);
-    if (real && real !== script) candidates.push(real);
-  } catch {
-    // argv[1] not statable; fall through with the raw value.
-  }
-  for (const candidate of candidates) {
-    const normalized = candidate.replace(/\\/g, "/");
-    if (normalized.includes("/pi-coding-agent/") && normalized.endsWith("/dist/cli.js")) {
-      return candidate;
-    }
-  }
-  return null;
+export interface RuntimeLaunchCommand {
+  command: string;
+  argsPrefix: string[];
 }
 
-function findPiCliScriptOnPath(): string | null {
-  const pathEnv = process.env.PATH ?? "";
-  for (const dir of pathEnv.split(path.delimiter)) {
-    if (!dir) continue;
-    for (const shimName of process.platform === "win32" ? ["pi.cmd", "pi"] : ["pi"]) {
-      const shimPath = path.join(dir, shimName);
-      if (!fs.existsSync(shimPath)) continue;
-
-      // Common on Linux/macOS: the npm `bin/pi` entry is a symlink pointing
-      // straight at .../pi-coding-agent/dist/cli.js. Resolve it directly — its
-      // file *content* is JS (not a wrapper that names cli.js), so the text
-      // regex below would miss it and we'd skip this (often faster, same-
-      // filesystem) install in favour of a later PATH entry.
-      try {
-        const real = fs.realpathSync(shimPath);
-        const normalized = real.replace(/\\/g, "/");
-        if (normalized.includes("/pi-coding-agent/") && normalized.endsWith("/dist/cli.js")) {
-          return real;
-        }
-      } catch {
-        // not a resolvable symlink; fall through to the wrapper-text scan.
-      }
-
-      let text = "";
-      try {
-        text = fs.readFileSync(shimPath, "utf8");
-      } catch {
-        continue;
-      }
-      const match = text.match(/node_modules[\\/]([^\s"']*pi-coding-agent)[\\/]dist[\\/]cli\.js/);
-      if (!match) continue;
-      const cliPath = path.join(dir, "node_modules", match[1], "dist", "cli.js");
-      if (fs.existsSync(cliPath)) return cliPath;
-    }
+/**
+ * Re-launch the runtime and entrypoint that are executing this Pi process.
+ *
+ * This deliberately knows nothing about npm, pnpm, Pi package names, or dist
+ * layouts. With Node it becomes `node <entrypoint>`; with Bun it becomes
+ * `bun <entrypoint>`. Package-manager shims have already done their job before
+ * the current process starts, so children do not need to execute or parse them.
+ */
+export function getCurrentRuntimeLaunch(
+  argv: readonly string[] = process.argv,
+  execPath = process.execPath,
+): RuntimeLaunchCommand | null {
+  const rawEntrypoint = argv[1];
+  if (!execPath || !rawEntrypoint || rawEntrypoint.startsWith("-")) return null;
+  const entrypoint = path.resolve(rawEntrypoint);
+  try {
+    if (!fs.statSync(entrypoint).isFile()) return null;
+  } catch {
+    return null;
   }
-  return null;
-}
-
-/** Resolve the dist/cli.js of the currently running pi installation, if findable. */
-export function getPiCliScriptPath(): string | null {
-  return getCurrentPiCliScript() ?? findPiCliScriptOnPath();
+  return { command: execPath, argsPrefix: [entrypoint] };
 }
 
 function getPiSpawnCommand(override?: { command: string; argsPrefix?: string[] }): { command: string; argsPrefix: string[] } {
@@ -243,11 +198,63 @@ function getPiSpawnCommand(override?: { command: string; argsPrefix?: string[] }
     return { command: overrideCommand, argsPrefix };
   }
 
-  const cliScript = getCurrentPiCliScript() ?? findPiCliScriptOnPath();
-  if (cliScript) return { command: process.execPath, argsPrefix: [cliScript] };
+  const currentRuntime = getCurrentRuntimeLaunch();
+  if (currentRuntime) return currentRuntime;
+
+  // SDK/embedded hosts may have no script entrypoint. They can set the
+  // explicit command variables above; keep `pi` as a final conventional
+  // fallback for environments where it is a real executable on PATH.
   return { command: "pi", argsPrefix: [] };
 }
 
+/**
+ * Build a child environment with a dependable executable search path.
+ *
+ * Elevated PowerShell sessions and pnpm shims can start Pi with a PATH that
+ * omits PNPM_HOME, the user npm bin directory, or even the Node directory.
+ * Child Pi processes then start (when we resolved cli.js directly) but cannot
+ * launch tools or nested Pi processes. Windows also treats Path/PATH keys
+ * case-insensitively, while Node's env object does not, so emit exactly one.
+ */
+export function buildChildProcessEnv(extra: NodeJS.ProcessEnv = {}): NodeJS.ProcessEnv {
+  const inherited = { ...process.env, ...extra };
+  const pathEntries: string[] = [];
+  const add = (value: string | undefined) => {
+    if (!value) return;
+    for (const entry of value.split(path.delimiter)) {
+      const clean = entry.trim();
+      if (!clean) continue;
+      const key = process.platform === "win32" ? clean.toLowerCase() : clean;
+      if (!pathEntries.some((existing) => (process.platform === "win32" ? existing.toLowerCase() : existing) === key)) {
+        pathEntries.push(clean);
+      }
+    }
+  };
+
+  for (const [key, value] of Object.entries(inherited)) {
+    if (key.toLowerCase() === "path") add(value);
+  }
+  add(path.dirname(process.execPath));
+  add(process.argv[1] ? path.dirname(path.resolve(process.argv[1])) : undefined);
+  add(inherited.PNPM_HOME);
+  add(inherited.npm_config_prefix);
+  if (inherited.npm_config_prefix) add(path.join(inherited.npm_config_prefix, "bin"));
+  if (process.platform === "win32") {
+    add(inherited.APPDATA ? path.join(inherited.APPDATA, "npm") : undefined);
+    add(inherited.LOCALAPPDATA ? path.join(inherited.LOCALAPPDATA, "pnpm") : undefined);
+    add(inherited.USERPROFILE ? path.join(inherited.USERPROFILE, "AppData", "Local", "pnpm") : undefined);
+    const systemRoot = inherited.SystemRoot ?? inherited.SYSTEMROOT;
+    add(systemRoot ? path.join(systemRoot, "System32") : undefined);
+  }
+
+  const env: NodeJS.ProcessEnv = {};
+  for (const [key, value] of Object.entries(inherited)) {
+    if (key.toLowerCase() !== "path") env[key] = value;
+  }
+  env[process.platform === "win32" ? "Path" : "PATH"] = pathEntries.join(path.delimiter);
+  return env;
+}
+
 function resolveExtensionArg(value: string): string {
   if (!value) return value;
   if (value.startsWith("npm:") || value.startsWith("git:")) return value;
@@ -472,6 +479,14 @@ export function processJsonLine(line: string, result: SingleResult): boolean {
   // Guard: JSON.parse can return null, a number, boolean, or array — none of which have .type
   if (!event || typeof event !== "object" || Array.isArray(event)) return false;
 
+  const semanticEventTypes = new Set([
+    "message_end", "tool_result_end", "subagent_progress", "turn_start",
+    "turn_end", "tool_execution_start", "tool_execution_end",
+  ]);
+  if (semanticEventTypes.has(event.type)) {
+    result.lastActionAt = typeof event.timestamp === "number" ? event.timestamp : Date.now();
+  }
+
   if (event.type === "message_end" && event.message) {
     const msg = event.message as Message;
     if (hasMessage(result, msg)) return true;
@@ -638,7 +653,7 @@ export interface RunAgentOptions {
   agentName: string;
   /** Task description. */
   task: string;
-  /** Unique resumable name assigned to this subagent (e.g. "code-writer-01"). */
+  /** Unique resumable human name assigned to this subagent (e.g. "John"). */
   subagentName?: string;
   /** When true, send the task text to the child verbatim (no "Task:" / resume preamble). */
   rawPrompt?: boolean;
@@ -745,6 +760,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     task,
     name: opts.subagentName ?? initialResult?.name,
     startedAt: initialResult?.startedAt ?? Date.now(),
+    lastActionAt: initialResult?.lastActionAt ?? Date.now(),
     exitCode: -1,
     messages: initialResult?.messages ? [...initialResult.messages] : [],
     stderr: initialResult?.stderr ?? "",
@@ -835,8 +851,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
         // agents and tools, rather than only their immediate Pi parent.
         detached: process.platform !== "win32",
         stdio: ["pipe", "pipe", "pipe"],
-        env: {
-          ...process.env,
+        env: buildChildProcessEnv({
           [SUBAGENT_DEPTH_ENV]: String(nextDepth),
           [SUBAGENT_MAX_DEPTH_ENV]: String(propagatedMaxDepth),
           [SUBAGENT_STACK_ENV]: JSON.stringify(propagatedStack),
@@ -844,8 +859,9 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
           ...(sessionRoot ? { [SUBAGENT_SESSION_ROOT_ENV]: sessionRoot } : {}),
           ...(opts.namesFile ? { [SUBAGENT_NAMES_FILE_ENV]: opts.namesFile } : {}),
           ...(fallbackModel ? { [SUBAGENT_FALLBACK_MODEL_ENV]: fallbackModel } : {}),
+          // All other provider/auth/proxy/temp/home variables are inherited.
           // PI_OFFLINE is NOT forced here — see explanation near PI_OFFLINE_ENV.
-        },
+        }),
       });
 
       let buffer = "";
@@ -922,7 +938,10 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
             const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT ?? "C:\\Windows";
             const killer = spawn(
               path.join(systemRoot, "System32", "taskkill.exe"),
-              ["/PID", String(proc.pid), "/T", ...(force ? ["/F"] : [])],
+              // taskkill has no reliable graceful console-process mode when
+              // launched from elevated PowerShell; without /F it often leaves
+              // the Node child alive until our five-second escalation timer.
+              ["/PID", String(proc.pid), "/T", "/F"],
               { shell: false, stdio: "ignore", windowsHide: true },
             );
             killer.unref();
@@ -993,7 +1012,11 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
             result.stopReason = "error";
             result.errorMessage = message;
             appendBoundedStderr(result, `[pi-subagent] ${message}\n`);
-            forceStopAndSettle(1);
+            // No agent turn ever started, so there is no buffered semantic
+            // output to drain. Kill the rejected RPC process tree and settle
+            // immediately instead of waiting on slow Windows taskkill/stdio.
+            stopChild(true);
+            doResolve(1);
           }
           return;
         }
@@ -1002,6 +1025,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
         // compact-and-retry, or process a queued continuation. Killing here was
         // the direct cause of the WebSocket failures in the inspected session.
         if (event?.type === "agent_end") {
+          result.lastActionAt = Date.now();
           noteSemanticActivity(
             event.willRetry === true ? RETRY_WAIT_GRACE_MS : 0,
           );
@@ -1010,6 +1034,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
 
         if (event?.type === "agent_settled") {
           agentSettled = true;
+          result.lastActionAt = Date.now();
           // No semantic watchdog may fire while we are only waiting for the
           // deliberately terminated RPC process tree to close. On slower
           // launchers (notably Windows taskkill), that cleanup can outlast a
@@ -1052,8 +1077,10 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
           if (event?.type === "message_update" || event?.type === "tool_execution_update") {
             // Streaming deltas are intentionally not retained in result.messages,
             // but they prove the model/tool is still making real progress.
+            result.lastActionAt = Date.now();
             noteSemanticActivity();
           } else if (event?.type === "auto_retry_start") {
+            result.lastActionAt = Date.now();
             const delayMs = Number.isFinite(event.delayMs) ? Math.max(0, Number(event.delayMs)) : 0;
             noteSemanticActivity(delayMs + RETRY_WAIT_GRACE_MS);
           } else if (
@@ -1064,6 +1091,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
             event?.type === "summarization_retry_attempt_start" ||
             event?.type === "summarization_retry_finished"
           ) {
+            result.lastActionAt = Date.now();
             noteSemanticActivity();
           }
         }
@@ -1340,6 +1368,7 @@ export async function executeParallelSubprocess(
     task: t.task,
     name: extras?.names?.[index],
     startedAt: Date.now(),
+    lastActionAt: Date.now(),
     exitCode: -1,
     messages: [],
     stderr: "",
@@ -1434,9 +1463,9 @@ export async function executeParallelSubprocess(
     const output = succeeded
       ? getFinalOutput(r.messages, r.finalOutput)
       : r.errorMessage || r.stderr || getFinalOutput(r.messages, r.finalOutput);
-    const nameTag = r.name ? ` • name: ${r.name}` : "";
+    const identity = r.name ? `${r.name} (${r.agent})` : r.agent;
     const status = succeeded ? "completed" : r.exitCode === -1 ? "unfinished" : "failed";
-    return `[${r.agent}${nameTag}] ${status}: ${output || "(no output)"}`;
+    return `[${identity}] ${status}: ${output || "(no output)"}`;
   });
 
   return {

package/tree.ts

@@ -44,6 +44,8 @@ export interface TreeNode {
 	task?: string;
 	/** Epoch ms when this subagent run started (rendered as a dim hh:mm:ss prefix). */
 	startedAt?: number;
+	/** Latest activity across this node and every descendant. */
+	lastActionAt?: number;
 	outputPreview?: string[];
 	liveActivity?: LiveLogEntry[];
 	children: TreeNode[];
@@ -571,7 +573,6 @@ function buildResultNode(rawResult: SingleResult): TreeNode {
 	const status = statusFromResult(result);
 	const usage = formatUsage(result.usage, result.model);
 	const metaParts: string[] = [];
-	if (typeof result.name === "string" && result.name) metaParts.push(result.name);
 	if (typeof result.agentSource === "string" && result.agentSource) metaParts.push(result.agentSource);
 	if (usage) metaParts.push(usage);
 	if (status === "error") {
@@ -584,14 +585,21 @@ function buildResultNode(rawResult: SingleResult): TreeNode {
 	const children = buildNestedChildren(result);
 	const isRunning = status === "running";
 	const liveLog = Array.isArray(result.liveLog) ? result.liveLog : [];
+	const ownLastAction = typeof result.lastActionAt === "number" && Number.isFinite(result.lastActionAt)
+		? result.lastActionAt
+		: liveLog.reduce((latest, entry) => Math.max(latest, typeof entry.at === "number" ? entry.at : 0), result.startedAt ?? 0);
+	const descendantLastAction = children.reduce((latest, child) => Math.max(latest, child.lastActionAt ?? 0), 0);
+	const agentType = stringValue(result.agent, "unknown agent");
+	const humanName = typeof result.name === "string" && result.name ? result.name : undefined;
 	return {
-		label: stringValue(result.agent, "unknown agent"),
+		label: humanName ? `${humanName} (${agentType})` : agentType,
 		status,
 		meta: metaParts.join(" • "),
 		task: typeof result.task === "string" ? result.task : undefined,
 		startedAt: typeof result.startedAt === "number" && Number.isFinite(result.startedAt)
 			? result.startedAt
 			: undefined,
+		lastActionAt: Math.max(ownLastAction, descendantLastAction) || undefined,
 		liveActivity: isRunning && liveLog.length > 0 ? liveLog.slice(-MAX_LIVE_LOG_ENTRIES) : undefined,
 		outputPreview: !isRunning && children.length === 0 ? buildLeafPreview(result) : undefined,
 		children,
@@ -608,6 +616,7 @@ export function renderTreeLines(
 	showOutputPreview: boolean,
 	depth = 0,
 	prefix = "",
+	showFullPrompts = false,
 ): string[] {
 	const lines: string[] = [];
 
@@ -622,6 +631,14 @@ export function renderTreeLines(
 		if (node.meta) line += ` ${theme.fg("dim", node.meta)}`;
 		lines.push(line);
 
+		if (showFullPrompts && node.task) {
+			const promptLines = node.task.replace(/\r\n?/g, "\n").split("\n");
+			promptLines.forEach((promptLine, promptIndex) => {
+				const promptLabel = promptIndex === 0 ? "prompt: " : "        ";
+				lines.push(`${indent}  ${theme.fg("muted", promptLabel)}${theme.fg("toolOutput", promptLine)}`);
+			});
+		}
+
 		if (showOutputPreview && node.outputPreview && node.outputPreview.length > 0) {
 			for (const outputLine of node.outputPreview) {
 				lines.push(`${indent}  ${theme.fg("toolOutput", outputLine)}`);
@@ -641,7 +658,7 @@ export function renderTreeLines(
 		}
 
 		if (node.children.length > 0) {
-			lines.push(...renderTreeLines(node.children, theme, showOutputPreview, depth + 1, number));
+			lines.push(...renderTreeLines(node.children, theme, showOutputPreview, depth + 1, number, showFullPrompts));
 		}
 	});
 

package/types.ts

@@ -64,10 +64,12 @@ export interface SingleResult {
 	agent: string;
 	agentSource: "user" | "project" | "builtin" | "unknown";
 	task: string;
-	/** Unique resumable name for this subagent within the delegation tree (e.g. "code-writer-01"). */
+	/** Unique resumable human name within the delegation tree (e.g. "John"). */
 	name?: string;
 	/** Epoch ms when this subagent run started (used for TUI timestamps). */
 	startedAt?: number;
+	/** Most recent semantic activity in this agent's entire live run. */
+	lastActionAt?: number;
 	exitCode: number;
 	messages: Message[];
 	stderr: string;
@@ -264,6 +266,7 @@ export function compactSingleResultForDurableDetails(result: SingleResult): Sing
     subtreeUsageSummary: result.subtreeUsageSummary ?? buildUsageSummary([result]),
     ...(result.name !== undefined ? { name: result.name } : {}),
     ...(result.startedAt !== undefined ? { startedAt: result.startedAt } : {}),
+    ...(result.lastActionAt !== undefined ? { lastActionAt: result.lastActionAt } : {}),
     ...(result.stopReason !== undefined ? { stopReason: result.stopReason } : {}),
     ...(result.errorMessage !== undefined ? { errorMessage: result.errorMessage } : {}),
     ...(result.model !== undefined ? { model: result.model } : {}),