@herbertgao/pi-subagents 0.15.2 → 0.15.4

package/src/nested-tools.ts

@@ -399,47 +399,38 @@ export function createNestedSubagentTools(
       // one earlier would silently give a grandchild the wrong worktree base, the
       // wrong conversation under inherit_context, and the wrong inherited model.
       //
-      // spawn() throws on strict worktree-isolation failure and cwd validation —
-      // report it as a tool error, like the top-level Agent tool does, instead of
-      // letting it escape into the child's turn.
-      try {
-        if (invocation.runInBackground) {
-          const id = context.manager.spawn(
-            context.pi,
-            ctx,
-            resolvedType,
-            params.prompt,
-            {
-              ...options,
-              isBackground: true,
-            },
-          )
-          // Synchronous, before the event loop yields — onSessionCreated fires
-          // asynchronously inside runAgent, so the file is attached in time.
-          attachTranscript(id)
-          return textResult(
-            `Nested agent started in background. Agent ID: ${id}`,
-          )
-        }
-
-        const { record } = await context.manager.spawnAndWait(
+      // Startup throws mean no child ran. Let them propagate so Pi marks the
+      // nested Agent tool call failed instead of presenting the message as a
+      // successful child result.
+      if (invocation.runInBackground) {
+        const id = context.manager.spawn(
           context.pi,
           ctx,
           resolvedType,
           params.prompt,
-          { ...options, signal },
-          attachTranscript,
-        )
-        return textResult(
-          formatRecord(record, "inline"),
-          record.status === "error",
-        )
-      } catch (err) {
-        return textResult(
-          err instanceof Error ? err.message : String(err),
-          true,
+          {
+            ...options,
+            isBackground: true,
+          },
         )
+        // Synchronous, before the event loop yields — onSessionCreated fires
+        // asynchronously inside runAgent, so the file is attached in time.
+        attachTranscript(id)
+        return textResult(`Nested agent started in background. Agent ID: ${id}`)
       }
+
+      const { record } = await context.manager.spawnAndWait(
+        context.pi,
+        ctx,
+        resolvedType,
+        params.prompt,
+        { ...options, signal },
+        attachTranscript,
+      )
+      return textResult(
+        formatRecord(record, "inline"),
+        record.status === "error",
+      )
     },
   })
 

package/src/output-file.ts

@@ -66,6 +66,23 @@ export function createOutputFilePath(
   return join(dir, `${agentId}.output`)
 }
 
