@ferris1225/pi-subagents 4.1.18 → 4.1.21

package/src/runtime.ts

@@ -1,7 +1,7 @@
 /**
  * Shared per-session runtime state for pi-subagents.
  *
- * The extension registers several tools (subagent, subagent_wait/status/stop)
+ * The extension registers several tools (subagent, subagent_control/stop)
  * that share the background queue, completion batcher, abort controllers per
  * run, and settled-results store.
  * `createRuntime` builds those once per extension load and hands the same object
@@ -25,6 +25,7 @@ import { isRunActiveStatus, monitor } from "./monitor.ts";
 import type { RpcRunControl } from "./rpc-run.ts";
 import type { StartBackgroundInternal } from "./thread-lifecycle.ts";
 import { isFailedResult, type SingleResult } from "./spawn.ts";
+import type { ReviewMode } from "./workflow.ts";
 import type { IsolationMode, WorktreeFinalization, WorktreeIsolation } from "./worktree.ts";
 
 export type ThreadState =
@@ -50,6 +51,9 @@ export interface SubagentThread {
 	executionCwd: string;
 	thinkingLevel?: ThinkingLevel;
 	isolation: IsolationMode;
+	/** Dispatch-time gate intensity; "none" skips the automatic post-writer
+	 * reviewer for this thread (kept across resumes and reloads). */
+	review?: ReviewMode;
 	worktree?: WorktreeIsolation;
 	state: ThreadState;
 	control: RpcRunControl;
