@esso0428/pi-subagents 0.15.6 → 0.15.8

package/src/index.ts

@@ -451,6 +451,9 @@ export default function (pi: ExtensionAPI) {
       id: record.id, type: record.type, description: record.description,
       status: record.status, result: record.result, error: record.error,
       startedAt: record.startedAt, completedAt: record.completedAt,
+      toolUses: record.toolUses,
+      lifetimeUsage: record.lifetimeUsage,
+      invocation: record.invocation,
       transcriptPath: record.transcriptPath,
     });
 
@@ -1168,7 +1171,9 @@ Terse command-style prompts produce shallow, generic work.
       const effectiveMaxTurns = normalizeMaxTurns(resolvedConfig.maxTurns ?? getDefaultMaxTurns());
       const agentInvocation: AgentInvocation = {
         modelName,
+        effectiveModelName: model?.name ?? model?.id ?? ctx.model?.name ?? ctx.model?.id,
         thinking,
+        effectiveThinking: thinking,
         // Explicit value only — the default fallback would just add noise.
         // Normalize so `0` (unlimited) doesn't surface as a misleading "max turns: 0".
         maxTurns: normalizeMaxTurns(resolvedConfig.maxTurns),
@@ -1758,6 +1763,26 @@ Terse command-style prompts produce shallow, generic work.
     }
   }
 
