@ghyper9023/pi-dev-workflow 0.4.3 → 0.5.1

package/extensions/sub-agents.ts

@@ -34,7 +34,11 @@ const DEFAULT_TIMEOUT_MS = 180_000;
 const PROGRESS_INTERVAL_MS = 1_500;
 
 /** Hard limit on accumulated output per subagent (prevents OOM on runaway). */
-const MAX_BUFFER_BYTES = 500_000;
+// Keep up to 10MB of output — large enough to hold complete session event streams
+// including cargo test compilation output (commonly 100-400 KB).
+// We preserve the END of the buffer (last N bytes) so extractFinalOutput can
+// find the final AI response even when the total output is large.
+const MAX_BUFFER_BYTES = 10_000_000;
 
 /**
  * Locations to auto-load APPEND_SYSTEM.md / append.system.md from (checked in order).
@@ -111,6 +115,15 @@ function osHomedir(): string {
 	}
 }
 
+/** Parse boolean-like frontmatter values: true/yes/1, false/no/0, or undefined. */
+function parseBool(val: string | undefined): boolean | undefined {
+	if (val === undefined) return undefined;
+	const lc = val.toLowerCase().trim();
+	if (lc === "true" || lc === "yes" || lc === "1") return true;
+	if (lc === "false" || lc === "no" || lc === "0") return false;
+	return undefined;
+}
+
 // ── Process lifecycle management ─────────────────────────────
 //
 // Fix #1: Prevent orphan sub-agents when pi exits or crashes.