@@ -90,6 +94,13 @@ export interface SubagentRuntime {
 	/** The process-wide background dispatcher. Set at tool registration so
 	 * threads restored from the durable manifest can resume before any dispatch. */
 	dispatcher?: StartBackgroundInternal;
+	/** Resolves when the load-time durable restore pass has finished. Everything
+	 * that answers "which threads exist" awaits it — the lookup tools, a fresh
+	 * dispatch before it allocates a run id, and the restored-thread notice — so
+	 * a reload can never report parked work as missing, or hand a new run an id a
+	 * record still owns, while the manifest is being read. Resolved by default;
+	 * `bootstrapDurableState` publishes the real pass. */
+	durableRestore: Promise<void>;
 	/** Run ids restored from the durable manifest at load; consumed by the
 	 * one-time session-start notice. */
 	restoredRunIds: number[];
@@ -100,8 +111,9 @@ export interface SubagentRuntime {
 	completionBatcher: CompletionBatcher<CompletionMessageItem>;
 	/** Abort controllers per active run, so subagent_stop can cancel a run in-turn. */
 	runControllers: Map<number, AbortController>;
-	/** Final results keyed by run id, so subagent_wait can hand the model the
-	 * actual result in-turn instead of it sleeping/polling for a wake-up message. */
+	/** Final results keyed by run id, so a dispatch with wait: true can hand the
+	 * model the actual result in-turn instead of it sleeping/polling for a
+	 * wake-up message. */
 	settledRuns: Map<number, SingleResult>;
 	settledListeners: Map<number, Set<(result: SingleResult) => void>>;
 	registerRunResult: (runId: number, result: SingleResult) => void;
@@ -127,6 +139,7 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 		backgroundQueue,
 		getActiveTools: () => pi.getActiveTools(),
 		sessionActive: true,
+		durableRestore: Promise.resolve(),
 		restoredRunIds: [],
 		restoredNotified: false,
 		sendCompletionGroup: (items) => {
@@ -140,7 +153,12 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 			const active = monitor
 				.getRuns()
 				.filter((run) => isRunActiveStatus(run.status))
-				.map((run) => ({ id: run.id, agent: run.agent, label: run.label, queued: run.status === "queued" }));
+				.map((run) => ({
+					id: run.id,
+					agent: run.agent,
+					label: run.label,
+					...(run.status === "queued" && run.waitReason ? { wait: run.waitReason } : {}),
+				}));
 			const message = {
 				customType: "subagent-result",
 				content: formatCompletionMessage(items) + formatActiveRunsFooter(active),

package/src/session-fork.ts

@@ -4,6 +4,7 @@ import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { existsSync } from "node:fs";
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { join } from "node:path";
+import { writeTempOwnerMarker } from "./temp-hygiene.ts";
 
 export interface ForkedSession {
 	sessionDir: string;
@@ -53,6 +54,7 @@ export async function forkRetainedSession(options: {
 	const root = options.targetRoot;
 	await mkdir(root, { recursive: true });
 	const sessionDir = await mkdtemp(join(root, "pi-subagent-session-fork-"));
+	writeTempOwnerMarker(sessionDir);
 	try {
 		// Supplying the new directory makes createBranchedSession write there.
 		// cwdOverride rewrites the cloned header so a settled isolated session can

package/src/setup.ts

@@ -2,11 +2,10 @@
  * Interactive configuration wizard for /subagents-setup.
  *
  * The wizard stays one level deep and exposes only what most users touch:
- * which agents run, the model and thinking strength each runs on, and the
- * delegation directive toggle. Everything else (agent scope, idle timeout,
- * result lines, notifications) is config-file-only; model failures hand
- * directly to the current main model, and thinking defaults to capability-
- * aware Auto.
+ * which agents run and the model and thinking strength each runs on.
+ * Everything else (agent scope, idle timeout, result lines, notifications) is
+ * config-file-only; model failures hand directly to the current main model,
+ * and thinking defaults to capability-aware Auto.
  */
 
 import { stat } from "node:fs/promises";
@@ -40,10 +39,11 @@ import { promptSelectMany, promptSelectOne } from "./ui.ts";
 
 /** Short, selection-friendly descriptions for the built-in agents. */
 const MODULE_HINTS: Record<string, string> = {
-	explorer: "read-only codebase recon (fast model)",
+	explorer: "read-only codebase recon (fast, read-only tools)",
 	worker: "implement / fix / refactor / test (full tools)",
 	cleaner: "apply proven cleanup and deduplicate code (full tools)",
 	documenter: "sync diff or whole-codebase comments/docs (docs write)",
+	synthesizer: "merge fan-out results/long sources into one brief (read-only)",
 	reviewer: "read-only audits and pre-commit gates",
 };
 
@@ -230,14 +230,6 @@ async function configureOneAgent(
 	}
 }
 
-async function pickInjection(ctx: ExtensionCommandContext, current: boolean): Promise<boolean | undefined> {
-	const on = "On — inject the delegation directive (recommended)";
-	const off = "Off — rely on tool descriptions only";
-	const choice = await ctx.ui.select("Proactive dispatch injection?", [current ? `${on} (current)` : on, current ? off : `${off} (current)`]);
-	if (choice === undefined) return undefined;
-	return choice.startsWith("On");
-}
-
 function keepAgentEntries<T>(record: Record<string, T>, enabled: readonly string[]): Record<string, T> {
 	const keep = new Set(enabled);
 	return Object.fromEntries(Object.entries(record).filter(([name]) => keep.has(name)));
@@ -254,9 +246,6 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		agentModels = applyAgentModelChoice(agentModels, agentName, choice);
 	}
 
-	const injection = await pickInjection(ctx, base.proactiveInjection);
-	if (injection === undefined) return false;
-
 	const next: SubagentsConfig = {
 		enabledAgents: enabled,
 		agentModels,
@@ -264,7 +253,6 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		agentThinkingLevels: {},
 		notifyOnReviewPass: base.notifyOnReviewPass,
 		maxResultLines: base.maxResultLines,
-		proactiveInjection: injection,
 		agentScope: base.agentScope,
 		idleTimeoutSec: base.idleTimeoutSec,
 	};
@@ -278,7 +266,6 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 		const choice = await ctx.ui.select("pi-subagents settings", [
 			"Enable/disable agents",
 			"Configure an agent (model + thinking)",
-			"Proactive injection",
 			"Full re-setup",
 		]);
 		if (choice === undefined) return;
@@ -296,31 +283,28 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 			const enabled = await pickEnabledAgents(ctx, config.enabledAgents);
 			if (enabled === undefined) continue;
 			next.enabledAgents = enabled;
-			// Newly enabling cleaner inherits the reviewer's configured model and
-			// thinking level, so the file reflects what cleaner will actually run
-			// instead of silently falling back to the current main model.
-			if (!config.enabledAgents.includes("cleaner") && enabled.includes("cleaner")) {
-				if (!next.agentModels.cleaner && config.agentModels.reviewer) {
-					next.agentModels.cleaner = config.agentModels.reviewer;
-				}
-				if (!next.agentThinkingLevels.cleaner && config.agentThinkingLevels.reviewer) {
-					next.agentThinkingLevels.cleaner = config.agentThinkingLevels.reviewer;
+			// A newly enabled role inherits a kindred role's configured model and
+			// thinking level, so the file reflects what it will actually run
+			// instead of silently falling back to the current main model: cleaner
+			// follows the reviewer; documenter and synthesizer intentionally
+			// follow the faster explorer route.
+			const modelInheritance: ReadonlyArray<[agent: string, from: string]> = [
+				["cleaner", "reviewer"],
+				["documenter", "explorer"],
+				["synthesizer", "explorer"],
+			];
+			for (const [agent, from] of modelInheritance) {
+				if (config.enabledAgents.includes(agent) || !enabled.includes(agent)) continue;
+				if (!next.agentModels[agent] && config.agentModels[from]) {
+					next.agentModels[agent] = config.agentModels[from];
 				}
-			}
-			// Documenter intentionally follows the faster explorer route. When it
-			// is re-enabled after being explicitly disabled, it inherits any
-			// explorer overrides instead of silently choosing a stronger model.
-			if (!config.enabledAgents.includes("documenter") && enabled.includes("documenter")) {
-				if (!next.agentModels.documenter && config.agentModels.explorer) {
-					next.agentModels.documenter = config.agentModels.explorer;
-				}
-				if (!next.agentThinkingLevels.documenter && config.agentThinkingLevels.explorer) {
-					next.agentThinkingLevels.documenter = config.agentThinkingLevels.explorer;
+				if (!next.agentThinkingLevels[agent] && config.agentThinkingLevels[from]) {
+					next.agentThinkingLevels[agent] = config.agentThinkingLevels[from];
 				}
 			}
 			next.agentModels = keepAgentEntries(next.agentModels, enabled);
 			next.agentThinkingLevels = keepAgentEntries(next.agentThinkingLevels, enabled);
-		} else if (choice.startsWith("Configure")) {
+		} else {
 			// Per-agent loop: thinking Esc returns to that agent's model picker;
 			// model Esc returns to the agent picker; agent-picker Esc saves completed
 			// choices and returns to this settings menu.
@@ -338,10 +322,6 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 			ctx.ui.notify(`pi-subagents updated. Saved to ${configPath}`, "info");
 			config = next;
 			continue;
-		} else {
-			const injection = await pickInjection(ctx, next.proactiveInjection);
-			if (injection === undefined) continue;
-			next.proactiveInjection = injection;
 		}
 
 		await saveConfig(next, configPath);