@gotgenes/pi-subagents 6.1.0 → 6.3.0

package/src/tools/agent-tool.ts

@@ -20,17 +20,15 @@ import {
   SPINNER,
   type UICtx,
 } from "../ui/agent-widget.js";
-import { addUsage, type LifetimeUsage } from "../usage.js";
+import { subscribeUIObserver } from "../ui/ui-observer.js";
+import type { LifetimeUsage } from "../usage.js";
 import { formatLifetimeTokens, textResult } from "./helpers.js";
 
 // ---- Agent-tool-specific helpers ----
 
-/**
- * Create an AgentActivity state and spawn callbacks for tracking tool usage.
- * Used by both foreground and background paths to avoid duplication.
- */
-export function createActivityTracker(maxTurns?: number, onStreamUpdate?: () => void) {
-  const state: AgentActivity = {
+/** Create a fresh AgentActivity state for tracking UI progress. */
+function createAgentActivity(maxTurns?: number): AgentActivity {
+  return {
     activeTools: new Map(),
     toolUses: 0,
     turnCount: 1,
@@ -39,40 +37,6 @@ export function createActivityTracker(maxTurns?: number, onStreamUpdate?: () =>
     session: undefined,
     lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
   };
-
-  const callbacks = {
-    onToolActivity: (activity: { type: "start" | "end"; toolName: string }) => {
-      if (activity.type === "start") {
-        state.activeTools.set(activity.toolName + "_" + Date.now(), activity.toolName);
-      } else {
-        for (const [key, name] of state.activeTools) {
-          if (name === activity.toolName) {
-            state.activeTools.delete(key);
-            break;
-          }
-        }
-        state.toolUses++;
-      }
-      onStreamUpdate?.();
-    },
-    onTextDelta: (_delta: string, fullText: string) => {
-      state.responseText = fullText;
-      onStreamUpdate?.();
-    },
-    onTurnEnd: (turnCount: number) => {
-      state.turnCount = turnCount;
-      onStreamUpdate?.();
-    },
-    onSessionCreated: (session: any) => {
-      state.session = session;
-    },
-    onAssistantUsage: (usage: { input: number; output: number; cacheWrite: number }) => {
-      addUsage(state.lifetimeUsage, usage);
-      onStreamUpdate?.();
-    },
-  };
-
-  return { state, callbacks };
 }
 
 /** Parenthetical status note for completed agent result text. */
@@ -451,8 +415,7 @@ Guidelines:
 
       // Background execution
       if (runInBackground) {
-        const { state: bgState, callbacks: bgCallbacks } =
-          createActivityTracker(effectiveMaxTurns);
+        const bgState = createAgentActivity(effectiveMaxTurns);
 
         let id: string;
 
@@ -469,7 +432,10 @@ Guidelines:
             isBackground: true,
             isolation,
             invocation: agentInvocation,
-            ...bgCallbacks,
+            onSessionCreated: (session: any) => {
+              bgState.session = session;
+              subscribeUIObserver(session, bgState);
+            },
           });
         } catch (err) {
           return textResult(err instanceof Error ? err.message : String(err));
@@ -521,6 +487,9 @@ Guidelines:
       const startedAt = Date.now();
       let fgId: string | undefined;
 
+      const fgState = createAgentActivity(effectiveMaxTurns);
+      let unsubUI: (() => void) | undefined;
+
       const streamUpdate = () => {
         const details: AgentDetails = {
           ...detailBase,
@@ -539,25 +508,6 @@ Guidelines:
         });
       };
 
-      const { state: fgState, callbacks: fgCallbacks } = createActivityTracker(
-        effectiveMaxTurns,
-        streamUpdate,
-      );
-
-      // Wire session creation to register in widget
-      const origOnSession = fgCallbacks.onSessionCreated;
-      fgCallbacks.onSessionCreated = (session: any) => {
-        origOnSession(session);
-        for (const a of deps.manager.listAgents()) {
-          if (a.session === session) {
-            fgId = a.id;
-            deps.agentActivity.set(a.id, fgState);
-            deps.widget.ensureTimer();
-            break;
-          }
-        }
-      };
-
       // Animate spinner at ~80ms (smooth rotation through 10 braille frames)
       const spinnerInterval = setInterval(() => {
         spinnerFrame++;
@@ -584,15 +534,28 @@ Guidelines:
             signal,
             parentSessionFile: ctx.sessionManager.getSessionFile(),
             parentSessionId: ctx.sessionManager.getSessionId(),
-            ...fgCallbacks,
+            onSessionCreated: (session: any) => {
+              fgState.session = session;
+              unsubUI = subscribeUIObserver(session, fgState, streamUpdate);
+              for (const a of deps.manager.listAgents()) {
+                if (a.session === session) {
+                  fgId = a.id;
+                  deps.agentActivity.set(a.id, fgState);
+                  deps.widget.ensureTimer();
+                  break;
+                }
+              }
+            },
           },
         );
       } catch (err) {
         clearInterval(spinnerInterval);
+        unsubUI?.();
         return textResult(err instanceof Error ? err.message : String(err));
       }
 
       clearInterval(spinnerInterval);
