@dyyz1993/pi-coding-agent 0.74.47 → 0.74.48

package/dist/extensions/subagent-v2/index.ts

@@ -5,26 +5,339 @@ import type { Message } from "@dyyz1993/pi-ai";
 import { StringEnum } from "@dyyz1993/pi-ai";
 import {
 	type AgentScope,
+	type ChannelContract,
 	type ExtensionAPI,
 	RpcClient,
 	createTypedChannel,
 	discoverAgents,
+	getMarkdownTheme,
+	withFileMutationQueue,
 } from "@dyyz1993/pi-coding-agent";
-import { Text } from "@dyyz1993/pi-tui";
+import type { Theme, ThemeColor } from "@dyyz1993/pi-coding-agent";
+import { type Component, Container, Markdown, Spacer, Text } from "@dyyz1993/pi-tui";
 import { Type } from "typebox";
-import {
-	accumulateUsage,
-	cleanupTempFiles,
-	type SingleResult,
-	type SubagentEventPayload,
-	type UsageStats,
-	formatUsageStats,
-	getFinalOutput,
-	makeUsage,
-	renderSingleResult,
-	writePromptToTempFile,
-} from "../subagent-shared/index.js";
-import type { SubagentChannelContract } from "../subagent-shared/contract.js";
+
+// ── Inlined from subagent-shared/contract.ts ──
+
+const SUBAGENT_CHANNEL_NAME = "subagent";
+
+interface SubagentEventPayload {
+	event: unknown;
+	sessionId: string;
+	taskId?: string;
+	[key: string]: unknown;
+}
+
+interface SubagentStartPayload {
+	event: {
+		type: "subagent_start";
+		toolCallId: string;
+		description: string;
+		instruction: string;
+	};
+	sessionId: string;
+}
+
+interface SubagentChannelContract extends ChannelContract {
+	methods?: Record<string, never>;
+	events: {
+		event: SubagentEventPayload;
+		subagent_start: SubagentStartPayload;
+	};
+}
+
+// ── Inlined from subagent-shared/types.ts ──
+
+interface UsageStats {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+	contextTokens: number;
+	turns: number;
+}
+
+interface SingleResult {
+	agent: string;
+	agentSource: "user" | "project" | "unknown" | "builtin" | "plugin" | "flag" | "policy";
+	task: string;
+	exitCode: number;
+	messages: Message[];
+	stderr: string;
+	usage: UsageStats;
+	model?: string;
+	stopReason?: string;
+	errorMessage?: string;
+	step?: number;
+	sessionPath?: string;
+}
+
+type DisplayItem =
+	| { type: "text"; text: string }
+	| { type: "toolCall"; name: string; args: Record<string, unknown> };
+
+interface SubagentDetailsBase {
+	agentScope: string;
+	projectAgentsDir: string | null;
+}
+
+// ── Inlined from subagent-shared/utils.ts ──
+
+function formatTokens(count: number): string {
+	if (count < 1000) return count.toString();
+	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1000000) return `${Math.round(count / 1000)}k`;
+	return `${(count / 1000000).toFixed(1)}M`;
+}
+
+function formatUsageStats(
+	usage: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+		cost: number;
+		contextTokens?: number;
+		turns?: number;
+	},
+	model?: string,
+): string {
+	const parts: string[] = [];
+	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
+	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
+	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
+	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+	if (usage.contextTokens && usage.contextTokens > 0) parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
+	if (model) parts.push(model);
+	return parts.join(" ");
+}
+
+function getFinalOutput(messages: Message[]): string {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "assistant") {
+			for (const part of msg.content) {
+				if (part.type === "text") return part.text;
+			}
+		}
+	}
+	return "";
+}
+
+function getDisplayItems(messages: Message[]): DisplayItem[] {
+	const items: DisplayItem[] = [];
+	for (const msg of messages) {
+		if (msg.role === "assistant") {
+			for (const part of msg.content) {
+				if (part.type === "text") items.push({ type: "text", text: part.text });
+				else if (part.type === "toolCall") items.push({ type: "toolCall", name: part.name, args: part.arguments });
+			}
+		}
+	}
+	return items;
+}
+
+async function writePromptToTempFile(
+	agentName: string,
+	prompt: string,
+	tmpPrefix = "pi-subagent-",
+): Promise<{ dir: string; filePath: string }> {
+	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), tmpPrefix));
+	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 });
+	});
+	return { dir: tmpDir, filePath };
+}
+
+function cleanupTempFiles(filePath: string | null, dir: string | null, logPrefix = "subagent"): void {
+	if (filePath)
+		try {
+			fs.unlinkSync(filePath);
+		} catch (err) {
+			console.debug(`[${logPrefix}] temp file cleanup failed:`, err instanceof Error ? err.message : err);
+		}
+	if (dir)
+		try {
+			fs.rmdirSync(dir);
+		} catch (err) {
+			console.debug(`[${logPrefix}] temp dir cleanup failed:`, err instanceof Error ? err.message : err);
+		}
+}
+
+function makeUsage(): UsageStats {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
+}
+
+function accumulateUsage(result: { usage: UsageStats; model?: string; stopReason?: string; errorMessage?: string }, msg: Message): void {
+	if (msg.role !== "assistant") return;
+	result.usage.turns++;
+	const usage = msg.usage;
+	if (usage) {
+		result.usage.input += usage.input || 0;
+		result.usage.output += usage.output || 0;
+		result.usage.cacheRead += usage.cacheRead || 0;
+		result.usage.cacheWrite += usage.cacheWrite || 0;
+		result.usage.cost += usage.cost?.total || 0;
+		result.usage.contextTokens = usage.totalTokens || 0;
+	}
+	if (!result.model && msg.model) result.model = msg.model;
+	if (msg.stopReason) result.stopReason = msg.stopReason;
+	if (msg.errorMessage) result.errorMessage = msg.errorMessage;
+}
+
+// ── Inlined from subagent-shared/render.ts ──
+
+const COLLAPSED_ITEM_COUNT = 10;
+
+function formatToolCall(
+	toolName: string,
+	args: Record<string, unknown>,
+	themeFg: (color: ThemeColor, text: string) => string,
+): string {
+	const shortenPath = (p: string) => {
+		const home = os.homedir();
+		return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+	};
+
+	switch (toolName) {
+		case "bash": {
+			const command = (args.command as string) || "...";
+			const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command;
+			return themeFg("muted", "$ ") + themeFg("toolOutput", preview);
+		}
+		case "read": {
+			const rawPath = (args.file_path || args.path || "...") as string;
+			const filePath = shortenPath(rawPath);
+			const offset = args.offset as number | undefined;
+			const limit = args.limit as number | undefined;
+			let text = themeFg("accent", filePath);
+			if (offset !== undefined || limit !== undefined) {
+				const startLine = offset ?? 1;
+				const endLine = limit !== undefined ? startLine + limit - 1 : "";
+				text += themeFg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+			}
+			return themeFg("muted", "read ") + text;
+		}
+		case "write": {
+			const rawPath = (args.file_path || args.path || "...") as string;
+			const filePath = shortenPath(rawPath);
+			const content = (args.content || "") as string;
+			const lines = content.split("\n").length;
+			let text = themeFg("muted", "write ") + themeFg("accent", filePath);
+			if (lines > 1) text += themeFg("dim", ` (${lines} lines)`);
+			return text;
+		}
+		case "edit": {
+			const rawPath = (args.file_path || args.path || "...") as string;
+			return themeFg("muted", "edit ") + themeFg("accent", shortenPath(rawPath));
+		}
+		case "ls": {
+			const rawPath = (args.path || ".") as string;
+			return themeFg("muted", "ls ") + themeFg("accent", shortenPath(rawPath));
+		}
+		case "find": {
+			const pattern = (args.pattern || "*") as string;
+			const rawPath = (args.path || ".") as string;
+			return themeFg("muted", "find ") + themeFg("accent", pattern) + themeFg("dim", ` in ${shortenPath(rawPath)}`);
+		}
+		case "grep": {
+			const pattern = (args.pattern || "") as string;
+			const rawPath = (args.path || ".") as string;
+			return (
+				themeFg("muted", "grep ") +
+				themeFg("accent", `/${pattern}/`) +
+				themeFg("dim", ` in ${shortenPath(rawPath)}`)
+			);
+		}
+		default: {
+			const argsStr = JSON.stringify(args);
+			const preview = argsStr.length > 50 ? `${argsStr.slice(0, 50)}...` : argsStr;
+			return themeFg("accent", toolName) + themeFg("dim", ` ${preview}`);
+		}
+	}
+}
+
+function renderDisplayItemsInner(
+	items: DisplayItem[],
+	expanded: boolean,
+	theme: Theme,
+	limit?: number,
+): string {
+	const fg = (c: string, t: string) => theme.fg(c as ThemeColor, t);
+	const toShow = limit ? items.slice(-limit) : items;
+	const skipped = limit && items.length > limit ? items.length - limit : 0;
+	let text = "";
+	if (skipped > 0) text += theme.fg("muted", `... ${skipped} earlier items\n`);
+	for (const item of toShow) {
+		if (item.type === "text") {
+			const preview = expanded ? item.text : item.text.split("\n").slice(0, 3).join("\n");
+			text += `${theme.fg("toolOutput", preview)}\n`;
+		} else {
+			text += `${theme.fg("muted", "→ ") + formatToolCall(item.name, item.args, fg)}\n`;
+		}
+	}
+	return text.trimEnd();
+}
+
+function renderSingleResult(r: SingleResult, expanded: boolean, theme: Theme): Component {
+	const mdTheme = getMarkdownTheme();
+	const fg = (c: string, t: string) => theme.fg(c as ThemeColor, t);
+	const isError =
+		r.exitCode !== 0 || r.stopReason === "error" || r.stopReason === "aborted" || r.stopReason === "timeout";
+	const icon = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
+	const displayItems = getDisplayItems(r.messages);
+	const finalOutput = getFinalOutput(r.messages);
+
+	if (expanded) {
+		const container = new Container();
+		let header = `${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${theme.fg("muted", ` (${r.agentSource})`)}`;
+		if (isError && r.stopReason) header += ` ${theme.fg("error", `[${r.stopReason}]`)}`;
+		container.addChild(new Text(header, 0, 0));
+		if (isError && r.errorMessage) container.addChild(new Text(theme.fg("error", `Error: ${r.errorMessage}`), 0, 0));
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(theme.fg("muted", "─── Task ───"), 0, 0));
+		container.addChild(new Text(theme.fg("dim", r.task), 0, 0));
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(theme.fg("muted", "─── Output ───"), 0, 0));
+		if (displayItems.length === 0 && !finalOutput) {
+			container.addChild(new Text(theme.fg("muted", "(no output)"), 0, 0));
+		} else {
+			for (const item of displayItems) {
+				if (item.type === "toolCall")
+					container.addChild(new Text(theme.fg("muted", "→ ") + formatToolCall(item.name, item.args, fg), 0, 0));
+			}
+			if (finalOutput) {
+				container.addChild(new Spacer(1));
+				container.addChild(new Markdown(finalOutput.trim(), 0, 0, mdTheme));
+			}
+		}
+		const usageStr = formatUsageStats(r.usage, r.model);
+		if (usageStr) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("dim", usageStr), 0, 0));
+		}
+		return container;
+	}
+
+	let text = `${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${theme.fg("muted", ` (${r.agentSource})`)}`;
+	if (isError && r.stopReason) text += ` ${theme.fg("error", `[${r.stopReason}]`)}`;
+	if (isError && r.errorMessage) text += `\n${theme.fg("error", `Error: ${r.errorMessage}`)}`;
+	else if (displayItems.length === 0) text += `\n${theme.fg("muted", "(no output)")}`;
+	else {
+		text += `\n${renderDisplayItemsInner(displayItems, expanded, theme, COLLAPSED_ITEM_COUNT)}`;
+		if (displayItems.length > COLLAPSED_ITEM_COUNT) text += `\n${theme.fg("muted", "(Ctrl+O to expand)")}`;
+	}
+	const usageStr = formatUsageStats(r.usage, r.model);
+	if (usageStr) text += `\n${theme.fg("dim", usageStr)}`;
+	return new Text(text, 0, 0);
+}
+
+// ── subagent-v2 logic ──
 
 const STEER_GRACE_MS = 30_000;
 
