pi-subagents 0.69.0 → 0.70.0

package/src/watchdog/model-selection.ts

@@ -1,187 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { normalizeModelSegment, resolveModelCandidate } from "../runs/shared/model-resolution.ts";
-import type { WatchdogEndpointConfig } from "./types.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 {
-	source: "configured" | "suggested";
-	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: string[] = [...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 as Parameters<typeof resolveWatchdogModelInput>[1]);
-		} 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 {
-			source: "suggested",
-			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.`);
-}
-
-export function recommendWatchdogModel(ctx: ExtensionContext, configured: WatchdogEndpointConfig): WatchdogModelRecommendation {
-	if (!configured.model) return recommendStrongWatchdogModel(ctx);
-	const resolved = resolveWatchdogModelInput(ctx, configured.model);
-	const thinking = resolved.thinking ?? parseWatchdogThinkingInput(configured.thinking) ?? "off";
-	return {
-		...resolved,
-		source: "configured",
-		thinking: thinking === false ? "off" : thinking,
-		label: "configured watchdog",
-		reason: "Keep the configured watchdog model and thinking; no replacement recommendation is needed. This is not a strength or independence assessment.",
-	};
-}
-
-export function formatWatchdogRecommendation(recommendation: WatchdogModelRecommendation): string {
-	return `${recommendation.source === "configured" ? "Keep configured watchdog" : "Recommended strong watchdog"}: ${recommendation.model}:${recommendation.thinking}`;
-}

package/src/watchdog/permission-arbiter.ts

@@ -1,156 +0,0 @@
-import { Agent, type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
-import { convertToLlm, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
-import { Type, type Static } from "typebox";
-import { appendPermissionAudit, permissionArgsPreview } from "../runs/shared/permissions.ts";
-import { agentStreamOptions } from "../shared/agent-stream-options.ts";
-import { opencodeSessionHeaders } from "../shared/opencode-session-headers.ts";
-import { decodeChildWatchdogConfig } from "./child-status.ts";
-import { childResolvedConfig } from "./register-child.ts";
-import { resolveWatchdogReviewModel } from "./review.ts";
-
-const PermissionDecisionParams = Type.Object({
-	decision: Type.String({ enum: ["approve", "deny"] }),
-	reason: Type.String({ description: "One concise reason for this exact decision." }),
-}, { additionalProperties: false });
-
-type PermissionDecisionParams = Static<typeof PermissionDecisionParams>;
-
-export interface WatchdogPermissionResult {
-	approved: boolean;
-	reason: string;
-	source: "watchdog";
-}
-
-export interface WatchdogPermissionRequest {
-	ctx: ExtensionContext;
-	toolName: string;
-	args: unknown;
-	rawWatchdogConfig?: string;
-	auditPath?: string;
-	signal?: AbortSignal;
-}
-
-export interface WatchdogPermissionArbiterOptions {
-	streamFn?: StreamFn;
-}
-
-function conciseReason(value: string): string {
-	const trimmed = value.trim();
-	return trimmed ? trimmed.slice(0, 500) : "Watchdog returned an empty reason.";
-}
-
-export function createWatchdogPermissionArbiter(options: WatchdogPermissionArbiterOptions = {}) {
-	return async (request: WatchdogPermissionRequest): Promise<WatchdogPermissionResult> => {
-		const preview = permissionArgsPreview(request.args);
-		const createdAt = Date.now();
-		const auditBase = { type: "permission.request", createdAt, toolName: request.toolName, preview, matchedRule: "ask", decisionSource: "watchdog" };
-		appendPermissionAudit(request.auditPath, auditBase);
-		let completed = false;
-		const finish = (approved: boolean, reason: string, decision: string): WatchdogPermissionResult => {
-			const concise = conciseReason(reason);
-			if (completed) return { approved, reason: concise, source: "watchdog" };
-			completed = true;
-			appendPermissionAudit(request.auditPath, {
-				type: "permission.decision",
-				createdAt: Date.now(),
-				requestCreatedAt: createdAt,
-				toolName: request.toolName,
-				decision,
-				approved,
-				decisionSource: "watchdog",
-				reason: concise,
-			});
-			return { approved, reason: concise, source: "watchdog" };
-		};
-
-		let childConfig;
-		try {
-			childConfig = decodeChildWatchdogConfig(request.rawWatchdogConfig);
-		} catch (error) {
-			const reason = error instanceof Error ? error.message : String(error);
-			return finish(false, `Watchdog permission arbiter configuration is invalid: ${reason}`, "unavailable");
-		}
-		if (!childConfig) return finish(false, "Watchdog permission arbiter is unavailable because the child watchdog is disabled.", "unavailable");
-		if (request.signal?.aborted || request.ctx.signal?.aborted) return finish(false, "Watchdog permission decision was cancelled.", "cancelled");
-
-		let decision: PermissionDecisionParams | undefined;
-		const tool: AgentTool<typeof PermissionDecisionParams, { recorded: boolean }> = {
-			name: "watchdog_permission_decision",
-			label: "Watchdog permission decision",
-			description: "Approve or deny this exact child tool call. Call exactly once.",
-			parameters: PermissionDecisionParams,
-			executionMode: "sequential",
-			async execute(_toolCallId, params) {
-				if (!decision) decision = params;
-				return { content: [{ type: "text", text: "Permission decision recorded." }], details: { recorded: true } };
-			},
-		};
-
-		let timeout: ReturnType<typeof setTimeout> | undefined;
-		let agent: Agent | undefined;
-		let abort: (() => void) | undefined;
-		try {
-			const run = async (): Promise<WatchdogPermissionResult> => {
-				const config = childResolvedConfig(childConfig);
-				const selection = await resolveWatchdogReviewModel(request.ctx, config);
-				const auth = selection.auth;
-				const sessionId = request.ctx.sessionManager.getSessionId();
-				const registeredProvider = (request.ctx.modelRegistry as {
-					getRegisteredProviderConfig?: (provider: string) => { api?: string; streamSimple?: StreamFn } | undefined;
-				}).getRegisteredProviderConfig?.(selection.model.provider);
-				const baseStreamFn = options.streamFn ?? (registeredProvider?.streamSimple && registeredProvider.api === selection.model.api
-					? registeredProvider.streamSimple
-					: streamSimple);
-				const streamFn: StreamFn = (model, context, streamOptions) => baseStreamFn(model, context, {
-					...streamOptions,
-					...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
-					env: auth.env || streamOptions?.env ? { ...(auth.env ?? {}), ...(streamOptions?.env ?? {}) } : undefined,
-					headers: { ...opencodeSessionHeaders(model, sessionId), ...(streamOptions?.headers ?? {}), ...(auth.headers ?? {}) },
-				});
-				agent = new Agent({
-					initialState: {
-						systemPrompt: [
-							"You are the pi-subagents watchdog permission arbiter.",
-							"Decide only whether this exact non-bash child tool call should proceed.",
-							"Call watchdog_permission_decision exactly once with approve or deny and a concise reason.",
-							"Deny when uncertain. Do not produce freeform advice or ask the parent orchestrator.",
-						].join("\n"),
-						model: selection.model,
-						thinkingLevel: selection.thinkingLevel,
-						tools: [tool],
-					},
-					convertToLlm,
-					...agentStreamOptions(streamFn),
-					getApiKey: (providerName) => providerName === selection.model.provider ? auth.apiKey : undefined,
-					beforeToolCall: async ({ toolCall }) => toolCall.name === tool.name ? undefined : { block: true, reason: `Permission arbiter tool '${toolCall.name}' is not allowed.` },
-					toolExecution: "sequential",
-				});
-				await agent.prompt(`Tool: ${request.toolName}\nRedacted arguments: ${preview}`);
-				if (!decision) return finish(false, "Watchdog permission arbiter returned no decision.", "malformed");
-				const approved = decision.decision === "approve";
-				return finish(approved, decision.reason, decision.decision);
-			};
-			return await Promise.race([
-				run(),
-				new Promise<WatchdogPermissionResult>((resolve) => { timeout = setTimeout(() => { agent?.abort(); resolve(finish(false, "Watchdog permission decision timed out.", "timeout")); }, childConfig.agentEndTimeoutMs); }),
-				new Promise<WatchdogPermissionResult>((resolve) => {
-					abort = () => { agent?.abort(); resolve(finish(false, "Watchdog permission decision was cancelled.", "cancelled")); };
-					request.signal?.addEventListener("abort", abort, { once: true });
-					request.ctx.signal?.addEventListener("abort", abort, { once: true });
-				}),
-			]);
-		} catch (error) {
-			const reason = error instanceof Error ? error.message : String(error);
-			return finish(false, `Watchdog permission arbiter failed closed: ${reason}`, reason.includes("timed out") ? "timeout" : "error");
-		} finally {
-			if (timeout) clearTimeout(timeout);
-			if (abort) {
-				request.signal?.removeEventListener("abort", abort);
-				request.ctx.signal?.removeEventListener("abort", abort);
-			}
-		}
-	};
-}
-
-export const requestWatchdogPermission = createWatchdogPermissionArbiter();

package/src/watchdog/register-child.ts

@@ -1,128 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { captureWatchdogDiffBaseline, type WatchdogDiffBaseline } from "./diff-tool.ts";
-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_STATUS_EVENT,
-	type ChildWatchdogConfig,
-	type ChildWatchdogPhase,
-	type ChildWatchdogStatusEvent,
-} from "./child-status.ts";
-import type { ChildWatchdogWarningSummary } from "../shared/types.ts";
-import { SUBAGENT_WATCHDOG_WARNING_TYPE, type ResolvedWatchdogConfig, type WatchdogWarningDetails } from "./types.ts";
-
-export 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 } : {}),
-		},
-		stalemateRepeats: config.stalemateRepeats,
-		cadence: { ...config.cadence },
-		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 } : {}),
-	};
-}
-
-/**
- * Register the child-side watchdog. Status events go to the sink the hosting
- * process passed in the child runtime config; the host folds them into the
- * child's event stream.
- */
-export function registerChildWatchdog(
-	pi: ExtensionAPI,
-	childConfig: ChildWatchdogConfig | undefined,
-	writeStatus: ((event: ChildWatchdogStatusEvent) => void) | undefined,
-): MainWatchdogRuntime | undefined {
-	if (!childConfig) return undefined;
-	if (!writeStatus) throw new Error("Child watchdog status sink is missing; the host must pass ChildRuntimeConfig.watchdogStatus.");
-	let currentContext: ExtensionContext | undefined;
-	let diffBaseline: WatchdogDiffBaseline | undefined;
-	let seq = 0;
-	const emitStatus = (phase: ChildWatchdogPhase, reason?: string, warning?: ChildWatchdogWarningSummary): 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(),
-			...(reason ? { reason } : {}),
-			...(warning ? { warning } : {}),
-		});
-	};
-	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(), diffBaseline: () => diffBaseline }),
-		reviewDescription: "child model review",
-		reviewChangesOnly: true,
-		displayWarning: (details, options) => {
-			const childDetails = childWarningDetails(details, childConfig);
-			emitStatus("reviewing", undefined, { severity: childDetails.severity, importance: childDetails.importance, category: childDetails.category, summary: childDetails.summary, evidence: childDetails.evidence, recommendedAction: childDetails.recommendedAction, ...(childDetails.displayedAt ? { displayedAt: childDetails.displayedAt } : {}), addressed: false, stalemate: childDetails.state === "stalemate" });
-			pi.sendMessage(createWatchdogWarningMessage(childDetails, { display: true, details: childDetails }), options);
-		},
-		displayUserWarning: (details) => {
-			const childDetails = childWarningDetails(details, childConfig);
-			emitStatus("reviewing", undefined, { severity: childDetails.severity, importance: childDetails.importance, category: childDetails.category, summary: childDetails.summary, evidence: childDetails.evidence, recommendedAction: childDetails.recommendedAction, ...(childDetails.displayedAt ? { displayedAt: childDetails.displayedAt } : {}), addressed: false, stalemate: childDetails.state === "stalemate" });
-			pi.appendEntry(SUBAGENT_WATCHDOG_WARNING_TYPE, 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);
-		diffBaseline = captureWatchdogDiffBaseline(ctx.cwd);
-		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("tool_result", (_event, ctx) => {
-		rememberContext(ctx);
-		runtime.handleToolResult(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", snapshot.lastError);
-		else if (snapshot.status === "stale") emitStatus("stale", "review stale");
-		else emitStatus("idle");
-	});
-	onRuntimeEvent("session_shutdown", () => {
-		currentContext = undefined;
-		runtime.dispose();
-		emitStatus("idle");
-	});
-	return runtime;
-}