@dreki-gg/pi-subagent 0.8.2 → 0.8.4

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @dreki-gg/pi-subagent
 
+## 0.8.4
+
+### Patch Changes
+
+- [`376864c`](https://github.com/dreki-gg/pi-extensions/commit/376864c37cefa47530363b47055311269c1724a8) Thanks [@jalbarrang](https://github.com/jalbarrang)! - feat(subagent): show live tool-aware status in working message during /run-agent
+
+  Previously `/run-agent` only showed a transient notification, leaving users with no visibility into what the background agent was doing (especially after a fork-at session switch that visually looks like a reload). Now the working message updates in real-time as the agent works:
+
+  - `scout · starting...`
+  - `scout · reading …/src/utils.ts`
+  - `scout · $ bun test --filter...`
+  - `scout · editing …/config.json`
+  - `scout · thinking...`
+
+  Added `onToolExecutionStart` callback to `spawnPiAgent` and `runAgent` to surface `tool_execution_start` events from the JSON stream.
+
+## 0.8.3
+
+### Patch Changes
+
+- [`6f0b219`](https://github.com/dreki-gg/pi-extensions/commit/6f0b219ac357ce1607a7a8211fd1c66bd35c62f1) Thanks [@jalbarrang](https://github.com/jalbarrang)! - fix(subagent): resolve TDZ crash when onMessage/onToolResult callbacks fire before spawnResult is assigned
+
+  Previously, `runSingleAgent` declared `const spawnResult = await spawnPiAgent({...})` and referenced `spawnResult` inside the `onMessage`/`onToolResult` callbacks. Since callbacks fire during the await (before the const is assigned), this caused a `ReferenceError: Cannot access 'spawnResult' before initialization`. Now uses `let` with a guard to safely accumulate messages when the result is not yet available.
+
 ## 0.8.2
 
 ### Patch Changes

package/extensions/subagent/agent-runner.ts

@@ -1,7 +1,7 @@
 import type { ResolvedPaths } from '@earendil-works/pi-coding-agent';
 import { discoverAgents, type AgentScope } from './agents.js';
 import type { AgentResult } from './agent-runner-types.js';
-import { emptyUsage, spawnPiAgent } from './spawn-utils.js';
+import { emptyUsage, spawnPiAgent, type ToolExecutionStartEvent } from './spawn-utils.js';
 
 export type OnPhaseUpdate = (phaseName: string, agentName: string, result: AgentResult) => void;
 
@@ -11,6 +11,7 @@ export interface RunAgentOptions {
   model?: string;
   thinking?: string;
   onUpdate?: OnPhaseUpdate;
+  onToolExecutionStart?: (event: ToolExecutionStartEvent) => void;
   phaseName?: string;
   signal?: AbortSignal;
   resolvedPaths?: ResolvedPaths;
@@ -76,6 +77,7 @@ export async function runAgent(
         options.onUpdate(options.phaseName ?? 'unknown', agentName, { ...result });
       }
     },
+    onToolExecutionStart: options.onToolExecutionStart,
   });
 
   result.exitCode = spawnResult.exitCode;

package/extensions/subagent/index.ts

@@ -27,26 +27,77 @@ import {
   SettingsManager,
 } from '@earendil-works/pi-coding-agent';
 import type { ResolvedPaths } from '@earendil-works/pi-coding-agent';
-import { Box, Container, Markdown, Spacer, Text, type AutocompleteItem } from '@earendil-works/pi-tui';
-import { Type } from 'typebox';
 import {
-  type AgentConfig,
-  type AgentScope,
-  type AgentSource,
-  discoverAgents,
-} from './agents.js';
+  Box,
+  Container,
+  Markdown,
+  Spacer,
+  Text,
+  type AutocompleteItem,
+} from '@earendil-works/pi-tui';
+import { Type } from 'typebox';
+import { type AgentConfig, type AgentScope, type AgentSource, discoverAgents } from './agents.js';
 import { formatRunAgentUsage, parseRunAgentArgs } from './run-agent-args.js';
 import { runAgent } from './agent-runner.js';
 import { extractRecentConversation } from './synthesis.js';
 import type { AgentResult } from './agent-runner-types.js';
 import { getFinalText } from './agent-result-utils.js';
 import { buildHandoffFromResult, renderHandoffForPrompt } from './handoffs.js';