@@ -167,6 +480,9 @@ export default function (pi: ExtensionAPI) {
 			const timeoutMs = Math.max((params.timeout ?? 300) * 1000, STEER_GRACE_MS + 10_000);
 			const background = params.background ?? false;
 
+			// Extract parent todo list from session history (for read-only reference)
+			const parentTodos = extractParentTodos(ctx.sessionManager.getBranch());
+
 			const details: SubagentDetails = {
 				agentScope,
 				projectAgentsDir: discovery.projectAgentsDir,
@@ -241,10 +557,17 @@ export default function (pi: ExtensionAPI) {
 				}
 			};
 
-			const client = new RpcClient({
+			// Pass subagent role and parent todos to child process via env vars
+		const env: Record<string, string> = { PI_SUBAGENT: "true" };
+		if (parentTodos.length > 0) {
+			env.PI_PARENT_TODOS = JSON.stringify(parentTodos);
+		}
+
+		const client = new RpcClient({
 				cwd: params.cwd ?? ctx.cwd,
 				provider: ctx.model?.provider || undefined,
 				model: agent.model,
+				env,
 				args: extraArgs,
 			});
 
@@ -613,3 +936,37 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 }
+
+/**
+ * Extract the parent session's todo list from session history entries.
+ * Scans custom "todo" entries and tool result messages for the latest list.
+ * Returns active (not deleted, not done) todos for read-only reference.
+ */
+export function extractParentTodos(branch: unknown[]): Array<{ id: number; text: string; priority?: string; done: boolean }> {
+	let todos: Array<{ id: number; text: string; done: boolean; deleted?: boolean; priority?: string }> = [];
+	let nextId = 1;
+
+	for (const entry of branch) {
+		const e = entry as Record<string, unknown>;
+		if (e.type === "custom" && (e as Record<string, unknown>).customType === "todo") {
+			const data = (e as Record<string, unknown>).data as Record<string, unknown> | undefined;
+			if (data?.todos) {
+				todos = data.todos as typeof todos;
+				nextId = (data.nextId as number) ?? nextId;
+			}
+			continue;
+		}
+		if (e.type !== "message") continue;
+		const msg = (e as Record<string, unknown>).message as Record<string, unknown> | undefined;
+		if (!msg || msg.role !== "toolResult" || (msg as Record<string, unknown>).toolName !== "todo") continue;
+		const details = (msg as Record<string, unknown>).details as Record<string, unknown> | undefined;
+		if (details?.todos) {
+			todos = details.todos as typeof todos;
+			nextId = (details.nextId as number) ?? nextId;
+		}
+	}
+
+	return todos
+		.filter((t) => !t.deleted && !t.done)
+		.map((t) => ({ id: t.id, text: t.text, priority: t.priority, done: t.done }));
+}

package/dist/extensions/todo-ext/index.ts

@@ -79,6 +79,39 @@ function updateWidget(ctx: ExtensionContext | undefined, todos: Todo[]): void {
 }
 
 export default function (pi: ExtensionAPI) {
+	// ── Sub-agent mode: inject parent's todos as read-only, no todo tool ──
+	if (process.env.PI_SUBAGENT === "true") {
+		let parentTodos: TodoItem[] = [];
+		try {
+			const raw = process.env.PI_PARENT_TODOS;
+			if (raw) parentTodos = JSON.parse(raw) as TodoItem[];
+		} catch {
+			// ignore parse errors
+		}
+		const active = parentTodos.filter((t) => !t.deleted && !t.done);
+		if (active.length > 0) {
+			const lines = active.map((t) => {
+				const pri = t.priority === "high" ? " [!]" : t.priority === "low" ? " [?]" : "";
+				return `  #${t.id}${pri}: ${t.text}`;
+			});
+			const header = `[Parent session's tasks — read-only]\nThese are the parent session's active tasks for reference. Do not modify them.\n${lines.join("\n")}`;
+			pi.on("context", (_event, _ctx) => {
+				return {
+					messages: [
+						...(_event as any).messages,
+						{
+							role: "user" as const,
+							content: [{ type: "text" as const, text: header }],
+							timestamp: Date.now(),
+						},
+					],
+				};
+			});
+		}
+		return; // Skip all tool/command/channel registration
+	}
+
+	// ── Normal mode ──
 	let todos: Todo[] = [];
 	let nextId = 1;
 	let channel: ServerChannel<TodoChannelContract> | null = null;
@@ -403,6 +436,28 @@ IMPORTANT: For creating a plan with multiple steps, use a SINGLE add call with n
 		},
 	});
 
+	// Inject active todo list into context so the LLM is aware of ongoing tasks
+	pi.on("context", (_event, _ctx) => {
+		const active = todos.filter((t) => !t.deleted && !t.done);
+		if (active.length === 0) return;
+
+		const lines = active.map((t) => {
+			const pri = t.priority === "high" ? " [!]" : t.priority === "low" ? " [?]" : "";
+			return `  #${t.id}${pri}: ${t.text}`;
+		});
+		const text = `[Todo list — ${active.length} active task(s)]\n${lines.join("\n")}`;
+		return {
+			messages: [
+				...(_event as any).messages,
+				{
+					role: "user" as const,
+					content: [{ type: "text" as const, text }],
+					timestamp: Date.now(),
+				},
+			],
+		};
+	});
+
 	pi.registerCommand("todos", {
 		description: "Show all todos on the current branch",
 		handler: async (_args, ctx) => {