@mystilleef/pi-subagent 0.5.0 → 0.7.0

package/src/{progress.ts → progress/progress.ts}

@@ -18,19 +18,20 @@
 
 import type { Component } from "@earendil-works/pi-tui";
 import { Box, Text } from "@earendil-works/pi-tui";
+import { formatSubagentTitle, type SubagentTheme } from "../output/ui.js";
 import {
   formatHeaderStats,
   getProgressState,
   type ProgressStatus,
+  renderToolActivityForDisplay,
   STATUS_BG,
   STATUS_COLOR,
   STATUS_ICON,
   type SubagentProgressState,
   type ThemeBg,
 } from "./progress-state.js";
-import { formatSubagentTitle, type SubagentTheme } from "./ui.js";
 
-export { makeToolPreview } from "./normalize.js";
+export { makeToolPreview } from "../output/normalize.js";
 export {
   cancelProgressState,
   clearProgressState,
@@ -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/{result-details.ts → progress/result-details.ts}

@@ -1,19 +1,21 @@
-import { TOOL_RESULT_FAILED_MESSAGE } from "./process.js";
-import {
-  extractProgressFromDetails,
-  getProgressState,
-  patchProgressState,
-} from "./progress.js";
+import { TOOL_RESULT_FAILED_MESSAGE } from "../child/process.js";
 import {
   formatSubagentResultForParent,
   summarizeFeedbackUiFinalOutput,
-} from "./summary.js";
+} from "../output/summary.js";
 import type {
   SingleResult,
   SubagentDetails,
   SubagentToolResult,
-} from "./types.js";
-import { detectMessageError } from "./utils.js";
+  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 {
   return (
@@ -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/instance-name.ts

@@ -0,0 +1,117 @@
+const DEFAULT_ADJECTIVES = [
+  "able",
+  "agile",
+  "alert",
+  "amber",
+  "ample",
+  "apt",
+  "arctic",
+  "avid",
+  "bold",
+  "brave",
+  "bright",
+  "brisk",
+  "calm",
+  "clever",
+  "cosmic",
+  "crisp",
+  "daring",
+  "dawn",
+  "eager",
+  "early",
+  "fair",
+  "fast",
+  "fierce",
+  "fine",
+  "fresh",
+  "gentle",
+  "golden",
+  "grand",
+  "happy",
+  "honest",
+  "jolly",
+  "keen",
+  "kind",
+  "lively",
+  "lucky",
+  "merry",
+  "mighty",
+  "nimble",
+  "noble",
+  "novel",
+  "patient",
+  "proud",
+  "quick",
+  "quiet",
+  "rapid",
+  "ready",
+  "sharp",
+  "smart",
+  "solid",
+  "steady",
+  "swift",
+  "tidy",
+  "vivid",
+  "warm",
+  "wise",
+] as const;
+
+const DEFAULT_NOUNS = [
+  "badger",
+  "beacon",
+  "bison",
+  "brook",
+  "cedar",
+  "comet",
+  "coral",
+  "coyote",
+  "crane",
+  "dolphin",
+  "eagle",
+  "ember",
+  "falcon",
+  "finch",
+  "forest",
+  "fox",
+  "gecko",
+  "glade",
+  "harbor",
+  "hawk",
+  "heron",
+  "island",
+  "jaguar",
+  "koala",
+  "lagoon",
+  "lemur",
+  "lynx",
+  "maple",
+  "meadow",
+  "otter",
+  "panda",
+  "panther",
+  "pelican",
+  "phoenix",
+  "puma",
+  "raven",
+  "reef",
+  "river",
+  "salmon",
+  "sparrow",
+  "summit",
+  "tiger",
+  "valley",
+  "violet",
+  "walrus",
+  "willow",
+  "wolf",
+  "wren",
+  "yak",
+  "zephyr",
+] as const;
+
+export function generateSubagentInstanceName(): string {
+  const adj =
+    DEFAULT_ADJECTIVES[Math.floor(Math.random() * DEFAULT_ADJECTIVES.length)];
+  const noun = DEFAULT_NOUNS[Math.floor(Math.random() * DEFAULT_NOUNS.length)];
+  return `${adj}-${noun}`;
+}

package/src/{types.ts → shared/types.ts}

@@ -1,6 +1,6 @@
 import type { Message } from "@earendil-works/pi-ai";
-import type { AgentScope } from "./agents.js";
-import type { TerminationMetadata } from "./termination.js";
+import type { AgentScope } from "../agent/agents.js";
+import type { TerminationMetadata } from "../child/termination.js";
 
 export interface UsageStats {
   input: number;
@@ -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 {
@@ -40,6 +49,7 @@ export interface SingleResult {
   progress?: StreamingProgress;
   messages?: Message[];
   termination?: TerminationMetadata;
+  thinkingWarning?: string;
 }
 
 export interface SubagentDetails {
@@ -47,6 +57,7 @@ export interface SubagentDetails {
   agentScope: AgentScope;
   projectAgentsDir: string | null;
   results: SingleResult[];
+  renderedByMessage?: true;
 }
 
 export interface SubagentToolResult {

package/src/{utils.ts → shared/utils.ts}

@@ -5,7 +5,6 @@ import type { Message } from "@earendil-works/pi-ai";
 import {
   DefaultResourceLoader,
   getAgentDir,
-  withFileMutationQueue,
 } from "@earendil-works/pi-coding-agent";
 
 export const DEFAULT_MAX_OUTPUT_BYTES = 50_000;
@@ -66,11 +65,10 @@ export async function writePromptToTempFile(
   );
   const safeName = agentName.replace(/[^\w.-]+/g, "_");
   const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
-  await withFileMutationQueue(filePath, async () => {
-    await fs.promises.writeFile(filePath, prompt, {
-      encoding: "utf-8",
-      mode: 0o600,
-    });
+  // mkdtemp guarantees a unique directory per call; no concurrent writer can hold this path.
+  await fs.promises.writeFile(filePath, prompt, {
+    encoding: "utf-8",
+    mode: 0o600,
   });
   return { dir: tmpDir, filePath };
 }

package/src/agent-cache.ts

@@ -1,41 +0,0 @@
-import path from "node:path";
-import {
-  type AgentDiscoveryResult,
-  type AgentScope,
-  discoverAgents,
-} from "./agents.js";
-
-export type AgentDiscoveryCacheEntry = AgentDiscoveryResult & { ts: number };
-export type AgentDiscoveryCache = Map<string, AgentDiscoveryCacheEntry>;
-export const AGENT_DISCOVERY_CACHE_TTL_MS = 3_000;
-const sharedAgentDiscoveryCache: AgentDiscoveryCache = new Map();
-
-export function resetAgentDiscoveryCache(): void {
-  sharedAgentDiscoveryCache.clear();
-}
-
-export function getCachedAgentDiscovery(
-  cwd: string,
-  scope: AgentScope,
-  cache: AgentDiscoveryCache = sharedAgentDiscoveryCache,
-  cacheTtlMs = AGENT_DISCOVERY_CACHE_TTL_MS,
-): AgentDiscoveryCacheEntry {
-  const key = `${path.resolve(cwd)}\0${scope}`;
-  const now = Date.now();
-  const entry = cache.get(key);
-  if (entry && now - entry.ts <= cacheTtlMs) return entry;
-  const nextEntry = { ...discoverAgents(cwd, scope), ts: now };
-  cache.set(key, nextEntry);
-  return nextEntry;
-}
-
-export function getCachedAgentCompletions(
-  prefix: string,
-  cwd = process.cwd(),
-  cache: AgentDiscoveryCache = sharedAgentDiscoveryCache,
-  cacheTtlMs = AGENT_DISCOVERY_CACHE_TTL_MS,
-): { value: string; label: string }[] {
-  return getCachedAgentDiscovery(cwd, "both", cache, cacheTtlMs)
-    .agents.filter((agent) => agent.name.startsWith(prefix))
-    .map((agent) => ({ value: agent.name, label: agent.name }));
-}

package/src/agents.ts

@@ -1,178 +0,0 @@
-/**
- * Agent discovery and configuration
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-
-export type AgentScope = "user" | "project" | "both";
-
-export type ThinkingLevel =
-  | "off"
-  | "minimal"
-  | "low"
-  | "medium"
-  | "high"
-  | "xhigh";
-
-const THINKING_LEVELS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-] as const;
-
-export interface AgentConfig {
-  name: string;
-  description: string;
-  tools?: string[];
-  skills?: string[];
-  thinking?: ThinkingLevel;
-  systemPrompt: string;
-  source: "user" | "project";
-  filePath: string;
-}
-
-export interface AgentDiscoveryResult {
-  agents: AgentConfig[];
-  projectAgentsDir: string | null;
-}
-
-function parseCommaList(raw: unknown): string[] | undefined {
-  if (typeof raw !== "string") return undefined;
-  const items = raw
-    .split(",")
-    .map((s) => s.trim())
-    .filter(Boolean);
-  return items.length > 0 ? items : undefined;
-}
-
-function parseThinkingLevel(raw: unknown): ThinkingLevel | undefined {
-  if (typeof raw !== "string") return undefined;
-  const normalized = raw.trim().toLowerCase();
-  return (THINKING_LEVELS as readonly string[]).includes(normalized)
-    ? (normalized as ThinkingLevel)
-    : undefined;
-}
-
-function loadAgentsFromDir(
-  dir: string,
-  source: "user" | "project",
-): AgentConfig[] {
-  const agents: AgentConfig[] = [];
-  if (!fs.existsSync(dir)) {
-    return agents;
-  }
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return agents;
-  }
-  for (const entry of entries) {
-    if (!entry.name.endsWith(".md")) continue;
-    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-    const filePath = path.join(dir, entry.name);
-    let content: string;
-    try {
-      content = fs.readFileSync(filePath, "utf-8");
-    } catch {
-      continue;
-    }
-    let parsed: ReturnType<typeof parseFrontmatter<Record<string, unknown>>>;
-    try {
-      parsed = parseFrontmatter<Record<string, unknown>>(content);
-    } catch {
-      continue;
-    }
-    const { frontmatter, body } = parsed;
-    if (
-      typeof frontmatter !== "object" ||
-      frontmatter === null ||
-      Array.isArray(frontmatter)
-    )
-      continue;
-    const {
-      name,
-      description,
-      tools: rawTools,
-      skills: rawSkills,
-      thinking: rawThinking,
-    } = frontmatter;
-    if (typeof name !== "string" || typeof description !== "string") continue;
-    if (rawTools != null && typeof rawTools !== "string") continue;
-    if (rawSkills != null && typeof rawSkills !== "string") continue;
-    if (rawThinking != null && typeof rawThinking !== "string") continue;
-    const tools = parseCommaList(rawTools);
-    const skills = Object.hasOwn(frontmatter, "skills")
-      ? (parseCommaList(rawSkills) ?? [])
-      : undefined;
-    const thinking = parseThinkingLevel(rawThinking);
-    agents.push({
-      name,
-      description,
-      tools,
-      skills,
-      thinking,
-      systemPrompt: body,
-      source,
-      filePath,
-    });
-  }
-  return agents;
-}
-
-function isDirectory(p: string): boolean {
-  try {
-    return fs.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-function findNearestProjectAgentsDir(cwd: string): string | null {
-  let currentDir = cwd;
-  while (true) {
-    const candidate = path.join(currentDir, ".pi", "agents");
-    if (isDirectory(candidate)) return candidate;
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) return null;
-    currentDir = parentDir;
-  }
-}
-
-export function discoverAgents(
-  cwd: string,
-  scope: AgentScope,
-): AgentDiscoveryResult {
-  const userDir = path.join(getAgentDir(), "agents");
-  const projectAgentsDir = findNearestProjectAgentsDir(cwd);
-  const userAgents =
-    scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
-  const projectAgents =
-    scope === "user" || !projectAgentsDir
-      ? []
-      : loadAgentsFromDir(projectAgentsDir, "project");
-  const agentMap = new Map<string, AgentConfig>();
-  for (const agent of userAgents) agentMap.set(agent.name, agent);
-  for (const agent of projectAgents) agentMap.set(agent.name, agent);
-  return { agents: Array.from(agentMap.values()), projectAgentsDir };
-}
-
-export function formatAgentList(
-  agents: AgentConfig[],
-  maxItems: number,
-): { text: string; remaining: number } {
-  if (agents.length === 0) return { text: "none", remaining: 0 };
-  const listed = agents.slice(0, maxItems);
-  const remaining = agents.length - listed.length;
-  return {
-    text: listed
-      .map((a) => `${a.name} (${a.source}): ${a.description}`)
-      .join("; "),
-    remaining,
-  };
-}

package/src/child-events.ts

@@ -1,32 +0,0 @@
-type ChildKnownEvent =
-  | { type: "message_end"; message: unknown }
-  | { type: "tool_result_end"; message: unknown }
-  | { type: "agent_end"; messages?: unknown; stopReason?: string };
-
-export type ChildEventParseResult =
-  | { kind: "known"; event: ChildKnownEvent }
-  | { kind: "unknown"; event: unknown }
-  | { kind: "invalid"; line: string };
-
-const KNOWN_TYPES = new Set(["message_end", "tool_result_end", "agent_end"]);
-
-export function parseChildEventLine(line: string): ChildEventParseResult {
-  if (typeof line !== "string" || !line.trim())
-    return { kind: "invalid", line };
-  let event: unknown;
-  try {
-    event = JSON.parse(line);
-  } catch {
-    return { kind: "invalid", line };
-  }
-  if (
-    typeof event === "object" &&
-    event !== null &&
-    "type" in event &&
-    typeof (event as Record<string, unknown>).type === "string" &&
-    KNOWN_TYPES.has((event as Record<string, unknown>).type as string)
-  ) {
-    return { kind: "known", event: event as ChildKnownEvent };
-  }
-  return { kind: "unknown", event };
-}