@mystilleef/pi-subagent 0.5.0 → 0.7.0

package/src/index.ts

@@ -5,18 +5,19 @@ import type {
 import {
   getCachedAgentCompletions,
   resetAgentDiscoveryCache,
-} from "./agent-cache.js";
-import { cancelSubagentCommandHandler } from "./cancel-command.js";
-import { jobsCommandHandler } from "./jobs-command.js";
-import { renderSubagentProgress } from "./progress.js";
-import { renderSubagentResultMessage } from "./run.js";
-import { runCommandHandler } from "./run-command.js";
+} from "./agent/agent-cache.js";
+import { isDirectoryAsync } from "./agent/agents.js";
+import { cancelSubagentCommandHandler } from "./orchestration/cancel-command.js";
+import { jobsCommandHandler } from "./orchestration/jobs-command.js";
+import { renderSubagentResultMessage } from "./orchestration/run.js";
+import { runCommandHandler } from "./orchestration/run-command.js";
 import {
-  formatStartJobStatus,
+  formatSubagentToolResult,
   SubagentParams,
   startSubagentJob,
-} from "./subagent-orchestrator.js";
-import { renderSubagentCall, renderSubagentResult } from "./ui.js";
+} from "./orchestration/subagent-orchestrator.js";
+import { renderSubagentCall, renderSubagentToolResult } from "./output/ui.js";
+import { renderSubagentProgress } from "./progress/progress.js";
 
 export { SubagentParams };
 
@@ -24,15 +25,40 @@ export function resetAgentCache() {
   resetAgentDiscoveryCache();
 }
 
+function normalizeWorkspaceRoot(cwd: string | undefined): string | undefined {
+  if (typeof cwd !== "string") return undefined;
+  const root = cwd.trim();
+  return root.length > 0 ? root : undefined;
+}
+
 export default function registerSubagentExtension(pi: ExtensionAPI) {
+  let activeWorkspaceRoot: string | undefined;
+  const setActiveWorkspaceRoot = (
+    cwd: string | undefined,
+    fallback?: string,
+  ) => {
+    activeWorkspaceRoot = normalizeWorkspaceRoot(cwd ?? fallback);
+  };
+  const getRunArgumentCompletions = async (prefix: string) => {
+    if (!activeWorkspaceRoot) return [];
+    if (!(await isDirectoryAsync(activeWorkspaceRoot))) return [];
+    return getCachedAgentCompletions(prefix, activeWorkspaceRoot);
+  };
+  pi.on("resources_discover", (event, ctx) => {
+    setActiveWorkspaceRoot(ctx.cwd, event.cwd);
+  });
+  pi.on("session_start", (_event, ctx) => {
+    setActiveWorkspaceRoot(ctx.cwd);
+  });
   pi.registerMessageRenderer("subagent-progress", renderSubagentProgress);
   pi.registerMessageRenderer("subagent-result", renderSubagentResultMessage);
   pi.registerCommand("run", {
     description: "Run a subagent directly: /run <agent> [task]",
-    getArgumentCompletions: async (prefix: string) =>
-      getCachedAgentCompletions(prefix),
-    handler: async (args, ctx) =>
-      runCommandHandler(pi, ctx as ExtensionContext, args),
+    getArgumentCompletions: getRunArgumentCompletions,
+    handler: async (args, ctx) => {
+      setActiveWorkspaceRoot(ctx.cwd);
+      return runCommandHandler(pi, ctx as ExtensionContext, args);
+    },
   });
   pi.registerCommand("cancel-subagent", {
     description:
@@ -48,28 +74,21 @@ export default function registerSubagentExtension(pi: ExtensionAPI) {
     label: "Subagent",
     description: "Delegate a task to a subagent with isolated context.",
     parameters: SubagentParams,
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const result = await startSubagentJob(
         pi,
         ctx,
         params,
         signal ?? undefined,
+        onUpdate ?? undefined,
       );
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: formatStartJobStatus(params.agent, result),
-          },
-        ],
-        details: result.makeDetails([]),
-      };
+      return formatSubagentToolResult(params.agent, result);
     },
     renderCall(args, theme, _context) {
       return renderSubagentCall(args, theme);
     },
     renderResult(result, display, theme, _context) {
-      return renderSubagentResult(result, theme, display);
+      return renderSubagentToolResult(result, theme, display);
     },
   });
 }

package/src/{jobs-command.ts → orchestration/jobs-command.ts}

