pi-subagents-lite 1.4.6 → 1.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents-lite",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "description": "Lightweight sub-agents for pi — spawn specialized agents with isolated sessions, tools, and models.",
   "keywords": [
     "pi-package",

package/src/agents/agent-manager.ts

@@ -14,6 +14,7 @@ import {
   type AgentStatus,
   type CompactionInfo,
   type RunCallbacks,
+  type StopInitiator,
   SHORT_ID_LENGTH,
   type SpawnConfig,
   type ToolActivity,
@@ -267,7 +268,7 @@ export class AgentManager {
 
     // Wire parent abort signal to stop the subagent when the parent is interrupted
     if (options.signal) {
-      options.signal.addEventListener("abort", () => this.abort(id), { once: true });
+      options.signal.addEventListener("abort", () => this.abort(id, "agent"), { once: true });
     }
 
     const promise = runAgent(ctx, type, prompt, {
@@ -465,18 +466,18 @@ export class AgentManager {
     );
   }
 
-  abort(id: string): boolean {
+  abort(id: string, stoppedBy?: StopInitiator): boolean {
     const record = this.agents.get(id);
     if (!record) return false;
 
-    return this.stopAgent(record);
+    return this.stopAgent(record, stoppedBy);
   }
 
   /**
    * Stop an agent by aborting its session or removing it from the queue.
    * Returns true if the agent was stopped, false if it wasn't running/queued.
    */
-  private stopAgent(record: AgentRecord): boolean {
+  private stopAgent(record: AgentRecord, stoppedBy?: StopInitiator): boolean {
     if (record.lifecycle.status === "queued") {
       this.queue = this.queue.filter(q => q.id !== record.id);
     } else if (record.lifecycle.status !== "running") {
@@ -485,6 +486,7 @@ export class AgentManager {
       record.execution.abortController?.abort();
     }
     record.lifecycle.status = "stopped";
+    record.lifecycle.stoppedBy = stoppedBy;
     record.lifecycle.completedAt = Date.now();
     return true;
   }
@@ -501,6 +503,10 @@ export class AgentManager {
     for (const [id, record] of this.agents) {
       if (!isTerminalStatus(record.lifecycle.status)) continue;
       if ((record.lifecycle.completedAt ?? 0) >= cutoff) continue;
+      // Keep the record until the LLM has read the result (foreground return or
+      // background nudge). Otherwise a completed background agent can be wiped
+      // before its nudge is emitted.
+      if (!record.lifecycle.resultConsumed) continue;
       this.removeRecord(id, record);
     }
   }

package/src/agents/tool-execution.ts

@@ -88,6 +88,17 @@ export function buildAgentDetails(
   return details;
 }
 
+/**
+ * Result text plus status note, for display.
+ *
+ * Shared by the foreground tool result and the subagent-result nudge so both
+ * callers stay in sync on the nullish default and separator handling — they
+ * have diverged before. getStatusNote owns the leading separator.
+ */
+export function formatResultContent(record: AgentRecord): string {
+  return (record.result ?? "") + getStatusNote(record.lifecycle);
+}
+
 // ============================================================================
 // Tool execute handlers
 // ============================================================================
@@ -186,8 +197,7 @@ export async function executeAgentTool(
     return errorResult(`Agent failed: ${record.error || "unknown error"}`, details);
   }
 
-  const statusNote = getStatusNote(record.lifecycle.status);
-  return successResult((record.result ?? "") + statusNote, details);
+  return successResult(formatResultContent(record), details);
 }
 
 // ============================================================================
@@ -244,7 +254,7 @@ export async function executeStopAgentTool(
   }
 
   // Attempt to stop the running/queued agent
-  if (getManager()!.abort(agentId)) {
+  if (getManager()!.abort(agentId, "agent")) {
     return successResult(`Stopped agent ${agentId.slice(0, SHORT_ID_LENGTH)}`);
   }
 

package/src/spawn/spawn-coordinator.ts

@@ -1,5 +1,11 @@
-import { getStatusNote } from "../status-note.js";
 import { getPiInstance, getSessionCtx, getWidget } from "../shell.js";
+import { SHORT_ID_LENGTH } from "../types.js";
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentRecord, SpawnConfig, ToolActivity } from "../types.js";
+import type { AgentManager, SpawnOptions } from "../agents/agent-manager.js";
+import { buildAgentDetails, formatResultContent } from "../agents/tool-execution.js";
+
 /**
  * spawn-coordinator.ts — Spawn-and-track coordination for subagents.
  *
@@ -11,11 +17,6 @@ import { getPiInstance, getSessionCtx, getWidget } from "../shell.js";
  * D6 (Nudge owned here), D2 (peers with AgentManager).
  */
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { AgentRecord, SpawnConfig, ToolActivity } from "../types.js";
-import type { AgentManager, SpawnOptions } from "../agents/agent-manager.js";
-import { buildAgentDetails } from "../agents/tool-execution.js";
-
 // ============================================================================
 // Types
 // ============================================================================
@@ -121,6 +122,10 @@ export class SpawnCoordinator {
       // Foreground: await completion
       await record.execution.promise;
 
+      // Foreground tool handler reads the result inline on return — mark it
+      // consumed so the cleanup timer may evict the record once it ages out.
+      record.lifecycle.resultConsumed = true;
+
       // Clean up live view (foreground completion handled inline)
       this.liveViews.delete(agentId);
     }
@@ -234,7 +239,7 @@ export class SpawnCoordinator {
       pi.sendMessage(
         {
           customType: "subagent-result",
-          content: `[Subagent "${record.display.type}" ${record.lifecycle.status}]\n\n${record.result ?? ""} ${getStatusNote(record.lifecycle.status)}`,
+          content: `[Subagent "${record.display.type}" ${record.id.slice(0, SHORT_ID_LENGTH)} ${record.lifecycle.status}]\n\n${formatResultContent(record)}`,
           details,
           display: true,
         },
@@ -243,6 +248,10 @@ export class SpawnCoordinator {
           triggerTurn: true,
         },
       );
+
+      // Full result delivered to the LLM — record is now safe for the cleanup
+      // timer to evict once it ages out.
+      record.lifecycle.resultConsumed = true;
     } catch (error) {
       // sendMessage failed (shared runtime overwritten by subagent bindCore).
       // Fall back to UI notification using the captured spawning-session context.

package/src/status-note.ts

@@ -1,10 +1,20 @@
-const NOTES: Record<string, string> = {
-  stopped: "STOPPED BY THE USER before completion — output is partial; the task was NOT finished",
+import type { AgentLifecycle, AgentStatus, StopInitiator } from "./types.js";
+
+const STATUS_NOTES: Partial<Record<AgentStatus, string>> = {
   aborted: "hit the turn limit before completion; output may be incomplete",
   turn_limited: "wrapped up at the turn limit — output may be partial",
 };
 
-export function getStatusNote(status: string): string {
-  const note = NOTES[status];
+const STOP_NOTES: Record<StopInitiator, string> = {
+  user: "STOPPED BY THE USER before completion — output is partial; the task was NOT finished",
+  agent: "stopped before completion — output is partial; the task was NOT finished",
+};
+
+export function getStatusNote(lifecycle: AgentLifecycle): string {
+  const note =
+    lifecycle.status === "stopped"
+      // A stopped agent with no recorded initiator reads as an agent stop.
+      ? STOP_NOTES[lifecycle.stoppedBy ?? "agent"]
+      : STATUS_NOTES[lifecycle.status];
   return note ? ` (${note})` : "";
 }

package/src/types.ts

@@ -95,6 +95,9 @@ export interface CompactionInfo {
 /** Possible agent lifecycle statuses. */
 export type AgentStatus = "queued" | "running" | "completed" | "turn_limited" | "aborted" | "stopped" | "error";
 
+/** Who initiated an agent stop: "user" via UI menu, or "agent" via StopAgent tool. */
+export type StopInitiator = "user" | "agent";
+
 /**
  * Lifecycle state: when the agent started, completed, and its current status.
  * Used by agent-manager (lifecycle control), menus (status display), widget (linger logic).
@@ -103,6 +106,13 @@ export interface AgentLifecycle {
   status: AgentStatus;
   startedAt: number;
   completedAt?: number;
+  stoppedBy?: StopInitiator;
+  /**
+   * Whether the result has been read by the LLM (foreground return or background nudge).
+   * cleanup() preserves terminal records until this is set, so a completed background
+   * agent whose nudge hasn't fired yet isn't evicted before the LLM reads the result.
+   */
+  resultConsumed?: boolean;
 }
 
 /**

package/src/ui/menu/menu-running-agents.ts

@@ -134,7 +134,7 @@ export function buildAgentActionsList(
       input.onEscape = () => setActive(list);
       setActive(input);
     } else if (item.value === "stop") {
-      getManager()?.abort(record.id);
+      getManager()?.abort(record.id, "user");
       ctx.ui.notify(`Stopped ${shortId}`, "info");
       onClose();
     }
@@ -186,7 +186,7 @@ export async function showRunningAgentsMenu(
     agentList.onSelect = async (item) => {
       if (item.value === "__stop-all") {
         for (const r of running) {
-          getManager()?.abort(r.id);
+          getManager()?.abort(r.id, "user");
         }
         ctx.ui.notify(`Stopped ${running.length} agent(s)`, "info");
         done(undefined);