+  function makeUniqueAgentOptionLabels(pairs: Array<{ record: AgentRecord; label: string }>): string[] {
+    const counts = new Map<string, number>();
+    for (const pair of pairs) counts.set(pair.label, (counts.get(pair.label) ?? 0) + 1);
+    const used = new Set<string>();
+    return pairs.map((pair) => {
+      const { record, label } = pair;
+      if ((counts.get(label) ?? 0) === 1) {
+        used.add(label);
+        return label;
+      }
+      const suffix = ` · #${record.id.slice(-8)}`;
+      let candidate = `${label}${suffix}`;
+      let n = 2;
+      while (used.has(candidate)) candidate = `${label}${suffix}-${n++}`;
+      used.add(candidate);
+      pair.label = candidate;
+      return candidate;
+    });
+  }
+
   async function showRunningAgents(ctx: ExtensionCommandContext) {
     const { active: agents } = splitAgentRecords(manager.listAgents(), ctx.cwd);
     if (agents.length === 0) {
@@ -1765,19 +1790,17 @@ Terse command-style prompts produce shallow, generic work.
       return;
     }
 
-    const options = agents.map(a => {
-      const dn = getDisplayName(a.type);
-      const dur = formatDuration(a.startedAt, a.completedAt);
-      return `${dn} (${a.description}) · ${a.toolUses} tools · ${a.status} · ${dur}`;
+    const pairs = agents.map((record) => {
+      const dn = getDisplayName(record.type);
+      const dur = formatDuration(record.startedAt, record.completedAt);
+      return { record, label: `${dn} (${record.description}) · ${record.toolUses} tools · ${record.status} · ${dur}` };
     });
+    const options = makeUniqueAgentOptionLabels(pairs);
 
     const choice = await ctx.ui.select("Running agents", options);
     if (!choice) return;
-
-    // Find the selected agent by matching the option index
-    const idx = options.indexOf(choice);
-    if (idx < 0) return;
-    const record = agents[idx];
+    const record = pairs.find((pair) => pair.label === choice)?.record;
+    if (!record) return;
 
     await viewAgentConversation(ctx, record, "live");
     // Back-navigation: re-show the list
@@ -1791,10 +1814,11 @@ Terse command-style prompts produce shallow, generic work.
       return;
     }
 
-    const options = history.map(record => formatAgentHistoryOption(record, Date.now()));
+    const pairs = history.map((record) => ({ record, label: formatAgentHistoryOption(record, Date.now()) }));
+    const options = makeUniqueAgentOptionLabels(pairs);
     const choice = await ctx.ui.select("Agent history", options);
     if (!choice) return;
-    const record = history[options.indexOf(choice)];
+    const record = pairs.find((pair) => pair.label === choice)?.record;
     if (!record) return;
 
     await viewAgentConversation(ctx, record, "history");

package/src/types.ts

@@ -137,6 +137,10 @@ export interface AgentRecord {
 export interface AgentInvocation {
   /** Short display name, e.g. "haiku" — only set when different from parent. */
   modelName?: string;
+  /** Effective model captured from the child session, including inherited models. */
+  effectiveModelName?: string;
+  /** Requested/ effective thinking level. */
+  effectiveThinking?: AgentSession["thinkingLevel"];
   thinking?: ThinkingLevel;
   maxTurns?: number;
   isolated?: boolean;

package/src/ui/agent-widget.ts

@@ -166,7 +166,8 @@ export function buildInvocationTags(
 ): { modelName?: string; tags: string[] } {
   const tags: string[] = [];
   if (!invocation) return { tags };
-  if (invocation.thinking) tags.push(`thinking: ${invocation.thinking}`);
+  const thinking = invocation.effectiveThinking ?? invocation.thinking;
+  if (thinking) tags.push(`thinking: ${thinking}`);
   if (invocation.isolated) tags.push("isolated");
   if (invocation.isolation === "worktree") tags.push("worktree");
   if (invocation.inheritContext) tags.push("inherit context");

package/src/ui/ccstyle/ATTRIBUTION.md

@@ -0,0 +1,37 @@
+# Attribution
+
+The viewer-local ccstyle tool-card and diff renderer are adapted from
+`@herbertgao/pi-cc-extensions` version `0.9.0`, specifically its
+`extensions/renderer/tool/result.ts` and
+`extensions/renderer/tool/diff/` modules.
+
+The adaptation is local to this package and changes the configuration boundary,
+write payload handling, width guards, and syntax highlighting fallback. It does
+not install `@shikijs/cli`, patch Pi prototypes, or register global terminal
+handlers. The local copy uses Pi's public `highlightCode` API and plain text
+when highlighting is unavailable.
+
+The source package is distributed under the MIT License. The relevant license
+text is reproduced below:
+
+> MIT License
+>
+> Copyright (c) 2026 Herbert Gao and pi-cc-extensions contributors
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.

package/src/ui/ccstyle/diff/ansi-utils.ts

@@ -0,0 +1,168 @@
+const ANSI_SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
+const ANSI_SGR_WITH_COLON_PATTERN = /\x1b\[([0-9;:]*)m/g;
+const STYLE_RESET_PARAMS = [39, 22, 23, 24, 25, 27, 28, 29, 59] as const;
+
+export { ANSI_SGR_PATTERN, STYLE_RESET_PARAMS };
+
+export function expandSgrReset(param: number): readonly number[] | undefined {
+	return param === 0 ? STYLE_RESET_PARAMS : undefined;
+}
+
+export function toSgrParams(rawParams: string): number[] {
+	if (!rawParams.trim()) {
+		return [0];
+	}
+
+	const parsed = rawParams
+		.split(";")
+		.map((token) => Number.parseInt(token, 10))
+		.filter((value) => Number.isFinite(value));
+
+	return parsed.length > 0 ? parsed : [];
+}
+
+export function isFiniteSgrParam(value: number | undefined): value is number {
+	return typeof value === "number" && Number.isFinite(value);
+}
+
+export function readSgrColorSequence(params: number[], index: number): number[] | undefined {
+	const param = params[index];
+	if (param !== 38 && param !== 48) {
+		return undefined;
+	}
+
+	const colorMode = params[index + 1];
+	if (colorMode === 5) {
+		const colorValue = params[index + 2];
+		return isFiniteSgrParam(colorValue) ? [param, colorMode, colorValue] : undefined;
+	}
+
+	if (colorMode === 2) {
+		const red = params[index + 2];
+		const green = params[index + 3];
+		const blue = params[index + 4];
+		return isFiniteSgrParam(red) && isFiniteSgrParam(green) && isFiniteSgrParam(blue)
+			? [param, colorMode, red, green, blue]
+			: undefined;
+	}
+
+	return undefined;
+}
+
+export function stripBackgroundSgrParams(params: readonly number[]): number[] {
+	const sanitized: number[] = [];
+
+	for (let index = 0; index < params.length; index++) {
+		const param = params[index] ?? 0;
+
+		if (param === 0) {
+			sanitized.push(...expandSgrReset(param)!);
+			continue;
+		}
+
+		if (param === 49 || (param >= 40 && param <= 47) || (param >= 100 && param <= 107)) {
+			continue;
+		}
+
+		if (param === 38 || param === 48) {
+			const sequence = readSgrColorSequence(params as number[], index);
+			if (sequence) {
+				if (param === 38) {
+					sanitized.push(...sequence);
+				}
+				index += sequence.length - 1;
+				continue;
+			}
+			const advance = params[index + 1] === 5 ? 2 : params[index + 1] === 2 ? 4 : 0;
+			if (advance > 0) {
+				index += advance;
+				if (param === 38) {
+					sanitized.push(param);
+				}
+				continue;
+			}
+		}
+
+		sanitized.push(param);
+	}
+
+	return sanitized;
+}
+
+export function filterSgrSequences(text: string, filter: (params: number[]) => number[]): string {
+	if (!text || !text.includes("\x1b[")) {
+		return text;
+	}
+
+	return text.replace(ANSI_SGR_PATTERN, (_sequence, rawParams: string) => {
+		const parsed = toSgrParams(rawParams);
+		if (parsed.length === 0) {
+			return "";
+		}
+
+		const sanitized = filter(parsed);
+		if (sanitized.length === 0) {
+			return "";
+		}
+
+		return `\x1b[${sanitized.join(";")}m`;
+	});
+}
+
+function isValidColonForeground(segment: string): boolean {
+	const params = segment.split(":");
+	const isByte = (value: string | undefined) =>
+		value !== undefined && /^\d+$/.test(value) && Number(value) <= 255;
+	if (params[0] !== "38") return false;
+	if (params[1] === "5") return params.length === 3 && isByte(params[2]);
+	return (
+		params[1] === "2" &&
+		params.length === 6 &&
+		(params[2] === "" || /^\d+$/.test(params[2] ?? "")) &&
+		params.slice(3).every(isByte)
+	);
+}
+
+function sanitizeColonSgr(rawParams: string): string {
+	const segments = rawParams.split(";");
+	const sanitized: string[] = [];
+	for (let index = 0; index < segments.length; index++) {
+		const segment = segments[index] ?? "";
+		if (segment.includes(":")) {
+			const code = Number.parseInt(segment, 10);
+			if (code !== 48 && (code !== 38 || isValidColonForeground(segment))) {
+				sanitized.push(segment);
+			}
+			continue;
+		}
+		const param = Number.parseInt(segment, 10);
+		if (!Number.isFinite(param)) continue;
+		if (param === 0) {
+			sanitized.push(...STYLE_RESET_PARAMS.map(String));
+			continue;
+		}
+		if (param === 49 || (param >= 40 && param <= 47) || (param >= 100 && param <= 107)) {
+			continue;
+		}
+		if (param === 38 || param === 48) {
+			const mode = Number.parseInt(segments[index + 1] ?? "", 10);
+			const advance = mode === 5 ? 2 : mode === 2 ? 4 : 0;
+			if (advance > 0) {
+				if (param === 38) sanitized.push(...segments.slice(index, index + advance + 1));
+				index += advance;
+				continue;
+			}
+		}
+		sanitized.push(segment);
+	}
+	return sanitized.length > 0 ? `\x1b[${sanitized.join(";")}m` : "";
+}
+
+export function sanitizeAnsiForThemedOutput(text: string): string {
+	if (!text || !text.includes("\x1b[")) return text;
+	return text.replace(ANSI_SGR_WITH_COLON_PATTERN, (sequence, rawParams: string) =>
+		rawParams.includes(":")
+			? sanitizeColonSgr(rawParams)
+			: filterSgrSequences(sequence, stripBackgroundSgrParams),
+	);
+}

package/src/ui/ccstyle/diff/diff-presentation.ts

@@ -0,0 +1,70 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { pluralize } from "./render-utils.js";
+import type { ToolDisplayConfig } from "./types.js";
+
+export interface DiffSummaryStats {
+	added: number;
+	removed: number;
+	hunks: number;
+	files: number;
+}
+
+export type DiffPresentationMode = "split" | "unified" | "compact" | "summary";
+
+const MIN_COMPACT_DIFF_WIDTH = 8;
+const MIN_UNIFIED_DIFF_WIDTH = 18;
+
+export function normalizeDiffRenderWidth(width: number): number {
+	if (!Number.isFinite(width)) {
+		return 0;
+	}
+	return Math.max(0, Math.floor(width));
+}
+
+export function resolveDiffPresentationMode(
+	config: Pick<ToolDisplayConfig, "diffViewMode" | "diffSplitMinWidth">,
+	width: number,
+	canRenderSplitLayout: boolean,
+): DiffPresentationMode {
+	const safeWidth = normalizeDiffRenderWidth(width);
+	if (safeWidth < MIN_COMPACT_DIFF_WIDTH) {
+		return "summary";
+	}
+	if (safeWidth < MIN_UNIFIED_DIFF_WIDTH) {
+		return "compact";
+	}
+
+	switch (config.diffViewMode) {
+		case "split":
+			return canRenderSplitLayout ? "split" : "unified";
+		case "unified":
+			return "unified";
+		case "auto":
+		default:
+			return safeWidth >= (config.diffSplitMinWidth ?? 120) && canRenderSplitLayout ? "split" : "unified";
+	}
+}
+
+export function buildDiffSummaryText(stats: DiffSummaryStats, width: number): string {
+	const safeWidth = normalizeDiffRenderWidth(width);
+	if (safeWidth === 0) {
+		return "";
+	}
+
+	const summaryCandidates = [
+		`↳ diff +${stats.added} -${stats.removed} • ${stats.hunks} ${pluralize(stats.hunks, "hunk")} • ${stats.files} ${pluralize(stats.files, "file")}`,
+		`↳ diff +${stats.added} -${stats.removed} • ${stats.hunks}h • ${stats.files}f`,
+		`↳ diff +${stats.added} -${stats.removed}`,
+		`+${stats.added} -${stats.removed}`,
+		"diff",
+		"…",
+	];
+
+	for (const candidate of summaryCandidates) {
+		if (visibleWidth(candidate) <= safeWidth) {
+			return candidate;
+		}
+	}
+
+	return truncateToWidth(summaryCandidates[summaryCandidates.length - 1] ?? "", safeWidth, "");
+}