-import { emptyUsage, spawnPiAgent } from './spawn-utils.js';
+import { emptyUsage, spawnPiAgent, type ToolExecutionStartEvent } from './spawn-utils.js';
 
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
 
+function describeToolExecution(event: ToolExecutionStartEvent): string {
+  const shortenPath = (p: string) => {
+    const home = os.homedir();
+    const shortened = p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+    // Show only the last 2 path segments for brevity
+    const parts = shortened.split('/');
+    return parts.length > 3 ? `…/${parts.slice(-2).join('/')}` : shortened;
+  };
+
+  const args = event.args;
+  switch (event.toolName) {
+    case 'bash': {
+      const cmd = (args.command as string) || '';
+      const preview = cmd.length > 50 ? `${cmd.slice(0, 50)}…` : cmd;
+      return `$ ${preview}`;
+    }
+    case 'read': {
+      const p = ((args.file_path || args.path) as string) || '';
+      return `reading ${shortenPath(p)}`;
+    }
+    case 'write': {
+      const p = ((args.file_path || args.path) as string) || '';
+      return `writing ${shortenPath(p)}`;
+    }
+    case 'edit': {
+      const p = ((args.file_path || args.path) as string) || '';
+      return `editing ${shortenPath(p)}`;
+    }
+    case 'grep': {
+      const pattern = (args.pattern as string) || '';
+      return `grep /${pattern}/`;
+    }
+    case 'find': {
+      const pattern = (args.pattern as string) || '*';
+      return `find ${pattern}`;
+    }
+    case 'ls':
+      return `ls ${shortenPath((args.path as string) || '.')}`;
+    case 'web_search':
+      return `searching: ${(args.query as string)?.slice(0, 40) || '…'}`;
+    case 'web_visit':
+      return 'visiting page';
+    case 'subagent':
+      return `spawning ${(args.agent as string) || 'subagent'}`;
+    default:
+      return event.toolName;
+  }
+}
+
 function formatTokens(count: number): string {
   if (count < 1000) return count.toString();
   if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
@@ -247,7 +298,6 @@ async function mapWithConcurrencyLimit<TIn, TOut>(
   return results;
 }
 
-
 type OnUpdateCallback = (partial: AgentToolResult<SubagentDetails>) => void;
 
 async function runSingleAgent(
@@ -303,7 +353,8 @@ async function runSingleAgent(
     }
   };
 
-  const spawnResult = await spawnPiAgent({
+  let spawnResult: Awaited<ReturnType<typeof spawnPiAgent>> | undefined;
+  spawnResult = await spawnPiAgent({
     cwd: cwd ?? defaultCwd,
     agentName: agent.name,
     task,
@@ -313,15 +364,23 @@ async function runSingleAgent(
     tools: agent.tools,
     signal,
     onMessage: (msg) => {
-      currentResult.messages = spawnResult.messages;
-      currentResult.usage = spawnResult.usage;
-      currentResult.model = spawnResult.model ?? currentResult.model;
-      currentResult.stopReason = spawnResult.stopReason;
-      currentResult.errorMessage = spawnResult.errorMessage;
+      if (!spawnResult) {
+        currentResult.messages = [...currentResult.messages, msg];
+      } else {
+        currentResult.messages = spawnResult.messages;
+        currentResult.usage = spawnResult.usage;
+        currentResult.model = spawnResult.model ?? currentResult.model;
+        currentResult.stopReason = spawnResult.stopReason;
+        currentResult.errorMessage = spawnResult.errorMessage;
+      }
       emitUpdate();
     },
-    onToolResult: () => {
-      currentResult.messages = spawnResult.messages;
+    onToolResult: (msg) => {
+      if (!spawnResult) {
+        currentResult.messages = [...currentResult.messages, msg];
+      } else {
+        currentResult.messages = spawnResult.messages;
+      }
       emitUpdate();
     },
   });
@@ -373,13 +432,19 @@ const SubagentParams = Type.Object({
     Type.String({ description: 'Optional default model override for the run or all steps/tasks' }),
   ),
   thinking: Type.Optional(
-    Type.String({ description: 'Optional default reasoning level override for the run or all steps/tasks' }),
+    Type.String({
+      description: 'Optional default reasoning level override for the run or all steps/tasks',
+    }),
   ),
   tasks: Type.Optional(
-    Type.Array(TaskItem, { description: 'Array of {agent, task, model?, thinking?} for parallel execution' }),
+    Type.Array(TaskItem, {
+      description: 'Array of {agent, task, model?, thinking?} for parallel execution',
+    }),
   ),
   chain: Type.Optional(
-    Type.Array(ChainItem, { description: 'Array of {agent, task, model?, thinking?} for sequential execution' }),
+    Type.Array(ChainItem, {
+      description: 'Array of {agent, task, model?, thinking?} for sequential execution',
+    }),
   ),
   agentScope: Type.Optional(AgentScopeSchema),
   confirmProjectAgents: Type.Optional(
@@ -424,9 +489,7 @@ export default function (pi: ExtensionAPI) {
     if (!trimmedEnd) return replacement;
     if (/\s$/.test(argumentText)) return `${trimmedEnd} ${replacement}`;
     const lastSpace = trimmedEnd.lastIndexOf(' ');
-    return lastSpace === -1
-      ? replacement
-      : `${trimmedEnd.slice(0, lastSpace + 1)}${replacement}`;
+    return lastSpace === -1 ? replacement : `${trimmedEnd.slice(0, lastSpace + 1)}${replacement}`;
   }
 
   function buildArgumentCompletions(
@@ -456,9 +519,9 @@ export default function (pi: ExtensionAPI) {
     return discoverAgents(autocompleteCwd, scope, resolvedPaths).agents;
   }
 
-  async function getAutocompleteModels(scope: AgentScope): Promise<
-    Array<{ value: string; label?: string; description?: string }>
-  > {
+  async function getAutocompleteModels(
+    scope: AgentScope,
+  ): Promise<Array<{ value: string; label?: string; description?: string }>> {
     const items = new Map<string, { value: string; label?: string; description?: string }>();
 
     try {
@@ -1238,7 +1301,9 @@ export default function (pi: ExtensionAPI) {
         title,
         modeLine,
         theme.fg('muted', `Task: ${details.task}`),
-        failed && details.errorMessage ? theme.fg('error', `Error: ${details.errorMessage}`) : previewLines,
+        failed && details.errorMessage
+          ? theme.fg('error', `Error: ${details.errorMessage}`)
+          : previewLines,
         usageLine ? theme.fg('dim', usageLine) : undefined,
         theme.fg('muted', '(Ctrl+O to expand)'),
       ]
@@ -1347,7 +1412,10 @@ export default function (pi: ExtensionAPI) {
         { value: '--model', description: 'Override the agent model for this run' },
         { value: '--thinking', description: 'Override the reasoning level for this run' },
         { value: '--reasoning-level', description: 'Alias for --thinking' },
-        { value: '--yes-project-agents', description: 'Skip the project-agent trust confirmation prompt' },
+        {
+          value: '--yes-project-agents',
+          description: 'Skip the project-agent trust confirmation prompt',
+        },
         ...agents.map((agent) => ({
           value: agent.name,
           label: agent.name,
@@ -1363,7 +1431,8 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      const { agentName, explicitTask, agentScope, confirmProjectAgents, model, thinking } = parsed.options;
+      const { agentName, explicitTask, agentScope, confirmProjectAgents, model, thinking } =
+        parsed.options;
       if (!agentName) {
         ctx.ui.notify(formatRunAgentUsage(), 'warning');
         return;
@@ -1394,7 +1463,10 @@ export default function (pi: ExtensionAPI) {
       const conversation = extractRecentConversation(ctx);
       const task = buildRunAgentTask(conversation, explicitTask);
       if (!task) {
-        ctx.ui.notify(`No conversation context and no task specified.\n\n${formatRunAgentUsage()}`, 'warning');
+        ctx.ui.notify(
+          `No conversation context and no task specified.\n\n${formatRunAgentUsage()}`,
+          'warning',
+        );
         return;
       }
 
@@ -1416,13 +1488,29 @@ export default function (pi: ExtensionAPI) {
           `Running agent: ${agent.name} [${agent.source}${forked ? ', forked' : ', inline'}${selectedModel ? `, model=${selectedModel}` : ''}${selectedThinking ? `, thinking=${selectedThinking}` : ''}]`,
           'info',
         );
+        let lastToolDescription = '';
+        const updateWorkingStatus = (toolDesc?: string) => {
+          if (toolDesc) lastToolDescription = toolDesc;
+          const parts = [agent.name];
+          if (lastToolDescription) parts.push(lastToolDescription);
+          commandUi.setWorkingMessage(parts.join(' · '));
+        };
+        updateWorkingStatus('starting...');
 
         const result = await runAgent(commandCwd, agent.name, task, {
           agentScope,
           resolvedPaths,
           model,
           thinking,
+          onUpdate: () => {
+            // When a turn completes and the agent is thinking about next steps
+            updateWorkingStatus('thinking...');
+          },
+          onToolExecutionStart: (event) => {
+            updateWorkingStatus(describeToolExecution(event));
+          },
         });
+        commandUi.setWorkingMessage();
         const failed = result.exitCode !== 0 || result.stopReason === 'error';
         const output = getFinalText(result).trim();
 
@@ -1486,5 +1574,4 @@ export default function (pi: ExtensionAPI) {
       await runAndReport(ctx.cwd, ctx.ui, (message) => pi.sendMessage(message), false);
     },
   });
-
 }

package/extensions/subagent/spawn-utils.ts

@@ -57,6 +57,12 @@ function cleanupTempFiles(
   if (tmpPromptDir) try { fs.rmdirSync(tmpPromptDir); } catch { /* ignore */ }
 }
 
+export interface ToolExecutionStartEvent {
+  toolCallId: string;
+  toolName: string;
+  args: Record<string, unknown>;
+}
+
 export interface SpawnPiAgentOptions {
   cwd: string;
   agentName: string;
@@ -68,6 +74,7 @@ export interface SpawnPiAgentOptions {
   signal?: AbortSignal;
   onMessage?: (msg: Message) => void;
   onToolResult?: (msg: Message) => void;
+  onToolExecutionStart?: (event: ToolExecutionStartEvent) => void;
 }
 
 export interface SpawnPiAgentResult {
@@ -158,6 +165,14 @@ export async function spawnPiAgent(options: SpawnPiAgentOptions): Promise<SpawnP
           result.messages.push(event.message as Message);
           options.onToolResult?.(event.message as Message);
         }
+
+        if (event.type === 'tool_execution_start' && event.toolName) {
+          options.onToolExecutionStart?.({
+            toolCallId: event.toolCallId ?? '',
+            toolName: event.toolName,
+            args: event.args ?? {},
+          });
+        }
       };
 
       proc.stdout.on('data', (data: Buffer) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-subagent",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Subagent tool and direct agent runs for pi — isolated agents, parallel scouts, manager workflows, and bundled prompts",
   "keywords": [
     "pi-package"