+      unsubUI?.();
 
       // Clean up foreground agent from widget
       if (fgId) {

package/src/types.ts

@@ -83,8 +83,38 @@ export interface NotificationDetails {
 
 }
 
+/**
+ * Plain data snapshot of the parent session state captured at spawn time.
+ * Replaces live `ExtensionContext` references so queued agents don't read stale state.
+ */
+export interface ParentSnapshot {
+  /** Parent working directory. */
+  cwd: string;
+  /** Parent's effective system prompt (for append-mode agents). */
+  systemPrompt: string;
+  /** Parent's current model instance (fallback when agent config has no model). */
+  model: unknown;
+  /** Model registry for resolving config.model strings and creating sessions. */
+  modelRegistry: {
+    find(provider: string, modelId: string): unknown;
+    getAvailable?(): Array<{ provider: string; id: string }>;
+  };
+  /** Pre-built parent conversation text (when inheritContext was requested). */
+  parentContext?: string;
+}
+
 export interface EnvInfo {
   isGitRepo: boolean;
   branch: string;
   platform: string;
 }
+
+/**
+ * Narrow shell-exec callback replacing `ExtensionAPI` in `detectEnv()`.
+ * Matches the shape of `pi.exec()` without carrying an SDK dependency.
+ */
+export type ShellExec = (
+  command: string,
+  args: string[],
+  options?: { cwd?: string; timeout?: number },
+) => Promise<{ stdout: string; stderr: string; code: number }>;

package/src/ui/agent-menu.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SpawnOptions } from "../agent-manager.js";
 import {
   BUILTIN_TOOL_NAMES,
@@ -21,7 +21,7 @@ export interface AgentMenuManager {
   listAgents: () => AgentRecord[];
   getRecord: (id: string) => AgentRecord | undefined;
   /** Used by generate wizard to spawn an agent that writes the .md file. */
-  spawnAndWait: (pi: ExtensionAPI | null, ctx: ExtensionContext, type: string, prompt: string, opts: Omit<SpawnOptions, "isBackground">) => Promise<AgentRecord>;
+  spawnAndWait: (ctx: ExtensionContext, type: string, prompt: string, opts: Omit<SpawnOptions, "isBackground">) => Promise<AgentRecord>;
   getMaxConcurrent: () => number;
   setMaxConcurrent: (n: number) => void;
 }
@@ -487,7 +487,6 @@ Guidelines for choosing settings:
 Write the file using the write tool. Only write the file, nothing else.`;
 
     const record = await deps.manager.spawnAndWait(
-      null,
       ctx,
       "general-purpose",
       generatePrompt,

package/src/ui/ui-observer.ts

@@ -0,0 +1,83 @@
+/**
+ * ui-observer.ts — Subscribes to session events and updates AgentActivity state.
+ *
+ * Replaces the callback-based createActivityTracker pattern with a direct
+ * session subscription for streaming UI state (active tools, response text,
+ * turn count, lifetime usage).
+ */
+
+import { addUsage } from "../usage.js";
+import type { AgentActivity } from "./agent-widget.js";
+
+/** Narrow session interface — only the subscribe method needed by the observer. */
+interface SubscribableSession {
+	subscribe(fn: (event: any) => void): () => void;
+}
+
+/**
+ * Subscribe to session events and stream UI state into an AgentActivity object.
+ *
+ * Handles:
+ * - `tool_execution_start` → add to `state.activeTools`
+ * - `tool_execution_end` → remove from `state.activeTools`, `state.toolUses++`
+ * - `message_start` → reset `state.responseText`
+ * - `message_update` (text_delta) → append to `state.responseText`
+ * - `turn_end` → `state.turnCount++`
+ * - `message_end` (assistant, with usage) → `addUsage(state.lifetimeUsage, …)`
+ *
+ * Calls `onUpdate?.()` after each state mutation to trigger re-renders.
+ *
+ * @returns An unsubscribe function.
+ */
+export function subscribeUIObserver(
+	session: SubscribableSession,
+	state: AgentActivity,
+	onUpdate?: () => void,
+): () => void {
+	return session.subscribe((event: any) => {
+		if (event.type === "tool_execution_start") {
+			state.activeTools.set(event.toolName + "_" + Date.now(), event.toolName);
+			onUpdate?.();
+		}
+
+		if (event.type === "tool_execution_end") {
+			for (const [key, name] of state.activeTools) {
+				if (name === event.toolName) {
+					state.activeTools.delete(key);
+					break;
+				}
+			}
+			state.toolUses++;
+			onUpdate?.();
+		}
+
+		if (event.type === "message_start") {
+			state.responseText = "";
+		}
+
+		if (
+			event.type === "message_update" &&
+			event.assistantMessageEvent?.type === "text_delta"
+		) {
+			state.responseText += event.assistantMessageEvent.delta;
+			onUpdate?.();
+		}
+
+		if (event.type === "turn_end") {
+			state.turnCount++;
+			onUpdate?.();
+		}
+
+		if (event.type === "message_end" && event.message?.role === "assistant") {
+			const u = event.message.usage;
+			if (u) {
+				addUsage(state.lifetimeUsage, {
+					input: u.input ?? 0,
+					output: u.output ?? 0,
+					cacheWrite: u.cacheWrite ?? 0,
+				});
+				onUpdate?.();
+			}
+		}
+	});
+}