@underactive/pi-topping-moa-fusion 0.1.0 → 0.3.0

package/src/planning/planMode.ts

@@ -1,7 +1,8 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { Message, TextContent } from "@earendil-works/pi-ai";
+import type { Message } from "@earendil-works/pi-ai";
 import { Key } from "@earendil-works/pi-tui";
 import type {
+	AgentBeforeSettleEvent,
 	AgentSettledEvent,
 	AgentStartEvent,
 	ExtensionAPI,
@@ -9,6 +10,7 @@ import type {
 	MessageEndEvent,
 	MessageStartEvent,
 	MessageUpdateEvent,
+	SessionBoundaryDraft,
 	ThemeColor,
 	ToolExecutionStartEvent,
 } from "@earendil-works/pi-coding-agent";
@@ -37,11 +39,20 @@ import { showCancelOverlay } from "../ui/cancelOverlay.ts";
 import { UI_TICK_MS } from "../ui/chrome.ts";
 import { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
 import { showObserveOverlay, type ObserveSession } from "../ui/observeOverlay.ts";
+import { planNamingOverlay, withWorkingOverlay } from "../ui/workingOverlay.ts";
 import { ASK_USER_QUESTION_TOOL_NAME, createAskUserQuestionTracker, isAskUserQuestionInstalled } from "./askUserQuestion.ts";
+import {
+	buildVerificationPendingMessage,
+	collectOmissionDrafts,
+	isPlanInstructionEntry,
+	isPlanModeInstructionText,
+	isVerificationPendingEntry,
+	type ScannedEntry,
+} from "./contextEdits.ts";
 import { buildPlanModeExitInstructions, buildPlanModeInstructions, buildPlanModeReentryInstructions } from "./instructions.ts";
-import { latestPlanModeStateEntry, PlanModeStatePersistence } from "./modeState.ts";
-import { getPlan, getPlanSlug, isValidPlanSlug, resetPlanSlug, saveRepoPlanFile, setPlanSlug } from "./planFile.ts";
-import { PLAN_EXIT_CONTEXT_TYPE, PLAN_MODE_CONTEXT_TYPE, PLAN_MODE_CUSTOM_TOOLS, PLAN_MODE_READ_ONLY_TOOLS, PLAN_ONLY_REGISTERED_TOOLS } from "./tools/shared.ts";
+import { latestPlanModeStateEntry, PlanModeStatePersistence, validateToolLoadoutSnapshot } from "./modeState.ts";
+import { getPlan, getPlanSlug, isValidPlanSlug, resetPlanSlug, saveRepoPlanFile, setPlanSlug, slugifyPlanName } from "./planFile.ts";
+import { PLAN_EXIT_CONTEXT_TYPE, PLAN_MODE_CONTEXT_TYPE, PLAN_MODE_CUSTOM_TOOLS, PLAN_MODE_READ_ONLY_TOOLS, PLAN_ONLY_REGISTERED_TOOLS, VERIFICATION_PENDING_CONTEXT_TYPE } from "./tools/shared.ts";
 
 /** Trailing chars of the implementer report kept for the verifier's evidence. */
 const IMPLEMENTATION_REPORT_MAX_CHARS = 8000;
@@ -85,6 +96,17 @@ function extractAssistantText(content: unknown): string {
 	return "";
 }
 
+// Existing tests and stale post-reload contexts may not expose getBranch;
+// boundary handlers should become inert rather than throw in that case.
+function readBranchEntries(ctx: ExtensionContext): readonly ScannedEntry[] {
+	try {
+		const manager = ctx.sessionManager as { getBranch?: () => readonly ScannedEntry[] };
+		return typeof manager.getBranch === "function" ? manager.getBranch() : [];
+	} catch {
+		return [];
+	}
+}
+
 export function createPlanModeController(pi: ExtensionAPI) {
 	let planModeEnabled = false;
 	let toolsBeforePlanMode: string[] | undefined;
@@ -98,6 +120,8 @@ export function createPlanModeController(pi: ExtensionAPI) {
 	let activeRunMoaInfo: MfPlanInfo | undefined;
 	let implementationHandoff: ImplementationHandoff | undefined;
 	let implementationPending = false;
+	let verificationInFlight = false;
+	const omittedEntryIds = new Set<string>();
 	let lastImplementationStopReason: string | undefined;
 	// The implementer's final assistant text, captured while pending so the
 	// verifier can be handed the implementer's own (untrusted) report. Capped to
@@ -168,6 +192,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		needsExitReminder,
 		moaInfo: activeRunMoaInfo,
 		implementationHandoff,
+		toolsBeforePlanMode,
 	});
 	const footerState = (ctx: ExtensionContext): MoaFooterState => {
 		if (footerError) return "error";
@@ -218,6 +243,21 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		const customTools = PLAN_MODE_CUSTOM_TOOLS.filter((name) => name !== ASK_USER_QUESTION_TOOL_NAME || isAskUserQuestionInstalled(pi));
 		return [...new Set([...filtered, ...customTools])];
 	};
+	/**
+	 * Every registered tool except the plan-only ones — the safe fallback when no
+	 * trustworthy snapshot exists. Note this can restore a tool the user had
+	 * deliberately deactivated; that is strictly better than leaving the
+	 * implementer read-only, and only affects sessions saved before this field
+	 * existed. Deduped because registration re-adds already-present tools.
+	 */
+	const fullLoadoutFallback = (): string[] => {
+		const registered = [...new Set(
+			pi.getAllTools().map((tool) => tool.name).filter((name) => !PLAN_ONLY_REGISTERED_TOOLS.includes(name)),
+		)];
+		// An empty registered list would strip every tool; prefer the active set.
+		if (registered.length > 0) return registered;
+		return [...new Set(pi.getActiveTools().filter((name) => !PLAN_ONLY_REGISTERED_TOOLS.includes(name)))];
+	};
 	const applyReadOnlyProviderEnv = (): void => {
 		if (providerEnvBeforePlanMode === undefined) {
 			providerEnvBeforePlanMode = {};
@@ -234,7 +274,15 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		providerEnvBeforePlanMode = undefined;
 	};
 	const enablePlanModeTools = (): void => {
-		if (toolsBeforePlanMode === undefined) toolsBeforePlanMode = pi.getActiveTools();
+		if (toolsBeforePlanMode === undefined) {
+			// 0.86.0 restores tools from the transcript before session_start, and a
+			// leaked plan-only set is possible mid-session, so an "active" set that
+			// contains plan-only tools is the plan loadout, not the user's.
+			const active = pi.getActiveTools();
+			toolsBeforePlanMode = active.some((name) => PLAN_ONLY_REGISTERED_TOOLS.includes(name))
+				? fullLoadoutFallback()
+				: active;
+		}
 		applyReadOnlyProviderEnv();
 		pi.setActiveTools(getPlanModeTools(toolsBeforePlanMode));
 	};
@@ -356,7 +404,11 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		return lastReentryState;
 	};
 	async function saveSubmittedPlanPrompt(ctx: ExtensionContext, prompt: string): Promise<void> {
-		planRepoSlug = await summarizePlanPromptName(ctx, prompt);
+		planRepoSlug = await withWorkingOverlay(
+			ctx,
+			planNamingOverlay("plan", () => slugifyPlanName(prompt)),
+			(signal) => summarizePlanPromptName(ctx, prompt, { signal }),
+		);
 		persistState();
 		saveRepoPlanFile(prompt, ctx.cwd, planRepoSlug, "plan-prompt");
 	}
@@ -397,7 +449,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 					Implement: implementationHandoff.model,
 					Verify: implementationHandoff.verifier,
 				});