@@ -172,6 +185,22 @@ export interface AgentDef {
 	systemPrompt: string;
 	/** Custom timeout in ms for this agent type. */
 	timeoutMs?: number;
+
+	// ── Subprocess CLI args (from frontmatter) ──
+	/** Thinking level: "off" | "low" | "medium" | "high" | "xhigh" */
+	thinkingLevel?: string;
+	/** Persist session (default: false = --no-session) */
+	session?: boolean;
+	/** Session directory override */
+	sessionDir?: string;
+	/** Skip context files AGENTS.md/CLAUDE.md (default: true = -nc) */
+	noContext?: boolean;
+	/** Disable extension loading (default: true = -ne) */
+	noExtensions?: boolean;
+	/** Output mode: "json" | "text" (default: "json") */
+	mode?: string;
+	/** Extra raw CLI args to append */
+	extraArgs?: string[];
 }
 
 export interface SubagentResult {
@@ -182,6 +211,33 @@ export interface SubagentResult {
 	durationMs: number;
 }
 
+/**
+ * Caller-provided overrides for subprocess CLI args.
+ * Each field, when set, takes precedence over the AgentDef (frontmatter) value.
+ */
+export interface SubagentArgs {
+	/** Override thinking level */
+	thinkingLevel?: string;
+	/** Override session persistence */
+	session?: boolean;
+	/** Override session directory */
+	sessionDir?: string;
+	/** Override -nc (no context files) */
+	noContext?: boolean;
+	/** Override -ne (no extensions) */
+	noExtensions?: boolean;
+	/** Override --mode */
+	mode?: string;
+	/** Override --tools whitelist */
+	tools?: string[];
+	/** Extra --append-system-prompt (appended after agent's own) */
+	appendSystemPrompt?: string;
+	/** Extra raw CLI args (appended last, highest priority) */
+	extraArgs?: string[];
+	/** Workflow UUID to include in session name for cross-workflow traceability */
+	workflowId?: string;
+}
+
 function inferTimeout(name: string): number {
 	const lc = name.toLowerCase();
 	if (lc.includes("review") || lc.includes("审查")) return REVIEW_TIMEOUT_MS;
@@ -201,7 +257,7 @@ function loadAgent(filePath: string): AgentDef | null {
 
 		const fields: Record<string, string> = {};
 		for (const line of frontRaw.split("\n")) {
-			const m = line.match(/^(\w+):\s*(.*)$/);
+			const m = line.match(/^([\w-]+):\s*(.*)$/);
 			if (m) fields[m[1]] = m[2];
 		}
 
@@ -214,6 +270,14 @@ function loadAgent(filePath: string): AgentDef | null {
 			tools: tools && tools.length > 0 ? tools : undefined,
 			systemPrompt: body,
 			timeoutMs: inferTimeout(fields.name),
+			// ── Subprocess args from frontmatter ──
+			thinkingLevel: fields.thinking || undefined,
+			session: parseBool(fields.session),
+			sessionDir: fields["session-dir"] || undefined,
+			noContext: parseBool(fields["no-context"]),
+			noExtensions: parseBool(fields["no-extensions"]),
+			mode: fields.mode || undefined,
+			extraArgs: fields["extra-args"] ? fields["extra-args"].split(/\s+/).filter(Boolean) : undefined,
 		};
 	} catch {
 		return null;
@@ -270,8 +334,9 @@ export function discoverAgents(): AgentDef[] {
 // Fix #2: Simplified settle logic - no listener manipulation races.
 //   Buffer is capped at MAX_BUFFER_BYTES to prevent OOM on runaway output.
 // Fix #3: onProgress callback streams sub-agent output in real-time.
-// Fix #4: -nc (no context files), -ne (no extensions) to reduce startup overhead.
-//   Auto-load append.system.md. Thinking=off for faster responses.
+// Fix #4: Subprocess CLI args are resolved from caller > AgentDef frontmatter > defaults.
+//   Defaults: -nc, -ne, --no-session, --mode json, --thinking off.
+//   Auto-load append.system.md for project-level instructions.
 
 function getPiInvocation(args: string[]): { command: string; args: string[] } {
 	const currentScript = process.argv[1];
@@ -294,33 +359,65 @@ export async function spawnSubagent(
 	signal?: AbortSignal,
 	timeoutMs?: number,
 	onProgress?: (msg: string) => void,
+	argsOverride?: SubagentArgs,
 ): Promise<SubagentResult> {
 	const effectiveTimeout = timeoutMs ?? agent.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 	const systemPrompt = agent.systemPrompt.trim();
 
+	// ── Resolve arg overrides (caller > AgentDef frontmatter > hardcoded default) ──
+	const override = (argsOverride as SubagentArgs) ?? {};
+
+	const finalThinking      = override.thinkingLevel ?? agent.thinkingLevel ?? "off";
+	const finalSession       = override.session       ?? agent.session       ?? false;
+	const finalSessionDir    = override.sessionDir    ?? agent.sessionDir;
+	const finalNoContext     = override.noContext     ?? agent.noContext     ?? true;
+	const finalNoExtensions  = override.noExtensions  ?? agent.noExtensions  ?? true;
+	const finalMode          = override.mode          ?? agent.mode          ?? "json";
+	const finalTools         = override.tools         ?? agent.tools;
+	const finalExtraArgs     = override.extraArgs     ?? agent.extraArgs;
+
 	// Build pi arguments for the subagent
-	const args: string[] = [
-		"-p",                        // non-interactive
-		"--no-session",              // ephemeral
-		"-nc",                       // no context files (AGENTS.md / CLAUDE.md)
-		"-ne",                       // no extensions (less startup overhead)
-		"--mode", "json",            // structured output
-	];
+	const args: string[] = ["-p"]; // non-interactive
+
+	if (!finalSession) {
+		args.push("--no-session");
+	} else {
+		// Session enabled — auto-name with timestamp + agent name
+		// Use full file path with .jsonl extension (pi --session <path> creates/opens file)
+		const sessionDir = finalSessionDir || ".pi-dev-output/pi-subagent-sessions";
+		const safeAgentName = agent.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+		const ts = new Date().toISOString().replace(/[:.]/g, "-");
+		const wfSuffix = override.workflowId ? `_${override.workflowId}` : "";
+		const sessionName = `${ts}_${safeAgentName}${wfSuffix}`;
+		// Ensure session directory exists before spawning subagent
+		try {
+			fs.mkdirSync(sessionDir, { recursive: true });
+		} catch { /* ignore if already exists */ }
+		const sessionPath = path.join(sessionDir, `${sessionName}.jsonl`);
+		args.push("--session", sessionPath);
+	}
 
-	// Sub-agents don't need high thinking - off for speed
-	// (system prompt + task text provides enough context)
-	args.push("--thinking", "off");
+	if (finalNoContext)    args.push("-nc");
+	if (finalNoExtensions) args.push("-ne");
+
+	args.push("--mode", finalMode);
+	args.push("--thinking", finalThinking);
 
 	// Only grant the tools the agent needs
-	if (agent.tools && agent.tools.length > 0) {
-		args.push("--tools", agent.tools.join(","));
+	if (finalTools && finalTools.length > 0) {
+		args.push("--tools", finalTools.join(","));
 	}
 
-	// Append agent system prompt
+	// Append agent system prompt (from AgentDef markdown body)
 	if (systemPrompt) {
 		args.push("--append-system-prompt", systemPrompt);
 	}
 
+	// Caller override system prompt (appended after agent's own)
+	if (override.appendSystemPrompt) {
+		args.push("--append-system-prompt", override.appendSystemPrompt);
+	}
+
 	// Auto-load append.system.md (global or project-level)
 	// Fix #3: Sub-agents now follow append.system.md instructions
 	try {
@@ -332,6 +429,11 @@ export async function spawnSubagent(
 		// fail silently
 	}
 
+	// Extra raw args appended last (highest priority)
+	if (finalExtraArgs && finalExtraArgs.length > 0) {
+		args.push(...finalExtraArgs);
+	}
+
 	// The task itself
 	args.push(task);
 
@@ -379,13 +481,14 @@ export async function spawnSubagent(
 
 		// ── Stream stdout data + immediate progress callback ──
 		// Fix #3: Flush progress on every data chunk
+		// Fix #4: Preserve the END of the buffer (last N bytes) instead of the beginning,
+		// because extractFinalOutput needs the final AI response which is at the end.
 		proc.stdout.on("data", (data: Buffer) => {
 			const chunk = data.toString();
-			if (stdout.length < MAX_BUFFER_BYTES) {
-				stdout += chunk;
-				if (stdout.length > MAX_BUFFER_BYTES) {
-					stdout = stdout.slice(0, MAX_BUFFER_BYTES);
-				}
+			stdout += chunk;
+			if (stdout.length > MAX_BUFFER_BYTES) {
+				// Keep only the last MAX_BUFFER_BYTES bytes
+				stdout = stdout.slice(stdout.length - MAX_BUFFER_BYTES);
 			}
 			// Immediate progress on new data
 			if (!settled && onProgress) {
@@ -399,11 +502,9 @@ export async function spawnSubagent(
 
 		proc.stderr.on("data", (data: Buffer) => {
 			const chunk = data.toString();
-			if (stderr.length < MAX_BUFFER_BYTES) {
-				stderr += chunk;
-				if (stderr.length > MAX_BUFFER_BYTES) {
-					stderr = stderr.slice(0, MAX_BUFFER_BYTES);
-				}
+			stderr += chunk;
+			if (stderr.length > MAX_BUFFER_BYTES) {
+				stderr = stderr.slice(stderr.length - MAX_BUFFER_BYTES);
 			}
 		});
 
@@ -475,11 +576,13 @@ export function extractFinalOutput(jsonOutput: string): string {
 				textEndSeen = true;
 			}
 
-			// Format 2: Anthropic-style message events
-			// message_stop / message_end with content array
+			// Format 2: pi agent event — message_end / message_stop / message_complete
+			// Only process assistant messages; toolResult and user messages contain
+			// raw tool output (e.g. ls -la) that would pollute the extracted summary.
 			if ((event.type === "message_stop" || event.type === "message_end" ||
 			     event.type === "message_complete") &&
-			    event.message?.content) {
+			    event.message?.content &&
+			    event.message?.role === "assistant") {
 				const parts = Array.isArray(event.message.content)
 					? event.message.content
 					: [event.message.content];
@@ -510,6 +613,46 @@ export function extractFinalOutput(jsonOutput: string): string {
 			if (event.type === "complete" && event.text) {
 				result = event.text;
 			}
+
+			// Format 5b: turn_end — extract text from the turn's assistant message.
+			// This provides an additional extraction point when message_end is lost
+			// due to buffer truncation (large tool results like cargo test output
+			// can push the final assistant message beyond the buffer limit).
+			if (event.type === "turn_end" &&
+			    event.message?.content &&
+			    event.message?.role === "assistant") {
+				const parts = Array.isArray(event.message.content)
+					? event.message.content
+					: [event.message.content];
+				for (const part of parts) {
+					if (typeof part === "string") result = part;
+					else if (part?.type === "text") result = part.text;
+				}
+			}
+
+			// Format 6: agent_end — iterate messages backwards to find the last
+			// assistant message with text content. This catches edge cases where
+			// the final assistant response has no type:text block (e.g. only
+			// thinking/toolCall), which left result polluted by a prior tool result.
+			if (event.type === "agent_end" && Array.isArray(event.messages)) {
+				for (let i = event.messages.length - 1; i >= 0; i--) {
+					const msg = event.messages[i];
+					if (msg?.role === "assistant" && Array.isArray(msg.content)) {
+						for (let j = msg.content.length - 1; j >= 0; j--) {
+							const block = msg.content[j];
+							if (typeof block === "string") {
+								result = block;
+								break;
+							}
+							if (block?.type === "text" && block.text) {
+								result = block.text;
+								break;
+							}
+						}
+						if (result) break;
+					}
+				}
+			}
 		} catch {
 			// If a line isn't JSON, it might be raw text output - collect it
 			if (!result) {
@@ -599,6 +742,14 @@ export default function (pi: ExtensionAPI) {
 		parameters: Type.Object({
 			agent: Type.String({ description: "Name of the agent to invoke" }),
 			task: Type.String({ description: "Task description to delegate" }),
+			// Optional overrides (pass-through to SubagentArgs)
+			thinkingLevel: Type.Optional(Type.String({ description: "Override thinking level: off | low | medium | high | xhigh" })),
+			session: Type.Optional(Type.Boolean({ description: "Override session persistence" })),
+			noContext: Type.Optional(Type.Boolean({ description: "Override -nc (skip AGENTS.md/CLAUDE.md)" })),
+			noExtensions: Type.Optional(Type.Boolean({ description: "Override -ne (disable extensions)" })),
+			mode: Type.Optional(Type.String({ description: "Override output mode: json | text" })),
+			tools: Type.Optional(Type.String({ description: "Override tool whitelist (comma-separated)" })),
+			extraArgs: Type.Optional(Type.String({ description: "Extra raw CLI args (space-separated)" })),
 		}),
 		async execute(toolCallId, params, signal, onUpdate, ctx) {
 			const agent = agents.find((a) => a.name === params.agent);
@@ -616,6 +767,16 @@ export default function (pi: ExtensionAPI) {
 			// Fix #3: Report progress via onUpdate
 			onUpdate?.({ state: "running", message: `🤖 正在委派 ${agent.name} 处理...` });
 
+			// Build SubagentArgs from optional tool params
+			const toolArgs: SubagentArgs = {};
+			if (params.thinkingLevel !== undefined) toolArgs.thinkingLevel = params.thinkingLevel as string;
+			if (params.session !== undefined) toolArgs.session = params.session as boolean;
+			if (params.noContext !== undefined) toolArgs.noContext = params.noContext as boolean;
+			if (params.noExtensions !== undefined) toolArgs.noExtensions = params.noExtensions as boolean;
+			if (params.mode !== undefined) toolArgs.mode = params.mode as string;
+			if (params.tools !== undefined) toolArgs.tools = (params.tools as string).split(",").map(t => t.trim()).filter(Boolean);
+			if (params.extraArgs !== undefined) toolArgs.extraArgs = (params.extraArgs as string).split(/\s+/).filter(Boolean);
+
 			const result = await spawnSubagent(
 				agent,
 				params.task,
@@ -625,6 +786,7 @@ export default function (pi: ExtensionAPI) {
 				(progress) => {
 					onUpdate?.({ state: "running", message: progress });
 				},
+				Object.keys(toolArgs).length > 0 ? toolArgs : undefined,
 			);
 			const output = extractFinalOutput(result.output);
 			const dur = (result.durationMs / 1000).toFixed(1);

package/extensions/ui-helpers.ts

@@ -309,6 +309,8 @@ export function uiInput(
 export interface WorkflowSubStepWidgetState {
     agent: string;
     status: "pending" | "running" | "done" | "failed";
+    /** Thinking level for this agent ("off" | "low" | "medium" | "high" | "xhigh") */
+    thinkingLevel?: string;
     /** Recent tool activity (e.g. "edit:src/main.rs", "read:config.json") */
     tools?: string[];
     /** Output file paths */
@@ -357,6 +359,8 @@ export interface WorkflowWidgetState {
     updatedAt: string;
     /** Human-readable task summary shown in widget header, e.g. "[feat - 在 auth 中实现登录]" */
     taskSummary?: string;
+    /** Workflow UUID for cross-file traceability */
+    workflowId?: string;
 }
 
 // ── Widget component builder ─────────────────────────────────
@@ -440,6 +444,9 @@ function buildWidgetLines(state: WorkflowWidgetState, theme: Theme, expanded: bo
                 ? theme.fg("error", "✗")
                 : theme.fg("warning", "■");
     lines.push(`${glyph} 工作流 · ${dim(theme, modeLabel)} · ${dim(theme, formatDurationFull(elapsed))}`);
+    if (state.workflowId) {
+        lines.push(`   ${dim(theme, `UUID: ${state.workflowId}`)}`);
+    }
 
     // ── Step list ──
     for (let i = 0; i < state.steps.length; i++) {
@@ -466,20 +473,6 @@ function buildWidgetLines(state: WorkflowWidgetState, theme: Theme, expanded: bo
             icon = dim(theme, "◦");
         }
 
-        // ── Duration ──
-        let displayDurMs: number | undefined = s.durationMs;
-        if (isRunning && s.startedAt) {
-            displayDurMs = Date.now() - s.startedAt;
-        }
-        const durStr =
-            displayDurMs != null
-                ? dim(theme, ` (${formatDurationFull(displayDurMs)}`)
-                : isRunning
-                  ? dim(theme, ` (0s`)
-                  : "";
-        const timeout = s.timeoutMs ? dim(theme, `/超时时间${formatTimeout(s.timeoutMs)}`) : "";
-        const durClose = displayDurMs != null || isRunning ? dim(theme, ")") : "";
-
         // ── Loop count (第 N 次循环) for loop-group steps ──
         let loopStr = "";
         if (s.loopCount != null && s.loopCount > 0) {
@@ -520,8 +513,8 @@ function buildWidgetLines(state: WorkflowWidgetState, theme: Theme, expanded: bo
             stepIndent = "      ";
         }
 
-        // ── Step line ──
-        lines.push(`${stepIndent}${icon} ${labelStyle}${loopStr}${durStr}${timeout}${durClose}`);
+        // ── Step line (注意：计时/超时信息只在子代理行展示，不在父步骤行展示) ──
+        lines.push(`${stepIndent}${icon} ${labelStyle}${loopStr}`);
 
         // ── Sub-steps (agents with |__ tree) ──
         if (s.subSteps && s.subSteps.length > 0) {
@@ -550,11 +543,14 @@ function buildWidgetLines(state: WorkflowWidgetState, theme: Theme, expanded: bo
                 let subDurStr = "";
                 let subTimeoutStr = "";
                 let subDurClose = "";
+                // ⭐ 修复：已完成/失败的子代理使用记录的 durationMs，运行中使用 live 计时
                 let elapsedMs: number | undefined;
-                if (sub.startedAt) {
-                    elapsedMs = Date.now() - sub.startedAt;
-                } else if (sub.durationMs != null) {
+                if (isSubDone || sub.status === "failed") {
+                    // 已完成/失败 → 使用最终记录的 durationMs（代理完成时已冻结）
                     elapsedMs = sub.durationMs;
+                } else if (isSubRunning && sub.startedAt) {
+                    // 运行中 → 实时计算从 startedAt 到现在的时长
+                    elapsedMs = Date.now() - sub.startedAt;
                 }
                 if (elapsedMs != null) {
                     subDurStr = dim(theme, ` (${formatDurationFull(elapsedMs)}`);
@@ -570,7 +566,8 @@ function buildWidgetLines(state: WorkflowWidgetState, theme: Theme, expanded: bo
                     subDurClose = dim(theme, ")");
                 }
                 const agentConnector = dim(theme, "|__");
-                lines.push(`${agentIndent}${agentConnector} ${subIcon} ${sub.agent} ·${subDurStr}${subTimeoutStr}${subDurClose}`);
+                const thinkingTag = sub.thinkingLevel ? dim(theme, `thinking-${sub.thinkingLevel} `) : "";
+                lines.push(`${agentIndent}${agentConnector} ${subIcon} ${sub.agent} · ${thinkingTag}${subDurStr}${subTimeoutStr}${subDurClose}`);
 
                 // ── Children (tools, outputs, or "正在排队") ──
                 const childItems: string[] = [];
@@ -1011,6 +1008,7 @@ export function sendWorkflowResult(
         `[${taskSummary}]`,
         "",
         `${resultIcon} **工作流${statusText}** (${totalDur})`,
+        state.workflowId ? `工作流 UUID: \`${state.workflowId}\`` : "",
         "",
         stepSummaryParts.join("\n"),
         "",
@@ -1058,6 +1056,7 @@ export function buildWidgetState(
     status: WorkflowWidgetState["status"],
     extra?: { toolCount?: number; tokenCount?: number },
     taskSummary?: string,
+    workflowId?: string,
 ): WorkflowWidgetState {
     return {
         mode,
@@ -1069,6 +1068,7 @@ export function buildWidgetState(
         toolCount: extra?.toolCount,
         tokenCount: extra?.tokenCount,
         taskSummary,
+        workflowId,
     };
 }