+/**
+ * Ensure a transcript file exists without disturbing what is already in it.
+ *
+ * A resume reuses the agent's existing transcript (same deterministic path), so
+ * it must never call `writeInitialEntry` — that truncates, discarding turns the
+ * completion notification still points the user at, and any history the session
+ * has since compacted away is gone for good. Appending nothing creates the file
+ * when this is the agent's first transcript and is a no-op when it is not.
+ */
+export function ensureOutputFile(path: string): void {
+  try {
+    appendFileSync(path, "", "utf-8")
+  } catch {
+    /* ignore — streaming writes are best-effort too */
+  }
+}
+
 /** Write the initial user prompt entry. */
 export function writeInitialEntry(
   path: string,
@@ -93,8 +110,14 @@ export function streamToOutputFile(
   path: string,
   agentId: string,
   cwd: string,
+  startIndex?: number,
 ): () => void {
-  let writtenCount = 1 // initial user prompt already written
+  // Index of the first message this stream is responsible for. A spawn writes
+  // messages[0] as the initial prompt entry, so it starts at 1. A resume hands
+  // in the session's length as of just before the run: the session already
+  // holds every prior turn, and re-emitting those would duplicate history that
+  // is already in the file.
+  let writtenCount = startIndex ?? 1
 
   const flush = () => {
     const messages = session.messages

package/src/prompts.ts

@@ -10,6 +10,8 @@ export interface PromptExtras {
   memoryBlock?: string
   /** Preloaded skill contents to inject. */
   skillBlocks?: { name: string; content: string }[]
+  /** Original checkout path when cwd is an isolated worktree copy. */
+  worktreeBase?: string
 }
 
 /**
@@ -55,6 +57,12 @@ Platform: ${env.platform}`
   }
   const extrasSuffix =
     extraSections.length > 0 ? "\n\n" + extraSections.join("\n") : ""
+  const worktreeSection = extras?.worktreeBase
+    ? `\n\n<worktree_isolation>
+Your working directory is an isolated git worktree copy of ${extras.worktreeBase}.
+Work only inside it — never in ${extras.worktreeBase}, even if other instructions name that path as your working directory.
+</worktree_isolation>`
+    : ""
 
   if (config.promptMode === "append") {
     const identity = parentSystemPrompt || genericBase
@@ -88,6 +96,7 @@ You are operating as a sub-agent invoked to handle a specific task.
       "\n\n" +
       activeAgentTag +
       envBlock +
+      worktreeSection +
       customSection +
       extrasSuffix
     )
@@ -100,7 +109,12 @@ You have been invoked to handle a specific task autonomously.
 ${envBlock}`
 
   return (
-    activeAgentTag + replaceHeader + "\n\n" + config.systemPrompt + extrasSuffix
+    activeAgentTag +
+    replaceHeader +
+    worktreeSection +
+    "\n\n" +
+    config.systemPrompt +
+    extrasSuffix
   )
 }
 

package/src/ui/agent-widget.ts

@@ -358,6 +358,17 @@ export class AgentWidget {
     }
   }
 
+  /**
+   * Drop an agent's finished-age (call when a settled agent starts running
+   * again, i.e. a background resume). markFinished only seeds an age it has not
+   * seen before, so a resumed agent would otherwise keep the age from its
+   * previous run — already past the linger limit, hiding the new run's
+   * completion line entirely.
+   */
+  markRunning(agentId: string) {
+    this.finishedTurnAge.delete(agentId)
+  }
+
   /** Render a finished agent line. */
   private renderFinishedLine(
     a: {
@@ -536,6 +547,16 @@ export class AgentWidget {
       let hiddenRunning = 0
       let hiddenFinished = 0
 
+      // Reserve the queued line's row up front. It is a single summary of N
+      // waiting agents, so it cannot be folded into the "+N more" count (which
+      // is denominated in agents) without either under-reporting it as 1 or
+      // inflating the total with agents that were never getting their own rows.
+      // Reserving costs at most one running agent — which IS counted below —
+      // and makes the drop unreachable. It matters most exactly when it used to
+      // vanish: the pool is saturated and the queue is what the user needs to see.
+      const queuedReserve = queuedLine ? 1 : 0
+      budget -= queuedReserve
+
       // 1. Running agents (2 lines each)
       for (const pair of runningLines) {
         if (budget >= 2) {
@@ -546,8 +567,9 @@ export class AgentWidget {
         }
       }
 
-      // 2. Queued line
-      if (queuedLine && budget >= 1) {
+      // 2. Queued line (always fits — its row was reserved above)
+      if (queuedLine) {
+        budget += queuedReserve
         lines.push(queuedLine)
         budget--
       }

package/src/ui/schedule-menu.ts

@@ -11,6 +11,7 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent"
 import type { SubagentScheduler } from "../schedule.js"
 import type { ScheduledSubagent } from "../types.js"
+import { selectItem } from "./select-item.js"
 
 /** Format an ISO timestamp as relative time ("in 4h", "2d ago", "—"). */
 function relTime(iso: string | undefined, now = Date.now()): string {
@@ -88,16 +89,16 @@ export async function showSchedulesMenu(
     return
   }
 
-  const labels = jobs.map((j) => formatJob(j, scheduler))
-  const choice = await ctx.ui.select(
+  // Numbered + item-paired: two jobs whose names agree in the first 18
+  // characters format identically, and matching the returned string back
+  // against a parallel label array cancelled whichever came first.
+  const job = await selectItem(
+    ctx.ui,
     `Scheduled jobs (${jobs.length}) — select to cancel`,
-    labels,
+    jobs,
+    (j) => formatJob(j, scheduler),
   )
-  if (!choice) return
-
-  const idx = labels.indexOf(choice)
-  if (idx < 0) return
-  const job = jobs[idx]
+  if (!job) return
 
   const ok = await ctx.ui.confirm(
     `Cancel "${job.name}"?`,

package/src/ui/select-item.ts

@@ -0,0 +1,48 @@
+/**
+ * select-item.ts — pick an item from a list via `ctx.ui.select`, safely.
+ *
+ * Pi's dialog API is `select(title, options: string[]) => Promise<string | undefined>`:
+ * strings in, string out, with no index or value form. Callers therefore have to
+ * map the returned string back to the item it came from, and the obvious way —
+ * `labels.indexOf(choice)` over a parallel array — silently resolves to the
+ * FIRST match whenever two rows format identically. Row formatters here truncate
+ * (job names to 18 chars, agent descriptions to whatever fits), and the text they
+ * truncate is LLM-authored, so collisions are ordinary rather than exotic.
+ *
+ * This numbers every row, which makes the labels unique by construction — no
+ * data-dependent branch that only executes in the case nobody exercises — and
+ * keeps each label paired with its item so a later edit that sorts or filters
+ * between building and resolving cannot desync them.
+ */
+
+/** Minimal shape of the `ctx.ui` surface this needs. */
+export interface SelectUI {
+  select(title: string, options: string[]): Promise<string | undefined>
+}
+
+/**
+ * Show a numbered picker and return the chosen item (not its label).
+ *
+ * Returns undefined when the user escapes, or when the returned string is not
+ * one we offered.
+ */
+export async function selectItem<T>(
+  ui: SelectUI,
+  title: string,
+  items: readonly T[],
+  format: (item: T, index: number) => string,
+): Promise<T | undefined> {
+  // Pad the number so a 10+ item list keeps its columns aligned.
+  const width = String(items.length).length
+  const rows = items.map((item, i) => ({
+    item,
+    label: `${String(i + 1).padStart(width)}. ${format(item, i)}`,
+  }))
+
+  const choice = await ui.select(
+    title,
+    rows.map((r) => r.label),
+  )
+  if (!choice) return undefined
+  return rows.find((r) => r.label === choice)?.item
+}