pi-subagents 0.34.0 → 0.35.0

package/src/watchdog/model-selection.ts

@@ -0,0 +1,167 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { normalizeModelSegment, resolveModelCandidate } from "../runs/shared/model-fallback.ts";
+import {
+	getSupportedThinkingLevels,
+	splitKnownThinkingSuffix,
+	THINKING_LEVELS,
+	toModelInfo,
+	type ModelInfo,
+	type ThinkingLevel,
+} from "../shared/model-info.ts";
+
+export const STRONG_WATCHDOG_THINKING: ThinkingLevel = "high";
+
+const STRONG_WATCHDOG_MODELS = {
+	opus48: {
+		label: "Opus 4.8",
+		queries: [
+			"anthropic/claude-opus-4-8",
+			"anthropic/claude-opus-4.8",
+			"anthropic/opus-4-8",
+			"anthropic/opus-4.8",
+		],
+	},
+	gpt55: {
+		label: "GPT 5.5",
+		queries: [
+			"openai-codex/gpt-5.5",
+			"openai-codex/gpt-5-5",
+			"openai/gpt-5.5",
+			"openai/gpt-5-5",
+		],
+	},
+} as const;
+
+type StrongWatchdogFamily = keyof typeof STRONG_WATCHDOG_MODELS;
+
+type RegistryModel = ReturnType<ExtensionContext["modelRegistry"]["find"]>;
+
+export interface ResolvedWatchdogModelInput {
+	model: string;
+	thinking?: ThinkingLevel;
+	registryModel: NonNullable<RegistryModel>;
+}
+
+export interface WatchdogModelRecommendation {
+	model: string;
+	thinking: ThinkingLevel;
+	label: string;
+	reason: string;
+	registryModel: NonNullable<RegistryModel>;
+}
+
+function fullModelId(model: Pick<ModelInfo, "provider" | "id">): string {
+	return `${model.provider}/${model.id}`;
+}
+
+function modelRegistryEntries(ctx: ExtensionContext): ModelInfo[] {
+	return ctx.modelRegistry.getAvailable().map(toModelInfo);
+}
+
+function splitProviderModel(value: string): { provider: string; id: string } | undefined {
+	const slashIndex = value.indexOf("/");
+	if (slashIndex <= 0 || slashIndex === value.length - 1) return undefined;
+	return { provider: value.slice(0, slashIndex), id: value.slice(slashIndex + 1) };
+}
+
+function assertSupportedThinking(value: string, source: string): ThinkingLevel {
+	if ((THINKING_LEVELS as readonly string[]).includes(value)) return value as ThinkingLevel;
+	throw new Error(`Unsupported watchdog thinking '${value}' from ${source}; expected ${THINKING_LEVELS.join(", ")}, false, or inherit.`);
+}
+
+export function parseWatchdogThinkingInput(value: string | false | undefined, source = "watchdog input"): ThinkingLevel | false | undefined {
+	if (value === undefined || value === "") return undefined;
+	if (value === false) return false;
+	if (value === "false") return false;
+	return assertSupportedThinking(value, source);
+}
+
+export function resolveWatchdogModelInput(ctx: ExtensionContext, rawModel: string): ResolvedWatchdogModelInput {
+	const trimmed = rawModel.trim();
+	if (!trimmed) throw new Error("Watchdog model must be a non-empty provider/model value.");
+	const availableModels = modelRegistryEntries(ctx);
+	const preferredProvider = typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined;
+	const resolved = resolveModelCandidate(trimmed, availableModels, preferredProvider) ?? trimmed;
+	const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(resolved);
+	const named = splitProviderModel(baseModel);
+	if (!named) throw new Error(`Watchdog model '${rawModel}' did not resolve to provider/model. Use a provider-qualified model such as openai-codex/gpt-5.5:high or anthropic/claude-opus-4-8:high.`);
+	const registryModel = ctx.modelRegistry.find(named.provider, named.id);
+	if (!registryModel) throw new Error(`Watchdog model '${rawModel}' was not found as '${baseModel}'.`);
+	if (!ctx.modelRegistry.hasConfiguredAuth(registryModel)) {
+		throw new Error(`Watchdog model '${baseModel}' is not authenticated. Configure credentials for provider '${named.provider}' or choose an authenticated model.`);
+	}
+	return {
+		model: `${named.provider}/${named.id}`,
+		...(thinkingSuffix ? { thinking: assertSupportedThinking(thinkingSuffix.slice(1), "watchdog model suffix") } : {}),
+		registryModel,
+	};
+}
+
+function familyForModel(model: Pick<ModelInfo, "provider" | "id"> | undefined): StrongWatchdogFamily | undefined {
+	if (!model) return undefined;
+	const provider = normalizeModelSegment(model.provider);
+	const id = normalizeModelSegment(model.id);
+	if (provider.includes("openai") && /^gpt-5-5(-\d{8}|-\d{4}-\d{2}-\d{2})?$/.test(id)) return "gpt55";
+	if (provider.includes("anthropic") && /^(claude-opus-4-8|opus-4-8)(-\d{8}|-\d{4}-\d{2}-\d{2})?$/.test(id)) return "opus48";
+	return undefined;
+}
+
+function currentProviderFamily(ctx: ExtensionContext): "openai" | "anthropic" | undefined {
+	const provider = typeof ctx.model?.provider === "string" ? normalizeModelSegment(ctx.model.provider) : "";
+	if (provider.includes("openai")) return "openai";
+	if (provider.includes("anthropic")) return "anthropic";
+	return undefined;
+}
+
+function strongFamilyOrder(ctx: ExtensionContext): StrongWatchdogFamily[] {
+	const current = ctx.model ? familyForModel(toModelInfo(ctx.model)) : undefined;
+	if (current === "gpt55") return ["opus48"];
+	if (current === "opus48") return ["gpt55"];
+	const providerFamily = currentProviderFamily(ctx);
+	if (providerFamily === "openai") return ["opus48", "gpt55"];
+	if (providerFamily === "anthropic") return ["gpt55", "opus48"];
+	return ["gpt55", "opus48"];
+}
+
+function findFamilyMatch(family: StrongWatchdogFamily, availableModels: ModelInfo[]): string | undefined {
+	const matches = availableModels.filter((entry) => familyForModel(entry) === family);
+	if (matches.length === 1) return matches[0]!.fullId;
+	return undefined;
+}
+
+function resolveStrongCandidate(ctx: ExtensionContext, family: StrongWatchdogFamily): WatchdogModelRecommendation | undefined {
+	const availableModels = modelRegistryEntries(ctx);
+	const preference = STRONG_WATCHDOG_MODELS[family];
+	const queries = [...preference.queries];
+	const familyMatch = findFamilyMatch(family, availableModels);
+	if (familyMatch) queries.push(familyMatch);
+	for (const query of queries) {
+		let resolved: ResolvedWatchdogModelInput;
+		try {
+			resolved = resolveWatchdogModelInput(ctx, query);
+		} catch {
+			continue;
+		}
+		const modelInfo = toModelInfo(resolved.registryModel);
+		if (familyForModel(modelInfo) !== family) continue;
+		if (!getSupportedThinkingLevels(modelInfo).includes(STRONG_WATCHDOG_THINKING)) continue;
+		const current = ctx.model ? fullModelId(toModelInfo(ctx.model)) : "no current session model";
+		return {
+			model: resolved.model,
+			thinking: STRONG_WATCHDOG_THINKING,
+			label: preference.label,
+			reason: `Use ${preference.label} with thinking high as a strong independent watchdog for ${current}.`,
+			registryModel: resolved.registryModel,
+		};
+	}
+	return undefined;
+}
+
+export function recommendStrongWatchdogModel(ctx: ExtensionContext): WatchdogModelRecommendation {
+	for (const family of strongFamilyOrder(ctx)) {
+		const recommendation = resolveStrongCandidate(ctx, family);
+		if (recommendation) return recommendation;
+	}
+	const current = ctx.model ? fullModelId(toModelInfo(ctx.model)) : "the current session";
+	throw new Error(`No authenticated strong complementary watchdog model was found for ${current}. Configure access to Opus 4.8 or GPT 5.5, then run the recommendation again.`);
+}

