@mystilleef/pi-subagent 0.6.0 → 0.8.0

package/src/progress/progress-state.ts

@@ -3,12 +3,18 @@ import {
   isStatusOnlyFailure,
   isStatusOnlySuccess,
   makeToolPreview,
+  normalizeAndTruncate,
   normalizeSummaryValue,
   normalizeTerminalSentence,
-  TOOL_PREVIEW_MAX_CHARS,
   truncateText,
 } from "../output/normalize.js";
-import type { SubagentDetails } from "../shared/types.js";
+import type {
+  SingleResult,
+  SubagentDetails,
+  ToolActivity,
+} from "../shared/types.js";
+
+export const SENSITIVE_PATTERN = /secret|token|password/i;
 
 export type ThemeBg = "toolPendingBg" | "toolSuccessBg" | "toolErrorBg";
 
@@ -43,7 +49,9 @@ export interface SubagentProgressState {
   status: ProgressStatus;
   startTime: number;
   durationMs?: number;
+  activeToolActivity?: ToolActivity;
   lastToolPreview?: string;
+  toolResultCompleted?: boolean;
   toolCount: number;
   inputTokens?: number;
   outputTokens?: number;
@@ -59,7 +67,7 @@ export function createProgressState(
   requestId: string,
   agent: string,
   task: string,
-  instanceName = requestId,
+  instanceName?: string,
 ): void {
   store.set(requestId, {
     requestId,
@@ -91,7 +99,9 @@ export function patchProgressState(
     store.set(requestId, {
       ...state,
       ...patch,
+      activeToolActivity: undefined,
       lastToolPreview: undefined,
+      toolResultCompleted: undefined,
     });
     return;
   }
@@ -115,7 +125,9 @@ export function finalizeProgressState(
   storeTerminalProgressState(requestId, {
     status: "success",
     finalOutput: makeProgressFinalOutput(finalOutput),
+    activeToolActivity: undefined,
     lastToolPreview: undefined,
+    toolResultCompleted: undefined,
   });
 }
 
@@ -124,14 +136,18 @@ export function failProgressState(requestId: string, errorText: string): void {
   storeTerminalProgressState(requestId, {
     status: "error",
     errorText: sentence,
+    activeToolActivity: undefined,
     lastToolPreview: undefined,
+    toolResultCompleted: undefined,
   });
 }
 
 export function cancelProgressState(requestId: string, reason?: string): void {
   storeTerminalProgressState(requestId, {
     status: "cancelled",
+    activeToolActivity: undefined,
     lastToolPreview: undefined,
+    toolResultCompleted: undefined,
     ...(reason !== undefined
       ? { errorText: normalizeTerminalSentence(reason) }
       : {}),
@@ -198,53 +214,110 @@ function isMeaningfulProgressErrorLine(line: string): boolean {
 
 export interface DetailsProgress {
   lastToolPreview?: string;
+  activityText?: string;
+  activeToolActivity?: ToolActivity;
+  progressLastToolPreview?: string;
+  toolResultCompleted?: boolean;
   newToolCallIds: string[];
 }
 
+function trackNewToolCall(
+  id: string,
+  preview: string,
+  seenToolCallIds: Set<string>,
+  state: DetailsProgress,
+): void {
+  if (seenToolCallIds.has(id)) return;
+  seenToolCallIds.add(id);
+  state.newToolCallIds.push(id);
+  state.lastToolPreview = preview;
+}
+
+function extractProgressFromExistingProgress(
+  progress: {
+    activityText?: string;
+    activeToolActivity?: ToolActivity;
+    lastToolPreview?: string;
+    toolCalls: { id: string; preview: string }[];
+    toolResultCompleted?: boolean;
+  },
+  seenToolCallIds: Set<string>,
+  state: DetailsProgress,
+): void {
+  if (
+    typeof progress.activityText === "string" &&
+    progress.activityText.trim()
+  ) {
+    state.activityText = normalizeAndTruncate(progress.activityText);
+  }
+  if (progress.activeToolActivity) {
+    state.activeToolActivity = progress.activeToolActivity;
+  }
+  if (
+    typeof progress.lastToolPreview === "string" &&
+    progress.lastToolPreview.trim()
+  ) {
+    state.progressLastToolPreview = normalizeAndTruncate(
+      progress.lastToolPreview,
+    );
+  }
+  if (progress.toolResultCompleted) {
+    state.toolResultCompleted = true;
+  }
+  for (const toolCall of progress.toolCalls) {
+    if (!isDerivedToolCall(toolCall)) continue;
+    const preview = normalizeAndTruncate(toolCall.preview);
+    trackNewToolCall(toolCall.id, preview, seenToolCallIds, state);
+  }
+}
+
+function extractProgressFromMessages(
+  messages: SingleResult["messages"] = [],
+  seenToolCallIds: Set<string>,
+  state: DetailsProgress,
+): void {
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (isToolCallPart(part)) {
+        const preview = makeToolPreview(part.name, part.arguments);
+        trackNewToolCall(part.id, preview, seenToolCallIds, state);
+      }
+    }
+  }
+}
+
 export function extractProgressFromDetails(
   details: SubagentDetails,
   seenToolCallIds: Set<string>,
 ): DetailsProgress {
-  const newToolCallIds: string[] = [];
-  let lastToolPreview: string | undefined;
+  const state: DetailsProgress = { newToolCallIds: [] };
   const results = Array.isArray(details.results) ? details.results : [];
   for (const result of results) {
     if (result.progress) {
-      for (const toolCall of result.progress.toolCalls) {
-        if (!isDerivedToolCall(toolCall)) continue;
-        lastToolPreview = truncateText(
-          normalizeSummaryValue(toolCall.preview),
-          TOOL_PREVIEW_MAX_CHARS,
-        );
-        if (seenToolCallIds.has(toolCall.id)) continue;
-        seenToolCallIds.add(toolCall.id);
-        newToolCallIds.push(toolCall.id);
-      }
+      extractProgressFromExistingProgress(
+        result.progress,
+        seenToolCallIds,
+        state,
+      );
       continue;
     }
     const messages = Array.isArray(result.messages) ? result.messages : [];
-    for (const msg of messages) {
-      if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-      for (const part of msg.content) {
-        if (isToolCallPart(part)) {
-          lastToolPreview = makeToolPreview(part.name, part.arguments);
-          if (seenToolCallIds.has(part.id)) continue;
-          seenToolCallIds.add(part.id);
-          newToolCallIds.push(part.id);
-        }
-      }
-    }
+    extractProgressFromMessages(messages, seenToolCallIds, state);
   }
-  return { lastToolPreview, newToolCallIds };
+  return state;
+}
+
+function isObjectWith(part: unknown): part is Record<string, unknown> {
+  return typeof part === "object" && part !== null;
 }
 
 function isDerivedToolCall(part: unknown): part is {
   id: string;
   preview: string;
 } {
-  if (typeof part !== "object" || part === null) return false;
-  const maybe = part as { id?: unknown; preview?: unknown };
-  return typeof maybe.id === "string" && typeof maybe.preview === "string";
+  if (!isObjectWith(part)) return false;
+  return typeof part.id === "string" && typeof part.preview === "string";
 }
 
 export function isToolCallPart(part: unknown): part is {
@@ -253,12 +326,11 @@ export function isToolCallPart(part: unknown): part is {
   name: string;
   arguments?: Record<string, unknown>;
 } {
-  if (typeof part !== "object" || part === null) return false;
-  const maybe = part as { type?: unknown; id?: unknown; name?: unknown };
+  if (!isObjectWith(part)) return false;
   return (
-    maybe.type === "toolCall" &&
-    typeof maybe.id === "string" &&
-    typeof maybe.name === "string"
+    part.type === "toolCall" &&
+    typeof part.id === "string" &&
+    typeof part.name === "string"
   );
 }
 
@@ -274,22 +346,6 @@ export function formatElapsed(ms: number): string {
   return `${mins}m ${secs}s`;
 }
 
-/**
- * Format a raw token count for compact inline display.
- * Values below 1000 rendered as-is. Larger counts use `k`
- * or `M` suffixes with one decimal place, stripping trailing `.0`.
- */
-export function formatTokenCount(count: number): string {
-  if (count < 1000) return String(count);
-  const unit = count >= 1_000_000 ? "M" : "k";
-  const divisor = count >= 1_000_000 ? 1_000_000 : 1000;
-  return `${trimTrailingZero((count / divisor).toFixed(1))}${unit}`;
-}
-
-function trimTrailingZero(value: string): string {
-  return value.endsWith(".0") ? value.slice(0, -2) : value;
-}
-
 export function formatContextPercent(state: SubagentProgressState): string {
   const d = state.contextWindowTokens;
   if (!d || d <= 0 || !Number.isFinite(d)) return "--%";
@@ -311,3 +367,59 @@ export function formatHeaderStats(state: SubagentProgressState): string {
   const toolLabel = state.toolCount === 1 ? "tool" : "tools";
   return `${state.toolCount} ${toolLabel} · ${formatContextPercent(state)} ctx · ${formatElapsed(elapsedMs)}\n`;
 }
+
+const REDACTED_PLACEHOLDER = "(running...)";
+const REDACTED_PLACEHOLDER_LENGTH = REDACTED_PLACEHOLDER.length;
+
+function redactOrTruncate(text: string, maxChars: number): string {
+  if (SENSITIVE_PATTERN.test(text))
+    return maxChars >= REDACTED_PLACEHOLDER_LENGTH ? REDACTED_PLACEHOLDER : "";
+  return truncateText(text, maxChars);
+}
+
+function walkActivityTree(activity: ToolActivity): string[] {
+  const parts: string[] = [];
+  let current: ToolActivity | undefined = activity;
+  while (current) {
+    if (current.inputSummary) {
+      const annotated = current.instanceName
+        ? `${current.inputSummary} [${current.instanceName}]`
+        : current.inputSummary;
+      parts.push(annotated);
+    }
+    current = current.child;
+  }
+  return parts;
+}
+
+/**
+ * Renders a ToolActivity tree for storage. Each segment is
+ * independently normalized and truncated to TOOL_PREVIEW_MAX_CHARS (120).
+ */
+export function renderToolActivity(
+  activity: ToolActivity | undefined,
+): string | undefined {
+  if (!activity) return undefined;
+  const parts = walkActivityTree(activity);
+  if (parts.length === 0) return activity.toolName;
+  const result = parts.map((p) => normalizeAndTruncate(p)).join(" - ");
+  if (SENSITIVE_PATTERN.test(result)) return REDACTED_PLACEHOLDER;
+  return result;
+}
+
+/**
+ * Renders a ToolActivity tree for display with a caller-provided truncation
+ * budget. Segments are normalized without individual truncation so the
+ * joined result shares one post-join display budget.
+ */
+export function renderToolActivityForDisplay(
+  activity: ToolActivity | undefined,
+  maxChars: number,
+): string | undefined {
+  if (!activity) return undefined;
+  if (maxChars <= 0) return "";
+  const parts = walkActivityTree(activity);
+  if (parts.length === 0) return redactOrTruncate(activity.toolName, maxChars);
+  const joined = parts.map((p) => normalizeSummaryValue(p)).join(" - ");
+  return redactOrTruncate(joined, maxChars);
+}

package/src/progress/progress.ts

@@ -23,6 +23,7 @@ import {
   formatHeaderStats,
   getProgressState,
   type ProgressStatus,
+  renderToolActivityForDisplay,
   STATUS_BG,
   STATUS_COLOR,
   STATUS_ICON,
@@ -41,11 +42,12 @@ export {
   formatContextPercent,
   formatElapsed,
   formatHeaderStats,
-  formatTokenCount,
   getProgressState,
   makeTaskPreview,
   type ProgressStatus,
   patchProgressState,
+  renderToolActivity,
+  renderToolActivityForDisplay,
   resetProgressStore,
   STATUS_COLOR,
   STATUS_ICON,
@@ -96,7 +98,9 @@ class DynamicSubagentProgressText implements Component {
   render(width: number): string[] {
     const state = getProgressState(this.requestId);
     if (!state) return [];
-    return renderProgressBox(state, this.options, this.theme).render(width);
+    return renderProgressBox(state, this.options, this.theme, width).render(
+      width,
+    );
   }
 }
 
@@ -108,6 +112,7 @@ function renderProgressBox(
   state: SubagentProgressState,
   options: { expanded: boolean },
   theme: SubagentTheme,
+  width: number,
 ): Box {
   const status = state.status;
   const title = formatSubagentTitle(state.agent, state.instanceName, theme);
@@ -116,28 +121,19 @@ function renderProgressBox(
     theme.bg(getProgressBackground(status), line),
   );
   box.addChild(new Text(header, 0, 0));
-  addProgressBody(box, state, options, theme);
-  return box;
-}
-
-function addProgressBody(
-  box: Box,
-  state: SubagentProgressState,
-  options: { expanded: boolean },
-  theme: SubagentTheme,
-): void {
-  const body = makeProgressBody(state, options, theme);
-  if (body.length === 0) return;
+  const body = makeProgressBody(state, options, theme, width);
   for (const line of body) box.addChild(line);
+  return box;
 }
 
 function makeProgressBody(
   state: SubagentProgressState,
   options: { expanded: boolean },
   theme: SubagentTheme,
+  width: number,
 ): Text[] {
   if (state.status === "running")
-    return makeRunningProgressBody(state, options, theme);
+    return makeRunningProgressBody(state, options, theme, width);
   if (state.status === "error" || state.status === "cancelled") {
     return makeStoppedProgressBody(state, options, theme);
   }
@@ -150,12 +146,16 @@ function makeRunningProgressBody(
   state: SubagentProgressState,
   options: { expanded: boolean },
   theme: SubagentTheme,
+  width: number,
 ): Text[] {
   const body: Text[] = [];
-  if (state.lastToolPreview) {
-    body.push(
-      new Text(formatRunningToolPreview(state.lastToolPreview, theme), 2, 0),
-    );
+  const activityBudget = Math.max(0, width - 8);
+  const activityPreview = renderToolActivityForDisplay(
+    state.activeToolActivity,
+    activityBudget,
+  );
+  if (activityPreview) {
+    body.push(new Text(formatRunningToolPreview(activityPreview, theme), 2, 0));
   }
   if (options.expanded)
     body.push(new Text(theme.fg("dim", state.taskPreview), 2, 0));

package/src/progress/result-details.ts

@@ -7,12 +7,14 @@ import type {
   SingleResult,
   SubagentDetails,
   SubagentToolResult,
+  ToolActivity,
 } from "../shared/types.js";
 import { detectMessageError } from "../shared/utils.js";
 import {
   extractProgressFromDetails,
   getProgressState,
   patchProgressState,
+  renderToolActivity,
 } from "./progress.js";
 
 export function hasSubagentFailed(result: SingleResult): boolean {
@@ -53,22 +55,56 @@ export function sanitizeDetailsForDisplay(
   };
 }
 
+export function getLatestResult(
+  details: SubagentDetails,
+): SingleResult | undefined {
+  return details.results[0];
+}
+
 export function patchProgressFromDetails(
   requestId: string,
   details: SubagentDetails,
   seenToolCallIds: Set<string>,
 ): void {
-  const latestResult = details.results[0];
-  const { newToolCallIds, lastToolPreview } = extractProgressFromDetails(
-    details,
-    seenToolCallIds,
-  );
+  const latestResult = getLatestResult(details);
+  const {
+    newToolCallIds,
+    lastToolPreview,
+    activityText,
+    activeToolActivity,
+    toolResultCompleted,
+  } = extractProgressFromDetails(details, seenToolCallIds);
   const current = getProgressState(requestId);
   if (!current) return;
   const patch: Record<string, unknown> = {
     toolCount: current.toolCount + newToolCallIds.length,
   };
-  if (lastToolPreview) patch.lastToolPreview = lastToolPreview;
+  let nextActivity: ToolActivity | undefined;
+  if (newToolCallIds.length > 0 && lastToolPreview) {
+    nextActivity = { toolName: "tool", inputSummary: lastToolPreview };
+  } else if (activeToolActivity) {
+    nextActivity = activeToolActivity;
+  } else if (activityText) {
+    nextActivity = { toolName: "tool", inputSummary: activityText };
+  } else if (current.activeToolActivity) {
+    nextActivity = current.activeToolActivity;
+  }
+  if (toolResultCompleted && nextActivity?.child) {
+    nextActivity = { ...nextActivity, child: undefined };
+  } else if (toolResultCompleted) {
+    nextActivity = undefined;
+  }
+  patch.activeToolActivity = nextActivity;
+  const renderedPreview = renderToolActivity(nextActivity);
+  if (renderedPreview) {
+    patch.lastToolPreview = renderedPreview;
+  } else if (toolResultCompleted && !nextActivity) {
+    patch.lastToolPreview = undefined;
+  }
+  if (toolResultCompleted) {
+    patch.toolResultCompleted = true;
+  }
+  // Token accounting always applies when usage data is available
   if (latestResult?.usage) {
     patch.inputTokens = latestResult.usage.input;
     patch.outputTokens = latestResult.usage.output;
@@ -86,11 +122,13 @@ export function getSubagentText(result: SubagentToolResult): string {
 }
 
 export function getResultDisplayText(result: SubagentToolResult): string {
-  return result.details.results[0]?.finalOutput ?? getSubagentText(result);
+  return (
+    getLatestResult(result.details)?.finalOutput ?? getSubagentText(result)
+  );
 }
 
 export function getFeedbackSummaryText(result: SubagentToolResult): string {
-  const rawFinalOutput = result.details.results[0]?.finalOutput;
+  const rawFinalOutput = getLatestResult(result.details)?.finalOutput;
   if (rawFinalOutput?.trim())
     return summarizeFeedbackUiFinalOutput(rawFinalOutput);
   return getSubagentText(result).trim() || "(no output)";

package/src/shared/types.ts

@@ -13,6 +13,13 @@ export interface UsageStats {
   turns: number;
 }
 
+export interface ToolActivity {
+  toolName: string;
+  inputSummary?: string;
+  instanceName?: string;
+  child?: ToolActivity;
+}
+
 export interface StreamingProgressToolCall {
   id: string;
   preview: string;
@@ -20,8 +27,10 @@ export interface StreamingProgressToolCall {
 
 export interface StreamingProgress {
   activityText?: string;
+  activeToolActivity?: ToolActivity;
   toolCalls: StreamingProgressToolCall[];
   lastToolPreview?: string;
+  toolResultCompleted?: boolean;
 }
 
 export interface SingleResult {
@@ -48,6 +57,7 @@ export interface SubagentDetails {
   agentScope: AgentScope;
   projectAgentsDir: string | null;
   results: SingleResult[];
+  renderedByMessage?: true;
 }
 
 export interface SubagentToolResult {

package/src/shared/utils.ts

@@ -89,15 +89,54 @@ export function getPiInvocation(args: string[]): {
   return { command: "pi", args };
 }
 
+const SKILL_DISCOVERY_CACHE_TTL_MS = 300_000;
+
+type ResolvedSkillArgsCacheEntry = {
+  skillPaths: Map<string, string>;
+  ts: number;
+};
+
+const resolvedSkillArgsCache = new Map<string, ResolvedSkillArgsCacheEntry>();
+
+async function canonicalPath(filePath: string): Promise<string> {
+  try {
+    return await fs.promises.realpath(filePath);
+  } catch {
+    return path.resolve(filePath);
+  }
+}
+
+function buildSkillArgs(
+  requested: string[],
+  skillPaths: Map<string, string>,
+): string[] {
+  return requested.flatMap((name) => ["--skill", skillPaths.get(name) ?? name]);
+}
+
+export function resetResolvedAgentSkillArgsCache(): void {
+  resolvedSkillArgsCache.clear();
+}
+
 export async function resolveAgentSkillArgs(
   cwd: string,
   skillNames: string[],
 ): Promise<{ args: string[] } | { error: string }> {
   const requested = Array.from(new Set(skillNames));
   if (requested.length === 0) return { args: [] };
+  const cacheIdentitySkills = [...requested].sort();
+  const agentDir = getAgentDir();
+  const cacheKey = JSON.stringify({
+    cwd: await canonicalPath(cwd),
+    agentDir: await canonicalPath(agentDir),
+    skills: cacheIdentitySkills,
+  });
+  const cached = resolvedSkillArgsCache.get(cacheKey);
+  if (cached && Date.now() - cached.ts <= SKILL_DISCOVERY_CACHE_TTL_MS) {
+    return { args: buildSkillArgs(requested, cached.skillPaths) };
+  }
   const loader = new DefaultResourceLoader({
     cwd,
-    agentDir: getAgentDir(),
+    agentDir,
     noContextFiles: true,
     noPromptTemplates: true,
     noThemes: true,
@@ -124,12 +163,12 @@ export async function resolveAgentSkillArgs(
         .join(", ")}. Available skills: ${available}.`,
     };
   }
-  return {
-    args: requested.flatMap((name) => [
-      "--skill",
-      skillMap.get(name)?.filePath ?? name,
-    ]),
-  };
+  const skillPaths = new Map(
+    requested.map((name) => [name, skillMap.get(name)?.filePath ?? name]),
+  );
+  const args = buildSkillArgs(requested, skillPaths);
+  resolvedSkillArgsCache.set(cacheKey, { skillPaths, ts: Date.now() });
+  return { args };
 }
 
 export function getSubagentDepth(): number {