@mystilleef/pi-subagent 0.5.0 → 0.7.0

package/src/{normalize.ts → output/normalize.ts}

@@ -7,56 +7,37 @@ export function normalizeSummaryValue(value: string): string {
   return normalized;
 }
 
+const SECRET_KEY_RE = /secret|token|password|passwd|credential|auth/i;
+const JWT_RE = /^eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+
 export function extractSemanticToolTarget(
-  toolName: string,
   args: Record<string, unknown>,
   forceJson = false,
 ): string {
   if (forceJson) return JSON.stringify(args);
-  if (toolName === "bash" && typeof args.command === "string")
-    return args.command;
-  if (
-    ["read", "write", "edit", "file_search"].includes(toolName) &&
-    typeof args.path === "string"
-  )
-    return args.path;
-  if (toolName === "subagent") {
-    const parts = [];
-    if (typeof args.agent === "string") parts.push(args.agent);
-    if (typeof args.task === "string")
-      parts.push(normalizeSummaryValue(args.task));
-    if (typeof args.agentScope === "string") parts.push(`[${args.agentScope}]`);
-    if (parts.length) return parts.join(" ");
-    return JSON.stringify(args);
+  const semanticKeys = [
+    "command",
+    "path",
+    "agent",
+    "query",
+    "url",
+    "action",
+    "name",
+  ];
+  for (const key of semanticKeys) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  for (const key of Object.keys(args)) {
+    const value = args[key];
+    if (typeof value !== "string" || !value.trim()) continue;
+    if (SECRET_KEY_RE.test(key)) continue;
+    if (value.length > 60 || JWT_RE.test(value)) continue;
+    return value;
   }
   return "";
 }
 
-export function isTranscriptNoiseLine(line: string): boolean {
-  return /^(?:(?:hello|hi|hey)(?:[!,.?:;]+|\s|$)|reasoning:|raw log:|apolog(?:y|ies)|sorry\b)/i.test(
-    line,
-  );
-}
-
-export function isFailureDiagnosticLine(line: string): boolean {
-  return /^(?:at\s+|error:|failed:|failure:|exception:|traceback\b|caused by:)/i.test(
-    line,
-  );
-}
-
-export function filterOutputLines(output: string): string[] {
-  return output
-    .split(/\r?\n/)
-    .map((l) => l.trim())
-    .filter(
-      (l) => l && !isTranscriptNoiseLine(l) && !isFailureDiagnosticLine(l),
-    );
-}
-
-export function stripTerminalStatusPrefixes(value: string): string {
-  return value.replace(/^(?:(?:success|failure):\s*)+/i, "");
-}
-
 export function truncateText(text: string, limit: number): string {
   if (text.length <= limit) return text;
   return `${text.slice(0, limit - 1)}…`;
@@ -72,7 +53,10 @@ export function normalizeTerminalSentence(
     .replace(/^\s*`{1,3}([^`]+)`{1,3}\s*$/, "$1")
     .replace(/^\s*\*\*([^*]+)\*\*\s*$/, "$1")
     .replace(/^\s*__([^_]+)__\s*$/, "$1");
-  const withoutStatusPrefix = stripTerminalStatusPrefixes(unwrapped);
+  const withoutStatusPrefix = unwrapped.replace(
+    /^(?:(?:success|failure):\s*)+/i,
+    "",
+  );
   const withoutLabel = withoutStatusPrefix.replace(
     /^\s*(?:status|summary|result|output|message|error|check|outcome|project summary):\s+/i,
     "",
@@ -85,19 +69,21 @@ export function normalizeTerminalSentence(
 
 export const TOOL_PREVIEW_MAX_CHARS = 120;
 
+export function normalizeAndTruncate(
+  text: string,
+  limit = TOOL_PREVIEW_MAX_CHARS,
+): string {
+  return truncateText(normalizeSummaryValue(text), limit);
+}
+
 export function makeToolPreview(
   toolName: string,
   args: Record<string, unknown> | undefined,
 ): string {
   if (!args || Object.keys(args).length === 0) return toolName;
-  const target = normalizeSummaryValue(
-    extractSemanticToolTarget(toolName, args),
-  );
+  const target = normalizeSummaryValue(extractSemanticToolTarget(args));
   if (!target) return toolName;
-  return truncateText(
-    normalizeSummaryValue(`${toolName}: ${target}`),
-    TOOL_PREVIEW_MAX_CHARS,
-  );
+  return normalizeAndTruncate(`${toolName}: ${target}`);
 }
 
 export function isStatusOnlySuccess(value: string): boolean {

package/src/{summary.ts → output/summary.ts}

@@ -1,5 +1,5 @@
+import type { SingleResult } from "../shared/types.js";
 import { normalizeTerminalSentence } from "./normalize.js";
-import type { SingleResult } from "./types.js";
 
 export const FEEDBACK_UI_SUMMARY_MAX_CHARS = 120;
 
@@ -20,7 +20,9 @@ const FEEDBACK_UI_LABEL_PATTERN =
   /^\s*(outcome|project summary|result|summary|status|output|message|error|check):\s*/i;
 
 export function formatSubagentResultForParent(result: SingleResult): string {
-  return result.finalOutput;
+  return result.thinkingWarning
+    ? `[thinking] ${result.thinkingWarning}\n\n${result.finalOutput}`
+    : result.finalOutput;
 }
 
 export function summarizeFeedbackUiFinalOutput(finalOutput: string): string {

package/src/{ui.ts → output/ui.ts}

@@ -7,11 +7,7 @@ import {
   type MarkdownTheme,
   Text,
 } from "@earendil-works/pi-tui";
-import type { AgentScope } from "./agents.js";
-import {
-  extractSemanticToolTarget,
-  normalizeSummaryValue,
-} from "./normalize.js";
+import type { AgentScope } from "../agent/agents.js";
 import {
   formatContextPercent,
   formatElapsed,
@@ -21,11 +17,13 @@ import {
   STATUS_ICON,
   type SubagentProgressState,
   type ThemeBg,
-} from "./progress-state.js";
-import { hasSubagentFailed } from "./result-details.js";
-import type { SubagentDetails, UsageStats } from "./types.js";
-
-export type { ThemeBg };
+} from "../progress/progress-state.js";
+import { hasSubagentFailed } from "../progress/result-details.js";
+import type { SubagentDetails, UsageStats } from "../shared/types.js";
+import {
+  extractSemanticToolTarget,
+  normalizeSummaryValue,
+} from "./normalize.js";
 
 /**
  * Abstraction for theme-aware text formatting.
@@ -103,32 +101,16 @@ export function formatUsageStats(
   return parts.join(" · ");
 }
 
-/**
- * Formats millisecond durations into human-readable time strings.
- */
-export function formatDuration(ms: number): string {
-  if (ms < 1000) return `${Math.floor(ms)}ms`;
-  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-  const minutes = Math.floor(ms / 60000);
-  const seconds = Math.floor((ms % 60000) / 1000);
-  return `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
-}
-
 /**
  * Formats the footer for subagent result cards, including model, context, turns, and cost.
  */
-export function formatResultFooter(
-  usage: UsageStats,
-  model?: string,
-  durationMs?: number,
-): string {
+export function formatResultFooter(usage: UsageStats, model?: string): string {
   const parts: string[] = [];
   if (model) parts.push(model);
-  if (usage.contextTokens && usage.contextTokens > 0)
-    parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
   if (usage.turns)
     parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-  if (typeof durationMs === "number") parts.push(formatDuration(durationMs));
+  if (usage.contextTokens && usage.contextTokens > 0)
+    parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
   if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
   return parts.join(" · ");
 }
@@ -143,7 +125,7 @@ export function formatToolCall(
   forceJson = false,
 ): string {
   const target = normalizeSummaryValue(
-    extractSemanticToolTarget(toolName, args, forceJson),
+    extractSemanticToolTarget(args, forceJson),
   );
   if (!target) return themeFg("accent", toolName);
   return themeFg("accent", toolName) + themeFg("dim", ` ${target}`);
@@ -199,7 +181,8 @@ export function renderSubagentCall(
 ): Text {
   const scope: AgentScope = args.agentScope ?? "both";
   const agentName = args.agent || "...";
-  const target = extractSemanticToolTarget("subagent", args);
+  // Parser-owned preview suppresses task text: show agent + scope only
+  const target = args.agent ? `[${scope}]` : JSON.stringify(args);
   let text =
     theme.fg("toolTitle", theme.bold("subagent ")) +
     theme.fg("accent", agentName) +
@@ -208,15 +191,17 @@ export function renderSubagentCall(
   return new Text(text, 0, 0, (line) => theme.bg("toolPendingBg", line));
 }
 
-/**
- * Renders the subagent result box.
- *
- * Invariants:
- * - Red background indicates failure (exit code, error reason, or message error).
- * - Green background indicates success.
- * - Trims redundant "Outcome:" lines from the body.
- * - Displays usage stats and duration in the footer.
- */
+export function renderSubagentToolResult(
+  result: { content: { type: string; text?: string }[]; details?: unknown },
+  theme: SubagentTheme,
+  display?: { isPartial?: boolean },
+): Component {
+  const details = result.details as SubagentDetails | undefined;
+  if (details?.renderedByMessage) return new Text("", 0, 0);
+  return renderSubagentResult(result, theme, display);
+}
+
+// Invariants: Red background = failure, green = success. Trims redundant "Outcome:" lines. Shows usage stats + duration in footer.
 export function renderSubagentResult(
   result: { content: { type: string; text?: string }[]; details?: unknown },
   theme: SubagentTheme,
@@ -242,13 +227,29 @@ export function renderSubagentResult(
       : "success";
   const finalOutput = r.finalOutput ?? getFinalOutput(r.messages ?? []);
   const title = formatSubagentTitle(r.agent, r.instanceName, theme);
-  const bodyText = stripOutcomeLineForResultUi(bodyOverride ?? finalOutput);
-  const usageStr = formatResultFooter(r.usage, r.model, r.durationMs);
+  let effectiveBody = bodyOverride ?? finalOutput;
+  if (_display?.isPartial && !finalOutput?.trim() && !bodyOverride) {
+    effectiveBody =
+      result.content[0]?.text ||
+      r.progress?.activityText ||
+      r.progress?.lastToolPreview ||
+      "(running...)";
+  }
+  const bodyText = stripOutcomeLineForResultUi(effectiveBody);
+  const toolCount = r.progress?.toolCalls?.length ?? 0;
+  const toolLabel = `${toolCount} ${toolCount === 1 ? "tool" : "tools"}`;
+  const ctxPercent = formatContextPercent({
+    contextTokens: r.usage.contextTokens,
+    contextWindowTokens: r.usage.contextWindowTokens,
+  } as SubagentProgressState);
+  const metadata = `${toolLabel} · ${ctxPercent} ctx · ${formatElapsed(r.durationMs ?? 0)}`;
+  const usageStr = formatResultFooter(r.usage, r.model);
   return renderStatusCard(
     {
       status: resultStatus,
       title,
       variant: "full",
+      metadata,
       body: bodyText,
       footer: usageStr,
     },
@@ -347,7 +348,6 @@ function renderJobCard(
   );
 }
 
-/** Sort states by startTime descending (newest first). */
 function sortByStartTimeDesc(
   a: SubagentProgressState,
   b: SubagentProgressState,
@@ -363,11 +363,8 @@ const BOARD_SECTIONS: [string, ProgressStatus][] = [
   ["SUCCEEDED", "success"],
 ];
 
-/**
- * Renders a unified job board for the `/jobs` command.
- * Jobs render in status-specific sections, each sorted by `startTime` descending.
- * Status icons preserve the existing /jobs contract for running and cancelled jobs.
- */
+// Jobs render in status-specific sections, each sorted by `startTime` descending.
+// Status icons preserve the existing /jobs contract for running and cancelled jobs.
 export function renderRunsBoard(
   states: SubagentProgressState[],
   theme: SubagentTheme,

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

@@ -3,12 +3,18 @@ import {
   isStatusOnlyFailure,
   isStatusOnlySuccess,
   makeToolPreview,
+  normalizeAndTruncate,
   normalizeSummaryValue,
   normalizeTerminalSentence,
-  TOOL_PREVIEW_MAX_CHARS,
   truncateText,
-} from "./normalize.js";
-import type { SubagentDetails } from "./types.js";
+} from "../output/normalize.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);
+}