package/src/watchdog/register-child.ts

@@ -0,0 +1,117 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { MainWatchdogRuntime } from "./runtime.ts";
+import { createMainWatchdogReview } from "./review.ts";
+import { DEFAULT_WATCHDOG_CONFIG } from "./settings.ts";
+import { createWatchdogWarningMessage } from "./warning-format.ts";
+import {
+	CHILD_WATCHDOG_CONFIG_ENV,
+	CHILD_WATCHDOG_STATUS_EVENT,
+	decodeChildWatchdogConfig,
+	type ChildWatchdogConfig,
+	type ChildWatchdogPhase,
+} from "./child-status.ts";
+import type { ResolvedWatchdogConfig, WatchdogWarningDetails } from "./types.ts";
+
+function childResolvedConfig(config: ChildWatchdogConfig): ResolvedWatchdogConfig {
+	return {
+		...DEFAULT_WATCHDOG_CONFIG,
+		enabled: true,
+		agentEndTimeoutMs: config.agentEndTimeoutMs,
+		maxWarnings: config.maxWarnings,
+		main: {
+			enabled: true,
+			...(config.model ? { model: config.model } : {}),
+			...(config.thinking !== undefined ? { thinking: config.thinking } : {}),
+		},
+		autoFollow: {
+			blockers: config.autoFollowBlockers,
+			maxAttempts: config.autoFollowMaxAttempts,
+			stalemateRepeats: config.stalemateRepeats,
+		},
+		children: {
+			...DEFAULT_WATCHDOG_CONFIG.children,
+			watchdogTailTimeoutMs: config.watchdogTailTimeoutMs,
+		},
+		lsp: { ...config.lsp },
+	};
+}
+
+function childWarningDetails(details: WatchdogWarningDetails, config: ChildWatchdogConfig): WatchdogWarningDetails {
+	return {
+		...details,
+		source: details.source === "lsp" ? "lsp" : "child",
+		...(config.agent ? { agent: config.agent } : {}),
+		...(config.runId ? { runId: config.runId } : {}),
+	};
+}
+
+function writeStatus(event: unknown): void {
+	try {
+		process.stdout.write(`${JSON.stringify(event)}\n`);
+	} catch {
+		// Child watchdog status is advisory; stdout failures are handled by the child process itself.
+	}
+}
+
+export function registerChildWatchdog(pi: ExtensionAPI, rawConfig = process.env[CHILD_WATCHDOG_CONFIG_ENV]): MainWatchdogRuntime | undefined {
+	const childConfig = decodeChildWatchdogConfig(rawConfig);
+	if (!childConfig?.enabled) return undefined;
+	let currentContext: ExtensionContext | undefined;
+	let seq = 0;
+	const emitStatus = (phase: ChildWatchdogPhase, followUpPending = false, reason?: string): void => {
+		writeStatus({
+			type: CHILD_WATCHDOG_STATUS_EVENT,
+			...(childConfig.runId ? { runId: childConfig.runId } : {}),
+			...(childConfig.agent ? { agent: childConfig.agent } : {}),
+			...(childConfig.childIndex !== undefined ? { childIndex: childConfig.childIndex, stepIndex: childConfig.childIndex } : {}),
+			seq: ++seq,
+			phase,
+			ts: Date.now(),
+			followUpPending,
+			...(reason ? { reason } : {}),
+		});
+	};
+	const resolved = childResolvedConfig(childConfig);
+	const runtime = new MainWatchdogRuntime({
+		resolveConfig: () => ({ ok: true, config: resolved, errors: [], sources: [{ scope: "session", exists: true }] }),
+		review: createMainWatchdogReview(() => currentContext, { getThinkingLevel: () => pi.getThinkingLevel() }),
+		reviewDescription: "child model review",
+		reviewChangesOnly: true,
+		displayWarning: (details) => {
+			const childDetails = childWarningDetails(details, childConfig);
+			pi.sendMessage(createWatchdogWarningMessage(childDetails, { display: true, details: childDetails }));
+		},
+	});
+	const rememberContext = (ctx: ExtensionContext) => {
+		currentContext = ctx;
+	};
+	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: unknown, ctx: ExtensionContext) => unknown) => void;
+	onRuntimeEvent("session_start", (_event, ctx) => {
+		rememberContext(ctx);
+		runtime.bindSession(ctx);
+		emitStatus("idle");
+	});
+	onRuntimeEvent("before_agent_start", (event, ctx) => {
+		rememberContext(ctx);
+		runtime.handleBeforeAgentStart(event, ctx);
+	});
+	onRuntimeEvent("turn_end", (event, ctx) => {
+		rememberContext(ctx);
+		runtime.handleTurnEnd(event, ctx);
+	});
+	onRuntimeEvent("agent_end", async (event, ctx) => {
+		rememberContext(ctx);
+		emitStatus("reviewing");
+		await runtime.handleAgentEnd(event, ctx);
+		const snapshot = runtime.getSnapshot(ctx.cwd);
+		if (snapshot.status === "failed") emitStatus("failed", false, snapshot.lastError);
+		else if (snapshot.status === "stale") emitStatus("stale", false, "review stale");
+		else emitStatus("idle");
+	});
+	onRuntimeEvent("session_shutdown", () => {
+		currentContext = undefined;
+		runtime.dispose();
+		emitStatus("idle");
+	});
+	return runtime;
+}