@@ -1,11 +1,10 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-
+import { renderRunsBoard } from "../output/ui.js";
 import {
   getAllProgressStates,
   type SubagentProgressState,
-} from "./progress-state.js";
+} from "../progress/progress-state.js";
 import { listRunJobs } from "./run-registry.js";
-import { renderRunsBoard } from "./ui.js";
 
 export async function jobsCommandHandler(
   ctx: ExtensionCommandContext,

package/src/{run.ts → orchestration/run.ts}

@@ -1,5 +1,5 @@
-import type { SubagentDetails } from "./types.js";
-import { renderSubagentResult, type SubagentTheme } from "./ui.js";
+import { renderSubagentResult, type SubagentTheme } from "../output/ui.js";
+import type { SubagentDetails } from "../shared/types.js";
 
 /**
  * Pi message renderer adapter for `"subagent-result"` messages.

package/src/{subagent-orchestrator.ts → orchestration/subagent-orchestrator.ts}

@@ -1,46 +1,48 @@
+import type { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
 import { type Message, StringEnum } from "@earendil-works/pi-ai";
 import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import { getCachedAgentDiscovery } from "./agent-cache.js";
-import {
-  type AgentConfig,
-  type AgentScope,
-  discoverAgents,
-  type ThinkingLevel,
-} from "./agents.js";
-import { generateSubagentInstanceName } from "./instance-name.js";
-import { runSingleAgent } from "./process.js";
+import { getCachedAgentDiscovery } from "../agent/agent-cache.js";
+import type {
+  AgentConfig,
+  AgentScope,
+  ThinkingLevel,
+} from "../agent/agents.js";
+import { runSingleAgent, SubagentAbortError } from "../child/process.js";
+import { formatSubagentResultForParent } from "../output/summary.js";
 import {
   cancelProgressState,
   createProgressState,
   failProgressState,
   finalizeProgressState,
   getProgressState,
-} from "./progress.js";
+} from "../progress/progress.js";
 import {
   createSubagentError,
   getFeedbackSummaryText,
+  getLatestResult,
   getResultDisplayText,
   hasSubagentFailed,
   patchProgressFromDetails,
   sanitizeDetailsForDisplay,
-} from "./result-details.js";
+} from "../progress/result-details.js";
+import { generateSubagentInstanceName } from "../shared/instance-name.js";
+import type {
+  OnUpdateCallback,
+  SingleResult,
+  SubagentDetails,
+  SubagentToolResult,
+} from "../shared/types.js";
+import { getSubagentDepth } from "../shared/utils.js";
 import {
   listRunJobs,
   type RunJob,
   registerRunJob,
   removeRunJob,
 } from "./run-registry.js";
-import { formatSubagentResultForParent } from "./summary.js";
-import type {
-  OnUpdateCallback,
-  SingleResult,
-  SubagentDetails,
-  SubagentToolResult,
-} from "./types.js";
 
 const AgentScopeSchema = StringEnum(["user", "project", "both"] as const, {
   description:
@@ -75,6 +77,22 @@ type DetailsBuilder = (
   options?: DetailsOptions,
 ) => SubagentDetails;
 
+interface LifecycleContext {
+  pi: ExtensionAPI;
+  ctx: ExtensionContext;
+  requestId: string;
+  job: RunJob;
+  debug: boolean;
+  makeDetails: DetailsBuilder;
+  mergedSignal: AbortSignal;
+  agents: AgentConfig[];
+  agentName: string;
+  task: string;
+  parentModel: { provider: string; id: string } | undefined;
+  parentThinking: ThinkingLevel;
+  hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails>;
+}
+
 function createDetailsBuilder(
   agentScope: AgentScope,
   projectAgentsDir: string | null,
@@ -99,37 +117,40 @@ function sanitizeResultDetails(
     includeDebugMessages && (options?.includeMessages ?? true);
   const { messages, termination, progress, stderr, usage, ...core } = result;
   const { contextWindowTokens, ...usageBase } = usage;
-
   const sanitized: Record<string, unknown> = {
     ...core,
     stderr: includeDebugMessages ? stderr : "",
     usage: { ...usageBase },
   };
-
   if (contextWindowTokens !== undefined) {
     (sanitized.usage as Record<string, unknown>).contextWindowTokens =
       contextWindowTokens;
   }
-
   if (progress !== undefined) {
-    const { activityText, lastToolPreview, ...progBase } = progress;
+    const {
+      activityText,
+      activeToolActivity,
+      lastToolPreview,
+      toolResultCompleted,
+      ...progBase
+    } = progress;
     sanitized.progress = {
       toolCalls: progBase.toolCalls.map((tc) => ({
         id: tc.id,
         preview: tc.preview,
       })),
       ...(activityText !== undefined && { activityText }),
+      ...(activeToolActivity !== undefined && { activeToolActivity }),
       ...(lastToolPreview !== undefined && { lastToolPreview }),
+      ...(toolResultCompleted !== undefined && { toolResultCompleted }),
     };
   }
-
   if (includeMessages) {
     sanitized.messages = options?.recentMessages
       ? [...options.recentMessages]
       : messages !== undefined
         ? [...messages]
         : undefined;
-
     if (includeDebugMessages && termination !== undefined) {
       const { cancelReason, terminationSignal, fallbackCause, ...termBase } =
         termination;
@@ -141,7 +162,6 @@ function sanitizeResultDetails(
       };
     }
   }
-
   return sanitized as unknown as SingleResult;
 }
 
@@ -184,93 +204,136 @@ export function emitCompletionAlert(
   process.stdout.write("\x07");
 }
 
-async function runSubagentWorker(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  agents: AgentConfig[],
-  agentName: string,
-  task: string,
-  debug: boolean,
-  parentModel: { provider: string; id: string } | undefined,
-  parentThinking: ThinkingLevel,
-  makeDetails: DetailsBuilder,
-  requestId: string,
-  job: RunJob,
-  mergedSignal: AbortSignal,
-): Promise<void> {
+function createCompletedToolResult(
+  content: string,
+  details: SubagentDetails,
+): SubagentToolResult {
+  return {
+    content: [{ type: "text", text: content }],
+    details: { ...details, renderedByMessage: true },
+  };
+}
+
+function finishLifecycleFailure(
+  lc: LifecycleContext,
+  errorMessage: string,
+  details: SubagentDetails,
+): SubagentToolResult {
+  const displayDetails = sanitizeDetailsForDisplay(details, lc.debug);
+  if (lc.mergedSignal.aborted) {
+    cancelProgressState(lc.requestId, lc.job.cancelReason ?? errorMessage);
+    if (getSubagentDepth() > 0) {
+      sendSubagentResultMessage(lc.pi, "Canceled", displayDetails);
+    }
+    return createCompletedToolResult("Canceled", displayDetails);
+  }
+  failProgressState(lc.requestId, errorMessage);
+  lc.ctx.ui?.notify(errorMessage, "error");
+  const latestResult = getLatestResult(details);
+  const content = latestResult
+    ? formatSubagentResultForParent(latestResult) || "(failed)"
+    : errorMessage;
+  sendSubagentResultMessage(lc.pi, content, displayDetails);
+  return createCompletedToolResult(content, displayDetails);
+}
+
+function finishLifecycleResult(
+  lc: LifecycleContext,
+  result: SingleResult,
+): SubagentToolResult {
+  const details = lc.makeDetails([result]);
+  if (hasSubagentFailed(result)) {
+    return finishLifecycleFailure(
+      lc,
+      lc.mergedSignal.aborted ? "Aborted" : createSubagentError(result).message,
+      details,
+    );
+  }
+  const displayDetails = sanitizeDetailsForDisplay(details, lc.debug);
+  const content = formatSubagentResultForParent(result) || "(no output)";
+  const toolResult = createCompletedToolResult(content, displayDetails);
+  finalizeProgressState(lc.requestId, getFeedbackSummaryText(toolResult));
+  sendSubagentResultMessage(
+    lc.pi,
+    getResultDisplayText(toolResult),
+    displayDetails,
+  );
+  return toolResult;
+}
+
+function createPayloadFingerprint(payload: {
+  content: { type: string; text?: string }[];
+  details: SubagentDetails;
+}): string {
+  const contentText = payload.content[0]?.text ?? "";
+  const latestResult = payload.details.results[0];
+  const activityText = latestResult?.progress?.activityText ?? "";
+  const toolCallIds =
+    [...new Set(latestResult?.progress?.toolCalls?.map((tc) => tc.id))]
+      .sort()
+      .join(",") ?? "";
+  const exitCode = latestResult?.exitCode ?? 0;
+  const stopReason = latestResult?.stopReason ?? "";
+  return `${contentText}|${activityText}|${toolCallIds}|${exitCode}|${stopReason}`;
+}
+
+async function runSubagentLifecycle(
+  lc: LifecycleContext,
+): Promise<SubagentToolResult> {
   const seenToolCallIds = new Set<string>();
-  const requestProgressRender = createProgressRenderRequester(ctx, requestId);
+  const requestProgressRender = createProgressRenderRequester(
+    lc.ctx,
+    lc.requestId,
+  );
+  let lastDeliveredFingerprint: string | undefined;
   const onUpdate: OnUpdateCallback = (result) => {
-    patchProgressFromDetails(requestId, result.details, seenToolCallIds);
+    patchProgressFromDetails(lc.requestId, result.details, seenToolCallIds);
     requestProgressRender();
-  };
-  function handleWorkerFailure(
-    errorMessage: string,
-    isAborted: boolean,
-    details: SubagentDetails,
-  ) {
-    if (isAborted) {
-      cancelProgressState(requestId, job.cancelReason ?? errorMessage);
-    } else {
-      failProgressState(requestId, errorMessage);
-      ctx.ui?.notify(errorMessage, "error");
-      const content = details.results[0]
-        ? formatSubagentResultForParent(details.results[0] as SingleResult) ||
-          "(failed)"
-        : errorMessage;
-      sendSubagentResultMessage(
-        pi,
-        content,
-        sanitizeDetailsForDisplay(details, debug),
+    if (lc.hostOnUpdate) {
+      const sanitizedDetails = sanitizeDetailsForDisplay(
+        result.details,
+        lc.debug,
       );
+      const { renderedByMessage, ...partialDetails } = sanitizedDetails;
+      const payload = {
+        content: result.content,
+        details: partialDetails,
+      };
+      const fingerprint = createPayloadFingerprint(payload);
+      if (fingerprint !== lastDeliveredFingerprint) {
+        lastDeliveredFingerprint = fingerprint;
+        lc.hostOnUpdate(payload);
+      }
     }
-  }
+  };
+  const timerTick = setInterval(requestProgressRender, 500);
   try {
     const result = await runSingleAgent(
-      ctx.cwd,
-      agents,
-      agentName,
-      task,
-      mergedSignal,
+      lc.ctx.cwd,
+      lc.agents,
+      lc.agentName,
+      lc.task,
+      lc.mergedSignal,
       onUpdate,
-      makeDetails,
-      parentModel,
-      parentThinking,
+      lc.makeDetails,
+      lc.parentModel,
+      lc.parentThinking,
     );
-    if (hasSubagentFailed(result)) {
-      handleWorkerFailure(
-        mergedSignal.aborted ? "Aborted" : createSubagentError(result).message,
-        mergedSignal.aborted,
-        makeDetails([result]),
-      );
-    } else {
-      const toolResult: SubagentToolResult = {
-        content: [
-          {
-            type: "text" as const,
-            text: formatSubagentResultForParent(result) || "(no output)",
-          },
-        ],
-        details: makeDetails([result]),
-      };
-      finalizeProgressState(requestId, getFeedbackSummaryText(toolResult));
-      sendSubagentResultMessage(
-        pi,
-        getResultDisplayText(toolResult),
-        sanitizeDetailsForDisplay(toolResult.details, debug),
-      );
-    }
+    return finishLifecycleResult(lc, result);
   } catch (error) {
-    handleWorkerFailure(
+    const abortResult =
+      error instanceof SubagentAbortError ? error.result : undefined;
+    return finishLifecycleFailure(
+      lc,
       error instanceof Error ? error.message : String(error),
-      mergedSignal.aborted,
-      makeDetails([]),
+      abortResult ? lc.makeDetails([abortResult]) : lc.makeDetails([]),
     );
   } finally {
+    clearInterval(timerTick);
     requestProgressRender();
-    removeRunJob(requestId);
+    removeRunJob(lc.requestId);
     if (listRunJobs().length === 0) {
-      const state = getProgressState(requestId);
+      const state = getProgressState(lc.requestId);
       if (state) {
         emitCompletionAlert(state);
       }
@@ -278,23 +341,43 @@ async function runSubagentWorker(
   }
 }
 
-export type StartJobResult =
+type StartJobResult =
   | {
       kind: "started";
       requestId: string;
       instanceName: string;
       makeDetails: DetailsBuilder;
     }
+  | { kind: "completed"; result: SubagentToolResult }
   | { kind: "cancelled"; makeDetails: DetailsBuilder }
   | { kind: "not_found"; makeDetails: DetailsBuilder };
 
-export function formatStartJobStatus(
+type PrepareSubagentJobResult =
+  | {
+      kind: "ready";
+      lc: LifecycleContext;
+      instanceName: string;
+      requestProgressRender: () => void;
+      hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails>;
+    }
+  | { kind: "not_found"; makeDetails: DetailsBuilder }
+  | { kind: "cancelled"; makeDetails: DetailsBuilder }
+  | { kind: "aborted"; makeDetails: DetailsBuilder };
+
+export function formatSubagentToolResult(
   agentName: string,
   result: StartJobResult,
-): string {
-  if (result.kind === "not_found") return `Unknown agent: "${agentName}"`;
-  if (result.kind === "cancelled") return "Canceled";
-  return `Subagent ${agentName} ${result.instanceName} started (job: ${result.requestId})`;
+): SubagentToolResult {
+  if (result.kind === "completed") return result.result;
+  let text: string;
+  if (result.kind === "not_found") text = `Unknown agent: "${agentName}"`;
+  else if (result.kind === "cancelled") text = "Canceled";
+  else
+    text = `Subagent ${agentName} ${result.instanceName} started (job: ${result.requestId})`;
+  return {
+    content: [{ type: "text", text }],
+    details: result.makeDetails([]),
+  };
 }
 
 function needsProjectAgentConfirmation(
@@ -316,14 +399,15 @@ function confirmProjectAgentRun(
   );
 }
 
-export async function startSubagentJob(
+async function prepareSubagentJob(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
   params: Static<typeof SubagentParams>,
   hostSignal: AbortSignal | undefined,
-): Promise<StartJobResult> {
+  hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails>,
+): Promise<PrepareSubagentJobResult> {
   const agentScope: AgentScope = params.agentScope ?? "both";
-  const discovery = getCachedAgentDiscovery(ctx.cwd, agentScope);
+  const discovery = await getCachedAgentDiscovery(ctx.cwd, agentScope);
   const agents = discovery.agents;
   const debug = params.debug === true;
   const makeDetails = createDetailsBuilder(
@@ -344,7 +428,7 @@ export async function startSubagentJob(
     if (!confirmed) return { kind: "cancelled", makeDetails };
   }
   if (requested.source === "project") {
-    const userAgents = discoverAgents(ctx.cwd, "user");
+    const userAgents = await getCachedAgentDiscovery(ctx.cwd, "user");
     const hasUserCollision = userAgents.agents.some(
       (a) => a.name === requested.name,
     );
@@ -387,32 +471,70 @@ export async function startSubagentJob(
     details: { agent: params.agent, instanceName, requestId },
   });
   const requestProgressRender = createProgressRenderRequester(ctx, requestId);
-  setImmediate(() => {
-    if (mergedSignal.aborted) {
-      cancelStartedJob(job, job.cancelReason ?? "Aborted");
-      requestProgressRender();
-      return;
-    }
-    void runSubagentWorker(
+  if (mergedSignal.aborted) {
+    cancelStartedJob(job, job.cancelReason ?? "Aborted");
+    requestProgressRender();
+    return { kind: "aborted", makeDetails: makeStartedDetails };
+  }
+  return {
+    kind: "ready",
+    lc: {
       pi,
       ctx,
+      requestId,
+      job,
+      debug,
+      makeDetails: makeStartedDetails,
+      mergedSignal,
       agents,
-      params.agent,
+      agentName: params.agent,
       task,
-      debug,
       parentModel,
       parentThinking,
-      makeStartedDetails,
-      requestId,
-      job,
-      mergedSignal,
-    );
+      hostOnUpdate,
+    },
+    instanceName,
+    requestProgressRender,
+    hostOnUpdate,
+  };
+}
+
+export async function startSubagentJob(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  params: Static<typeof SubagentParams>,
+  hostSignal: AbortSignal | undefined,
+  hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails>,
+): Promise<StartJobResult> {
+  const prepared = await prepareSubagentJob(
+    pi,
+    ctx,
+    params,
+    hostSignal,
+    hostOnUpdate,
+  );
+  if (prepared.kind !== "ready") {
+    if (prepared.kind === "aborted")
+      return { kind: "cancelled", makeDetails: prepared.makeDetails };
+    return prepared;
+  }
+  const { lc, instanceName, requestProgressRender } = prepared;
+  if (getSubagentDepth() > 0) {
+    const result = await runSubagentLifecycle(lc);
+    return { kind: "completed", result };
+  }
+  setImmediate(() => {
+    if (lc.mergedSignal.aborted) {
+      cancelStartedJob(lc.job, lc.job.cancelReason ?? "Aborted");
+      requestProgressRender();
+      return;
+    }
+    runSubagentLifecycle(lc);
   });
-  if (mergedSignal.aborted) return { kind: "cancelled", makeDetails };
   return {
     kind: "started",
-    requestId,
+    requestId: lc.requestId,
     instanceName,
-    makeDetails: makeStartedDetails,
+    makeDetails: lc.makeDetails,
   };
 }