-				widget.switchToImplementing(implementationHandoff.model, "implementing plan…", implementationHandoff.thinking);
+				widget.switchToImplementing(implementationHandoff.model, "implementing plan", implementationHandoff.thinking);
 				activeProgressWidget = widget;
 			}
 			if (ctx) updateStatus(ctx);
@@ -519,6 +571,63 @@ export function createPlanModeController(pi: ExtensionAPI) {
 				activeProgressWidget?.updateRoleTranscript("Implement", implementationMessages);
 			}
 		},
+		onAgentBeforeSettle: (event: AgentBeforeSettleEvent, ctx: ExtensionContext) => {
+			try {
+				const branch = readBranchEntries(ctx);
+				const persistedOmissions = new Set(
+					branch
+						.filter((entry) => entry.type === "context_edit" && entry.replacement === null && typeof entry.targetId === "string")
+						.map((entry) => entry.targetId as string),
+				);
+				// A different extension can invalidate the combined boundary proposal.
+				// Forget locally proposed edits that did not reach the branch so they are
+				// retried rather than suppressed for the rest of this process.
+				for (const id of omittedEntryIds) {
+					if (!persistedOmissions.has(id)) omittedEntryIds.delete(id);
+				}
+				const drafts: SessionBoundaryDraft[] = [];
+
+				// Persist plan-instruction omissions after plan mode exits. This is
+				// additive to onContext's per-request filter and repairs older sessions.
+				if (!planModeEnabled) {
+					drafts.push(...collectOmissionDrafts(branch, isPlanInstructionEntry, omittedEntryIds));
+				}
+				if (!verificationInFlight) {
+					drafts.push(...collectOmissionDrafts(branch, isVerificationPendingEntry, omittedEntryIds));
+				}
+
+				const stopReason = lastImplementationStopReason;
+				// KEEP IN LOCKSTEP with onAgentSettled's verification branch below.
+				// exit_plan_mode marks implementation pending before the follow-up has
+				// run, so implementationTurns distinguishes that planning boundary.
+				const verificationWillDispatch = implementationPending
+					&& implementationTurns > 0
+					&& event.context.pendingMessages.length === 0
+					&& event.outcome !== "aborted"
+					&& event.outcome !== "error"
+					&& !implementationTurnFailed(stopReason)
+					&& stopReason !== "aborted"
+					&& implementationHandoff !== undefined
+					&& (implementationHandoff.verifier ?? loadMoaConfig().verifier) !== undefined;
+				if (verificationWillDispatch) {
+					drafts.push({
+						type: "custom_message",
+						customType: VERIFICATION_PENDING_CONTEXT_TYPE,
+						content: buildVerificationPendingMessage(implementationHandoff?.planFilePath),
+						display: false,
+					});
+				}
+
+				if (drafts.length === 0) return undefined;
+				for (const draft of drafts) {
+					if (draft.type === "context_edit") omittedEntryIds.add(draft.targetId);
+				}
+				return { entries: [...event.entries, ...drafts] };
+			} catch {
+				// A thrown boundary handler could reject every proposed entry.
+				return undefined;
+			}
+		},
 		onAgentSettled: (_event: AgentSettledEvent, ctx: ExtensionContext) => {
 			updateStatus(ctx);
 			if (!implementationPending) return;
@@ -566,10 +675,13 @@ export function createPlanModeController(pi: ExtensionAPI) {
 			// explicit guard is required before the verification branch.
 			if (stopReason === "aborted") return;
 			if (!implementationHandoff) return;
+			// KEEP IN LOCKSTEP with verificationWillDispatch in onAgentBeforeSettle.
 			const verifier = implementationHandoff.verifier ?? loadMoaConfig().verifier;
 			if (verifier) {
+				verificationInFlight = true;
 				void runImplementationVerification(ctx, moaRunHost, { ...implementationHandoff, verifier }, report)
-					.catch(reportFlowFailure("Verification"));
+					.catch(reportFlowFailure("Verification"))
+					.finally(() => { verificationInFlight = false; });
 			}
 		},
 		onContext: async (event: { messages: AgentMessage[] }) => {
@@ -578,9 +690,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 				const msg = message as AgentMessage & { customType?: string };
 				if (msg.customType === PLAN_MODE_CONTEXT_TYPE || msg.customType === PLAN_EXIT_CONTEXT_TYPE) return false;
 				if (msg.role !== "user") return true;
-				if (typeof msg.content === "string") return !msg.content.startsWith("[PLAN MODE ACTIVE]") && !msg.content.startsWith("[PLAN MODE RE-ENTRY]");
-				if (Array.isArray(msg.content)) return !msg.content.some((part) => part.type === "text" && ((part as TextContent).text?.startsWith("[PLAN MODE ACTIVE]") || (part as TextContent).text?.startsWith("[PLAN MODE RE-ENTRY]")));
-				return true;
+				return !isPlanModeInstructionText(msg.content);
 			}) };
 		},
 		onBeforeAgentStart: async () => {
@@ -612,6 +722,8 @@ export function createPlanModeController(pi: ExtensionAPI) {
 			activeCancelSession = undefined;
 			activeObserveSession = undefined;
 			implementationHandoff = undefined;
+			verificationInFlight = false;
+			omittedEntryIds.clear();
 			footerError = undefined;
 			lastRenderedFooter = undefined;
 			lastFooterCtx = undefined;
@@ -625,6 +737,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 			resetPlanSlug();
 			if (pi.getFlag("mf-plan") === true) planModeEnabled = true;
 			const restored = latestPlanModeStateEntry(ctx.sessionManager.getEntries());
+			const restoredPlanModeWasEnabled = restored?.enabled === true;
 			if (restored) {
 				planModeEnabled = restored.enabled ?? planModeEnabled;
 				needsExitReminder = restored.needsExitReminder ?? false;
@@ -632,13 +745,31 @@ export function createPlanModeController(pi: ExtensionAPI) {
 				planRepoSlug = isValidPlanSlug(restored.repoPlanSlug) ? restored.repoPlanSlug : undefined;
 				activeRunMoaInfo = validateMfPlanInfo(restored.moaInfo);
 				implementationHandoff = validateImplementationHandoff(restored.implementationHandoff);
+				toolsBeforePlanMode = validateToolLoadoutSnapshot(restored.toolsBeforePlanMode);
 			}
 			if (planModeEnabled) {
 				lastReentryState = getPlan() !== null;
+				// A persisted plan-mode session had its loadout restored from the transcript
+				// before this handler ran (#9548), so the active set is the plan loadout, not
+				// the user's. Only the persisted snapshot or the registered loadout can be
+				// trusted here. The flag-only path (no entry) is excluded: there plan mode
+				// never ran, so the active set really is the user's.
+				const repairedLoadoutSnapshot = restoredPlanModeWasEnabled && toolsBeforePlanMode === undefined;
+				if (repairedLoadoutSnapshot) toolsBeforePlanMode = fullLoadoutFallback();
 				enablePlanModeTools();
+				// Re-persist the restored (and, if needed, repaired) snapshot so later
+				// resumes of this session see the same trustworthy loadout.
+				if (restoredPlanModeWasEnabled) persistState();
 			} else {
 				deactivatePlanOnlyTools();
 			}
+			try {
+				if (collectOmissionDrafts(readBranchEntries(ctx), isVerificationPendingEntry, new Set()).length > 0) {
+					ctx.ui.notify("The previous session ended before plan verification finished — the last implementation is unverified. Run /mf-plan-implement to verify it.", "warning");
+				}
+			} catch {
+				// A stale session-start context cannot be notified safely.
+			}
 			updateStatus(ctx);
 			startFooterTicker(ctx);
 			if (ctx.mode === "tui" && typeof ctx.ui.onTerminalInput === "function") {
@@ -653,6 +784,8 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		},
 		onSessionShutdown: (_event: { reason: string }) => {
 			implementationPending = false;
+			verificationInFlight = false;
+			omittedEntryIds.clear();
 			lastImplementationStopReason = undefined;
 			lastImplementationReport = undefined;
 			resetImplementationTranscript();

package/src/planning/tools/exitPlanMode.ts

@@ -7,8 +7,9 @@ import { stripSynthSections } from "../../moa/verdicts.ts";
 import { FOLLOW_UP } from "../../shared/modelRefs.ts";
 import type { MfPlanInfo, PlanReviewDecision } from "../../moa/planInfo.ts";
 import { showPlanReview } from "../../ui/planReviewOverlay.ts";
+import { planNamingOverlay, withWorkingOverlay } from "../../ui/workingOverlay.ts";
 import { ASK_USER_QUESTION_PENDING_MESSAGE } from "../askUserQuestion.ts";
-import { getPlan, getPlanFilePath, saveRepoPlanFile, writePlan } from "../planFile.ts";
+import { getPlan, getPlanFilePath, saveRepoPlanFile, slugifyPlanName, writePlan } from "../planFile.ts";
 
 import type { ImplementationHandoff } from "../../moa/implementationRetry.ts";
 
@@ -98,7 +99,11 @@ export function registerExitPlanModeTool(pi: ExtensionAPI, host: ExitPlanModeHos
 			}
 
 			if (!host.getPlanRepoSlug()) {
-				host.setPlanRepoSlug(await summarizePlanPromptName(ctx, plan));
+				host.setPlanRepoSlug(await withWorkingOverlay(
+					ctx,
+					planNamingOverlay("plan", () => slugifyPlanName(plan)),
+					(signal) => summarizePlanPromptName(ctx, plan, { signal }),
+				));
 				host.persistState();
 			}
 

package/src/planning/tools/mfPlanSubagent.ts

@@ -6,6 +6,7 @@ import { Type } from "typebox";
 import * as path from "node:path";
 
 import { installShippedAgents, shippedAgentsDir, withAuthoritativeMoaAgents } from "../../agents/authoritative.ts";
+import { loadMoaConfig } from "../../config/settings.ts";
 import { discoverAgents, parseAgentFile } from "../../agents/discovery.ts";
 import { modelExtensionOptions } from "../../moa/modelRuntime.ts";
 import { CancelRun, type CancelRowExtras, type CancelSession } from "../../runtime/cancelRun.ts";
@@ -150,6 +151,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 				// Parallel mode — each task gets its own abort signal (combined
 				// with pi's turn signal) so F4 can kill one stuck agent
 				// while its siblings keep working.
+				const maxConcurrency = loadMoaConfig().maxConcurrentAgents;
 				const tasks = params.tasks!;
 				const run = new CancelRun();
 				const extras: CancelRowExtras[] = tasks.map(() => ({}));
@@ -202,6 +204,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 								loopCount: activityLoopCount(result.activity, histories[index]),
 							};
 						},
+						{ maxConcurrency },
 					);
 
 					// resolveOnAbort makes the runner resolve on abort; rethrow so a

package/src/planning/tools/shared.ts

@@ -17,3 +17,4 @@ export const PLAN_ONLY_REGISTERED_TOOLS = ["write_plan", "exit_plan_mode", "mf_p
 export const PLAN_SUBAGENT_NAMES = new Set(["moa-explore", "mf-plan"]);
 export const PLAN_MODE_CONTEXT_TYPE = "mf-plan-context";
 export const PLAN_EXIT_CONTEXT_TYPE = "mf-plan-exit";
+export const VERIFICATION_PENDING_CONTEXT_TYPE = "mf-plan-verification-pending";

package/src/runtime/activityTracking.ts

@@ -1,8 +1,8 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
+import type { AssistantMessage, Message, ToolCall } from "@earendil-works/pi-ai";
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { StreamingWordCounter } from "../activityMeter.ts";
-import { isNonnegativeFiniteNumber, isValidContentIndex, type WireAssistantMessageEvent } from "./wire.ts";
+import { isNonnegativeFiniteNumber, isValidContentIndex } from "./wire.ts";
 
 /** Max length of a one-line tool-activity description surfaced for progress UIs. */
 const ACTIVITY_MAX = 80;
@@ -94,6 +94,19 @@ export class OutputActivityTracker {
 
 type AssistantContentPart = AssistantMessage["content"][number];
 
+/**
+ * The only fields `apply` reads. Declared structurally rather than as the wire
+ * union so both the JSON-protocol delta and the in-process
+ * `MessageUpdateEvent["assistantMessageEvent"]` are assignable — those two
+ * diverged when JSON `toolcall_start` gained required `id`/`toolName` (#7953).
+ */
+export interface PartialAssistantDelta {
+	type: string;
+	contentIndex?: number;
+	delta?: string;
+	toolCall?: ToolCall;
+}
+
 /**
  * Rebuilds the in-flight assistant message from streamed deltas.
  *
@@ -111,19 +124,22 @@ export class PartialAssistantAssembler {
 		this.#parts = [];
 	}
 
-	apply(assistantEvent: WireAssistantMessageEvent | undefined): void {
+	apply(assistantEvent: PartialAssistantDelta | undefined): void {
 		if (!assistantEvent) return;
-		if (("contentIndex" in assistantEvent && !isValidContentIndex(assistantEvent.contentIndex))) return;
-		if (assistantEvent.type === "text_delta") {
-			const part = this.#parts[assistantEvent.contentIndex];
+		const contentIndex = assistantEvent.contentIndex;
+		// Every handled delta kind is content-indexed, so an absent or out-of-range
+		// index is a no-op — same net effect as the previous `in` check.
+		if (!isValidContentIndex(contentIndex)) return;
+		if (assistantEvent.type === "text_delta" && typeof assistantEvent.delta === "string") {
+			const part = this.#parts[contentIndex];
 			if (part?.type === "text") part.text += assistantEvent.delta;
-			else this.#parts[assistantEvent.contentIndex] = { type: "text", text: assistantEvent.delta };
-		} else if (assistantEvent.type === "thinking_delta") {
-			const part = this.#parts[assistantEvent.contentIndex];
+			else this.#parts[contentIndex] = { type: "text", text: assistantEvent.delta };
+		} else if (assistantEvent.type === "thinking_delta" && typeof assistantEvent.delta === "string") {
+			const part = this.#parts[contentIndex];
 			if (part?.type === "thinking") part.thinking += assistantEvent.delta;
-			else this.#parts[assistantEvent.contentIndex] = { type: "thinking", thinking: assistantEvent.delta };
-		} else if (assistantEvent.type === "toolcall_end") {
-			this.#parts[assistantEvent.contentIndex] = assistantEvent.toolCall;
+			else this.#parts[contentIndex] = { type: "thinking", thinking: assistantEvent.delta };
+		} else if (assistantEvent.type === "toolcall_end" && assistantEvent.toolCall) {
+			this.#parts[contentIndex] = assistantEvent.toolCall;
 		}
 	}
 

package/src/runtime/processPool.ts

@@ -38,6 +38,7 @@ export async function mapWithConcurrencyLimit<TIn, TOut>(
 	items: TIn[],
 	concurrency: number,
 	fn: (item: TIn, index: number) => Promise<TOut>,
+	onStart?: (index: number) => void,
 ): Promise<TOut[]> {
 	if (items.length === 0) return [];
 	const limit = Math.max(1, Math.min(concurrency, items.length));
@@ -47,6 +48,7 @@ export async function mapWithConcurrencyLimit<TIn, TOut>(
 		while (true) {
 			const current = nextIndex++;
 			if (current >= items.length) return;
+			onStart?.(current);
 			results[current] = await fn(items[current], current);
 		}
 	});

package/src/runtime/results.ts

@@ -92,6 +92,24 @@ export function getResultOutput(result: { exitCode: number; stopReason?: string;
 	return getFinalOutput(result.messages) || "(no output)";
 }
 
+/**
+ * Longest failure message kept for a status row. Generous enough that a
+ * provider's JSON error payload survives whole for a progress table to wrap
+ * across several lines, bounded so a multi-KB stderr dump cannot crowd out the
+ * table it renders in.
+ */
+const MAX_STATUS_DETAIL_CHARS = 500;
+
+/**
+ * Collapse an agent failure into one bounded line for a progress row. Runs of
+ * whitespace — newlines included — are flattened because the row is laid out as
+ * a single line before its surface wraps it to the available width.
+ */
+export function statusDetail(output: string): string {
+	const collapsed = output.replace(/\s+/g, " ").trim();
+	return collapsed.length <= MAX_STATUS_DETAIL_CHARS ? collapsed : `${collapsed.slice(0, MAX_STATUS_DETAIL_CHARS - 1)}…`;
+}
+
 export function truncateOutput(output: string): string {
 	const maxBytes = 50 * 1024;
 	const bytes = Buffer.from(output, "utf8");

package/src/runtime/runner.ts

@@ -10,6 +10,7 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import type { AgentConfig } from "../agents/discovery.ts";
+import { normalizeMaxConcurrentAgents } from "../config/settings.ts";
 import type { ThinkingLevel } from "../shared/modelRefs.ts";
 import { OutputActivityTracker, PartialAssistantAssembler, formatToolActivity } from "./activityTracking.ts";
 import { escalateKill, mapWithConcurrencyLimit, trackedProcesses } from "./processPool.ts";
@@ -24,7 +25,6 @@ import {
 } from "./wire.ts";
 
 const MAX_PARALLEL_TASKS = 8;
-const MAX_CONCURRENCY = 5;
 const CHILD_IDLE_TIMEOUT_MS = 15 * 60 * 1000;
 const MAX_DIAGNOSTIC_CHARS = 65_536;
 const READ_ONLY_AGENT_TOOLS = ["read", "grep", "find", "ls"] as const;
@@ -94,8 +94,9 @@ export interface RunSingleAgentOptions {
 	 * Called on every streamed turn boundary (each `message_end`) with the live,
 	 * in-progress result. Lets callers observe running usage — notably
 	 * `usage.contextTokens` (the latest turn's total context size) — so a progress
-	 * widget can show a growing context-usage bar while the agent works. Providers
-	 * that run a whole task as one turn only report at the end; see
+	 * widget can show a growing context-usage bar while the agent works.
+	 * `contextTokens` advances from `message_update` usage, authoritative
+	 * `message_end` usage, and the stderr beacon; see
 	 * docs/handoff-bridge-live-context.md.
 	 */
 	onProgress?: (result: SingleResult) => void;
@@ -249,6 +250,23 @@ export async function runSingleAgent(
 					outputActivity.messageUpdate(event.assistantMessageEvent);
 					partialMessage.apply(event.assistantMessageEvent);
 					currentResult.partialAssistant = partialMessage.snapshot();
+					// Interim context reading. Providers that run a whole task as one turn emit a
+					// single message_end, so without this the CTX bar sits at 0% for the run.
+					// A malformed or absent reading is ignored rather than rejected upstream, so a
+					// bad number never costs the run its text deltas.
+					// "beacon" source: never lowers a value and never overrides an authoritative
+					// message_end reading for the same turn.
+					const liveTotal = event.usage?.totalTokens;
+					if (isValidContextTokens(liveTotal)) {
+						const reconciled = reconcileContextTokens(
+							currentResult.usage.contextTokens,
+							contextUsageIsAuthoritative,
+							liveTotal,
+							"beacon",
+						);
+						currentResult.usage.contextTokens = reconciled.contextTokens;
+						contextUsageIsAuthoritative = reconciled.authoritative;
+					}
 					emitUpdate();
 				}
 
@@ -413,6 +431,13 @@ export interface ModelParallelAgentTask extends ParallelAgentTask {
 	model: string;
 }
 
+export interface ParallelRunOptions {
+	/** Max child processes in flight. Normalized here, so an omitted or malformed value falls back to the safe default. */
+	maxConcurrency?: number;
+	/** Called once a queued task acquires a process-pool slot, immediately before it begins. */
+	onStart?: (index: number) => void;
+}
+
 /** Run multiple agents in parallel with concurrency limit. */
 export async function runParallelAgents(
 	defaultCwd: string,
@@ -422,11 +447,14 @@ export async function runParallelAgents(
 	onUpdate: ((partial: AgentToolResult<unknown>) => void) | undefined,
 	onEach?: (index: number, result: SingleResult) => void,
 	onProgress?: (index: number, result: SingleResult) => void,
+	options: ParallelRunOptions = {},
 ): Promise<SingleResult[]> {
 	if (tasks.length > MAX_PARALLEL_TASKS) {
 		throw new Error(`Too many parallel tasks (${tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`);
 	}
 
+	const maxConcurrency = normalizeMaxConcurrentAgents(options.maxConcurrency);
+
 	const allResults: SingleResult[] = new Array(tasks.length);
 
 	for (let i = 0; i < tasks.length; i++) {
@@ -441,10 +469,12 @@ export async function runParallelAgents(
 		};
 	}
 
+	const startedIndices = new Set<number>();
+
 	const emitParallelUpdate = () => {
 		if (onUpdate) {
-			const running = allResults.filter((r) => r.exitCode === -1).length;
 			const done = allResults.filter((r) => r.exitCode !== -1).length;
+			const running = startedIndices.size - done;
 			onUpdate({
 				details: undefined,
 				content: [{ type: "text", text: `Parallel: ${done}/${allResults.length} done, ${running} running...` }],
@@ -452,10 +482,10 @@ export async function runParallelAgents(
 		}
 	};
 
-	const results = await mapWithConcurrencyLimit(tasks, MAX_CONCURRENCY, async (t, index) => {
+	const results = await mapWithConcurrencyLimit(tasks, maxConcurrency, async (t, index) => {
 		const taskSignal = t.signal ?? signal;
 		if (taskSignal?.aborted) {
-			// Cancelled while queued behind MAX_CONCURRENCY — never spawn.
+			// Cancelled while queued behind the configured concurrency limit — never spawn.
 			const placeholder = cancelledPlaceholderResult(t.agent, t.task);
 			allResults[index] = placeholder;
 			emitParallelUpdate();
@@ -483,6 +513,9 @@ export async function runParallelAgents(
 		emitParallelUpdate();
 		onEach?.(index, result);
 		return result;
+	}, (index) => {
+		startedIndices.add(index);
+		options.onStart?.(index);
 	});
 
 	return results;
@@ -500,15 +533,18 @@ export async function runParallelAgentsWithModels(
 	signal: AbortSignal | undefined,
 	onEach: ((index: number, result: SingleResult) => void) | undefined,
 	onProgress?: (index: number, result: SingleResult) => void,
+	options: ParallelRunOptions = {},
 ): Promise<SingleResult[]> {
 	if (tasks.length > MAX_PARALLEL_TASKS) {
 		throw new Error(`Too many parallel tasks (${tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`);
 	}
 
-	const results = await mapWithConcurrencyLimit(tasks, MAX_CONCURRENCY, async (t, index) => {
+	const maxConcurrency = normalizeMaxConcurrentAgents(options.maxConcurrency);
+
+	const results = await mapWithConcurrencyLimit(tasks, maxConcurrency, async (t, index) => {
 		const taskSignal = t.signal ?? signal;
 		if (taskSignal?.aborted) {
-			// Cancelled while queued behind MAX_CONCURRENCY — never spawn.
+			// Cancelled while queued behind the configured concurrency limit — never spawn.
 			const placeholder = cancelledPlaceholderResult(t.agent, t.task);
 			onEach?.(index, placeholder);
 			return placeholder;
@@ -532,7 +568,7 @@ export async function runParallelAgentsWithModels(
 		);
 		onEach?.(index, result);
 		return result;
-	});
+	}, options.onStart);
 
 	return results;
 }

package/src/runtime/wire.ts

@@ -71,6 +71,17 @@ function isWireMessage(value: unknown): boolean {
 		return typeof value.content === "string"
 			|| (Array.isArray(value.content) && value.content.every((part) => isTextContent(part) || isImageContent(part)));
 	}
+	// 0.86.0 children emit a system message_start/message_end pair carrying the
+	// prompt and tool-loadout declaration. It never reaches `messages` (isLlmMessage
+	// filters it) and both trackers ignore non-assistant roles, but rejecting it
+	// here put two spurious parse errors at the head of every failure report.
+	// The pair arrives before any assistant stream, so `partialMessage.start()`
+	// clearing the in-flight partial on a non-assistant message_start loses
+	// nothing today — worth re-checking if a future protocol interleaves them.
+	if (value.role === "system") {
+		return typeof value.content === "string"
+			|| (Array.isArray(value.content) && value.content.every((part) => isTextContent(part)));
+	}
 	if (value.role === "assistant") {
 		return Array.isArray(value.content)
 			&& value.content.every((part) => isTextContent(part) || isThinkingContent(part) || isToolCall(part));