@ferris1225/pi-subagents 0.9.0 → 0.11.0

package/src/setup.ts

@@ -15,6 +15,7 @@ import {
 	DEFAULT_CONFIG,
 	DEFAULT_ENABLED_AGENTS,
 	DEFAULT_MAX_CONCURRENCY,
+	DEFAULT_MAX_FIX_ROUNDS,
 	DEFAULT_MAX_PARALLEL_TASKS,
 	THINKING_LEVEL_VALUES,
 	type AgentScope,
@@ -27,9 +28,19 @@ import {
 } from "./config.ts";
 import { availableModelRefs, repairUnavailableModelOverrides } from "./models.ts";
 import { promptSelectMany, promptSelectOne } from "./ui.ts";
+import { loadBuiltinAgents } from "./agents.ts";
 
 const INHERIT = "__inherit__";
 
+/** Effective per-agent default strength from builtin frontmatter (config overrides win at spawn). */
+function builtinThinkingDefaults(): Map<string, ThinkingLevel> {
+	const map = new Map<string, ThinkingLevel>();
+	for (const agent of loadBuiltinAgents()) {
+		if (agent.thinking) map.set(agent.name, agent.thinking);
+	}
+	return map;
+}
+
 /** Short, selection-friendly descriptions for the built-in agents. */
 const MODULE_HINTS: Record<string, string> = {
 	explore: "read-only codebase recon (fast model)",
@@ -65,20 +76,24 @@ async function pickEnabledAgents(
 	);
 }
 
-async function pickAgentModels(
+async function pickAgentModelsAndStrength(
 	ctx: ExtensionCommandContext,
 	enabledAgents: readonly string[],
-	current: Record<string, string>,
-): Promise<Record<string, string> | undefined> {
+	currentModels: Record<string, string>,
+	currentStrengths: Record<string, ThinkingLevel>,
+	defaultLevel: ThinkingLevel,
+	defaults: ReadonlyMap<string, ThinkingLevel>,
+): Promise<{ models: Record<string, string>; strengths: Record<string, ThinkingLevel> } | undefined> {
 	const refs = availableModelRefs(ctx);
 	if (refs.length === 0) {
 		ctx.ui.notify("No Pi models are currently available; model overrides left unchanged.", "warning");
-		return { ...current };
+		return { models: { ...currentModels }, strengths: { ...currentStrengths } };
 	}
 
-	const result: Record<string, string> = {};
+	const models: Record<string, string> = {};
+	const strengths: Record<string, ThinkingLevel> = {};
 	for (const name of enabledAgents) {
-		const currentRef = current[name];
+		const currentRef = currentModels[name];
 		const items = [
 			{
 				value: INHERIT,
@@ -95,9 +110,15 @@ async function pickAgentModels(
 			items,
 		);
 		if (choice === undefined) return undefined; // Esc aborts the whole wizard
-		if (choice !== INHERIT) result[name] = choice;
+		if (choice !== INHERIT) models[name] = choice;
+
+		// Convenience: the model pick is immediately followed by the strength pick,
+		// so per-agent model + strength are configured in one pass.
+		const strength = await pickAgentStrength(ctx, name, currentStrengths[name], defaultLevel, defaults);
+		if (strength === undefined) return undefined; // Esc aborts the whole wizard
+		if (strength !== INHERIT) strengths[name] = strength;
 	}
-	return result;
+	return { models, strengths };
 }
 
 const THINKING_LEVEL_HINTS: Record<ThinkingLevel, string> = {
@@ -107,9 +128,52 @@ const THINKING_LEVEL_HINTS: Record<ThinkingLevel, string> = {
 	medium: "balanced reasoning",
 	high: "deep reasoning",
 	xhigh: "extra-deep reasoning",
-	max: "strongest reasoning (default)",
+	max: "strongest reasoning",
 };
 
+/** Single strength pick for one agent; the inherit option keeps the effective default. */
+async function pickAgentStrength(
+	ctx: ExtensionCommandContext,
+	agentName: string,
+	current: ThinkingLevel | undefined,
+	defaultLevel: ThinkingLevel,
+	defaults: ReadonlyMap<string, ThinkingLevel>,
+): Promise<ThinkingLevel | typeof INHERIT | undefined> {
+	const options = THINKING_LEVEL_VALUES.map((level) => ({
+		value: level,
+		label: current === level ? `${level} — ${THINKING_LEVEL_HINTS[level]} (current)` : `${level} — ${THINKING_LEVEL_HINTS[level]}`,
+	}));
+	const agentDefault = defaults.get(agentName);
+	const inheritLabel = agentDefault
+		? `(inherit agent default — ${agentDefault})`
+		: `(inherit global default — ${defaultLevel})`;
+	const choice = await promptSelectOne(
+		ctx,
+		`Thinking strength for "${agentName}"?`,
+		"Type to filter • ↑/↓ • Enter selects • Esc cancels setup",
+		[{ value: INHERIT, label: inheritLabel }, ...options],
+	);
+	if (choice === undefined) return undefined;
+	return choice === INHERIT ? INHERIT : (choice as ThinkingLevel);
+}
+
+/** Strength picks for every enabled agent (inherit keeps the effective default). */
+async function pickAgentStrengths(
+	ctx: ExtensionCommandContext,
+	enabledAgents: readonly string[],
+	currentStrengths: Record<string, ThinkingLevel>,
+	defaultLevel: ThinkingLevel,
+	defaults: ReadonlyMap<string, ThinkingLevel>,
+): Promise<Record<string, ThinkingLevel> | undefined> {
+	const strengths: Record<string, ThinkingLevel> = {};
+	for (const name of enabledAgents) {
+		const strength = await pickAgentStrength(ctx, name, currentStrengths[name], defaultLevel, defaults);
+		if (strength === undefined) return undefined; // Esc aborts
+		if (strength !== INHERIT) strengths[name] = strength;
+	}
+	return strengths;
+}
+
 async function pickThinkingLevel(
 	ctx: ExtensionCommandContext,
 	current: ThinkingLevel,
@@ -117,7 +181,7 @@ async function pickThinkingLevel(
 	const options = THINKING_LEVEL_VALUES.map((level) =>
 		level === current ? `${level} — ${THINKING_LEVEL_HINTS[level]} (current)` : `${level} — ${THINKING_LEVEL_HINTS[level]}`,
 	);
-	const choice = await ctx.ui.select("Sub-agent thinking strength?", options);
+	const choice = await ctx.ui.select("Default thinking strength for sub-agents?", options);
 	if (choice === undefined) return undefined;
 	return THINKING_LEVEL_VALUES.find((level) => choice.startsWith(`${level} —`));
 }
@@ -133,6 +197,8 @@ async function pickInjection(ctx: ExtensionCommandContext, current: boolean): Pr
 /** Preset steps offered for the two numeric limits (selection-only wizard). */
 const CONCURRENCY_STEPS = [1, 2, 3, 4, 6, 8, 12, 16];
 const PARALLEL_TASK_STEPS = [2, 4, 6, 8, 12, 16, 24, 32];
+/** Preset rounds offered for the auto-fix loop (0 disables it). */
+const FIX_ROUNDS_STEPS = [0, 1, 2, 3, 5];
 
 async function pickCount(
 	ctx: ExtensionCommandContext,
@@ -202,12 +268,14 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 	const enabled = await pickEnabledAgents(ctx, base.enabledAgents);
 	if (enabled === undefined) return notifyCancelled(ctx);
 
-	const models = await pickAgentModels(ctx, enabled, base.agentModels);
-	if (models === undefined) return notifyCancelled(ctx);
-
+	// Global default first, so per-agent strength picks can show "inherit" against it.
 	const thinkingLevel = await pickThinkingLevel(ctx, base.thinkingLevel);
 	if (thinkingLevel === undefined) return notifyCancelled(ctx);
 
+	const defaults = builtinThinkingDefaults();
+	const picked = await pickAgentModelsAndStrength(ctx, enabled, base.agentModels, base.agentThinkingLevels, thinkingLevel, defaults);
+	if (picked === undefined) return notifyCancelled(ctx);
+
 	const injection = await pickInjection(ctx, base.proactiveInjection);
 	if (injection === undefined) return notifyCancelled(ctx);
 
@@ -230,17 +298,30 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		base.maxParallelTasks,
 		DEFAULT_MAX_PARALLEL_TASKS,
 	);
-	if (maxParallelTasks === undefined) return notifyCancelled(ctx);
+		if (maxParallelTasks === undefined) return notifyCancelled(ctx);
 
-	const next: SubagentsConfig = {
+		const maxFixRounds = await pickCount(
+			ctx,
+			"Auto-fix rounds when a reviewer returns REQUEST_CHANGES? (0 = main agent handles fixes)",
+			FIX_ROUNDS_STEPS,
+			base.maxFixRounds,
+			DEFAULT_MAX_FIX_ROUNDS,
+		);
+		if (maxFixRounds === undefined) return notifyCancelled(ctx);
+
+		const next: SubagentsConfig = {
 		enabledAgents: enabled,
-		agentModels: repairStaleModels(ctx, models),
+		agentModels: repairStaleModels(ctx, picked.models),
+		agentThinkingLevels: picked.strengths,
 		thinkingLevel,
+		notifyOnReviewPass: base.notifyOnReviewPass,
+		maxResultLines: base.maxResultLines,
 		proactiveInjection: injection,
 		agentScope: scope,
 		maxConcurrency,
 		maxParallelTasks,
 		maxSubagentDepth: base.maxSubagentDepth,
+		maxFixRounds,
 	};
 	await saveConfig(next, configPath);
 	ctx.ui.notify(`pi-subagents configured. Saved to ${configPath}`, "info");
@@ -255,6 +336,7 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 		"Change agent scope",
 		"Change max concurrent sub-agents",
 		"Change max parallel tasks",
+		"Change max fix rounds",
 		"Full re-setup",
 	]);
 	if (choice === undefined) return notifyCancelled(ctx);
@@ -268,13 +350,26 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 		if (enabled === undefined) return notifyCancelled(ctx);
 		next.enabledAgents = enabled;
 	} else if (choice.startsWith("Change agent models")) {
-		const models = await pickAgentModels(ctx, config.enabledAgents, config.agentModels);
-		if (models === undefined) return notifyCancelled(ctx);
-		next.agentModels = repairStaleModels(ctx, models);
+		const defaults = builtinThinkingDefaults();
+		const picked = await pickAgentModelsAndStrength(
+			ctx,
+			config.enabledAgents,
+			config.agentModels,
+			config.agentThinkingLevels,
+			config.thinkingLevel,
+			defaults,
+		);
+		if (picked === undefined) return notifyCancelled(ctx);
+		next.agentModels = repairStaleModels(ctx, picked.models);
+		next.agentThinkingLevels = picked.strengths;
 	} else if (choice.startsWith("Change thinking")) {
+		// Global first so per-agent "inherit" labels reflect the value that will be stored.
 		const thinkingLevel = await pickThinkingLevel(ctx, config.thinkingLevel);
 		if (thinkingLevel === undefined) return notifyCancelled(ctx);
 		next.thinkingLevel = thinkingLevel;
+		const strengths = await pickAgentStrengths(ctx, config.enabledAgents, config.agentThinkingLevels, thinkingLevel, builtinThinkingDefaults());
+		if (strengths === undefined) return notifyCancelled(ctx);
+		next.agentThinkingLevels = strengths;
 	} else if (choice.startsWith("Toggle")) {
 		const injection = await pickInjection(ctx, config.proactiveInjection);
 		if (injection === undefined) return notifyCancelled(ctx);
@@ -303,6 +398,16 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 		);
 		if (maxParallelTasks === undefined) return notifyCancelled(ctx);
 		next.maxParallelTasks = maxParallelTasks;
+	} else if (choice.startsWith("Change max fix")) {
+		const maxFixRounds = await pickCount(
+			ctx,
+			"Auto-fix rounds when a reviewer returns REQUEST_CHANGES? (0 = main agent handles fixes)",
+			FIX_ROUNDS_STEPS,
+			config.maxFixRounds,
+			DEFAULT_MAX_FIX_ROUNDS,
+		);
+		if (maxFixRounds === undefined) return notifyCancelled(ctx);
+		next.maxFixRounds = maxFixRounds;
 	}
 
 	await saveConfig(next, configPath);

package/src/spawn.ts

@@ -11,8 +11,8 @@
  */
 
 import { spawn, type ChildProcess } from "node:child_process";
+import { existsSync, mkdirSync, unlinkSync, rmdirSync, writeFileSync } from "node:fs";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { existsSync, unlinkSync, rmdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
@@ -51,6 +51,8 @@ export interface SingleResult {
 	stderr: string;
 	usage: UsageStats;
 	model?: string;
+	/** Effective thinking strength this run was launched with. */
+	thinking?: string;
 	stopReason?: string;
 	errorMessage?: string;
 }
@@ -88,6 +90,54 @@ export function getFinalOutput(messages: Message[]): string {
 	return "";
 }
 
+/**
+ * Parse the machine-readable verdict a reviewer emits (see agents/reviewer.md).
+ * Only the LAST standalone `VERDICT: REVIEW_PASS/FAIL` line counts, so a report
+ * that merely discusses the tokens cannot be misclassified. Returns undefined
+ * when no verdict marker is present, so non-review agents are never mistaken
+ * for reviews.
+ */
+export function reviewVerdict(output: string): "pass" | "fail" | undefined {
+	const lines = output.split("\n");
+	for (let index = lines.length - 1; index >= 0; index--) {
+		const match = /^\s*VERDICT:\s*REVIEW_(PASS|FAIL)\s*$/i.exec(lines[index]);
+		if (match) return match[1].toUpperCase() === "PASS" ? "pass" : "fail";
+	}
+	return undefined;
+}
+
+/** Hard cap for a single line inside a truncated result (minified blobs must not blow up). */
+export const RESULT_LINE_MAX = 200;
+
+export interface TruncatedOutput {
+	/** The result text that fits in the completion message. */
+	text: string;
+	/** True when lines were dropped or shortened, so the full text is written to disk. */
+	truncated: boolean;
+}
+
+/** Cap result text for the main conversation: keep the first `maxLines` lines, at most RESULT_LINE_MAX chars each. */
+export function truncateResultOutput(output: string, maxLines: number): TruncatedOutput {
+	const lines = output.split("\n");
+	if (lines.length <= maxLines && lines.every((line) => line.length <= RESULT_LINE_MAX)) {
+		return { text: output, truncated: false };
+	}
+	const kept = lines.slice(0, maxLines).map((line) =>
+		line.length > RESULT_LINE_MAX ? `${line.slice(0, RESULT_LINE_MAX)}…` : line,
+	);
+	return { text: kept.join("\n"), truncated: true };
+}
+
+/** Persist the full result where the main agent can read it on demand. Returns the file path. */
+export function writeResultArtifact(output: string, agentName: string): string {
+	const dir = join(tmpdir(), "pi-subagents-results");
+	mkdirSync(dir, { recursive: true });
+	const safeName = agentName.replace(/[^\w.-]+/g, "_");
+	const filePath = join(dir, `${Date.now()}-${safeName}.md`);
+	writeFileSync(filePath, output, "utf8");
+	return filePath;
+}
+
 export function isFailedResult(result: SingleResult): boolean {
 	return result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
 }
@@ -238,6 +288,7 @@ export async function runSingleAgent(options: RunSingleOptions): Promise<SingleR
 		stderr: "",
 		usage: emptyUsage(),
 		model: agent.model,
+		thinking: thinkingLevel,
 	};
 
 	const emitUpdate = (): void => {