pi-subagents 0.40.0 → 0.41.0

package/src/watchdog/model-selection.ts

@@ -132,13 +132,13 @@ function findFamilyMatch(family: StrongWatchdogFamily, availableModels: ModelInf
 function resolveStrongCandidate(ctx: ExtensionContext, family: StrongWatchdogFamily): WatchdogModelRecommendation | undefined {
 	const availableModels = modelRegistryEntries(ctx);
 	const preference = STRONG_WATCHDOG_MODELS[family];
-	const queries = [...preference.queries];
+	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);
+			resolved = resolveWatchdogModelInput(ctx, query as Parameters<typeof resolveWatchdogModelInput>[1]);
 		} catch {
 			continue;
 		}

package/src/watchdog/permission-arbiter.ts

@@ -0,0 +1,145 @@
+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 { 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);
+		const finish = (approved: boolean, reason: string, decision: string): WatchdogPermissionResult => {
+			appendPermissionAudit(request.auditPath, {
+				type: "permission.decision",
+				createdAt: Date.now(),
+				requestCreatedAt: createdAt,
+				toolName: request.toolName,
+				decision,
+				approved,
+				decisionSource: "watchdog",
+				reason: conciseReason(reason),
+			});
+			return { approved, reason: conciseReason(reason), 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;
+		try {
+			const config = childResolvedConfig(childConfig);
+			const selection = await resolveWatchdogReviewModel(request.ctx, config);
+			const auth = selection.auth;
+			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: { ...(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,
+				streamFunction: 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",
+			});
+			const abort = () => agent?.abort();
+			request.signal?.addEventListener("abort", abort, { once: true });
+			request.ctx.signal?.addEventListener("abort", abort, { once: true });
+			try {
+				const prompt = `Tool: ${request.toolName}\nRedacted arguments: ${preview}`;
+				await Promise.race([
+					agent.prompt(prompt),
+					new Promise<never>((_, reject) => { timeout = setTimeout(() => { agent?.abort(); reject(new Error("Watchdog permission decision timed out.")); }, childConfig.agentEndTimeoutMs); }),
+				]);
+			} finally {
+				request.signal?.removeEventListener("abort", abort);
+				request.ctx.signal?.removeEventListener("abort", abort);
+			}
+			if (!decision) return finish(false, "Watchdog permission arbiter returned no decision.", "malformed");
+			const approved = decision.decision === "approve";
+			return finish(approved, decision.reason, decision.decision);
+		} 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);
+		}
+	};
+}
+
+export const requestWatchdogPermission = createWatchdogPermissionArbiter();

package/src/watchdog/register-child.ts

@@ -12,7 +12,7 @@ import {
 } from "./child-status.ts";
 import type { ResolvedWatchdogConfig, WatchdogWarningDetails } from "./types.ts";
 
-function childResolvedConfig(config: ChildWatchdogConfig): ResolvedWatchdogConfig {
+export function childResolvedConfig(config: ChildWatchdogConfig): ResolvedWatchdogConfig {
 	return {
 		...DEFAULT_WATCHDOG_CONFIG,
 		enabled: true,

package/src/watchdog/register-main.ts

@@ -184,7 +184,7 @@ function resolveModelCommandValue(ctx: ExtensionCommandContext, raw: string): {
 	const resolved = resolveWatchdogModelInput(ctx as ExtensionContext, value);
 	return {
 		model: resolved.model,
-		thinking: resolved.thinking,
+		thinking: resolved.thinking ?? null,
 		description: `${resolved.model}${resolved.thinking ? `:${resolved.thinking}` : ""}`,
 	};
 }

package/src/watchdog/review.ts

@@ -93,6 +93,9 @@ function resolveConfiguredModel(ctx: ExtensionContext, rawModel: string): { mode
 	const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const preferredProvider = typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined;
 	const resolved = resolveModelCandidate(rawModel, availableModels, preferredProvider);
+	if (!resolved) {
+		throw new Error(`Configured watchdog model '${rawModel}' did not match exactly one authenticated available model. Use provider/model or configure credentials for the intended provider.`);
+	}
 	const { baseModel } = splitKnownThinkingSuffix(resolved);
 	const named = splitProviderModel(baseModel);
 	if (!named) {
@@ -109,7 +112,7 @@ function resolveConfiguredModel(ctx: ExtensionContext, rawModel: string): { mode
 
 async function resolveReviewAuth(ctx: ExtensionContext, model: RegistryModel): Promise<WatchdogReviewAuth> {
 	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-	if (!auth.ok) throw new Error(`Watchdog model auth failed for ${fullModelId(model)}: ${auth.error}`);
+	if (auth.ok === false) throw new Error(`Watchdog model auth failed for ${fullModelId(model)}: ${auth.error}`);
 	return {
 		...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
 		...(auth.headers ? { headers: auth.headers } : {}),

package/src/watchdog/runtime.ts

@@ -602,8 +602,9 @@ export class MainWatchdogRuntime {
 				return "timeout";
 			}
 			if (!this.isCurrent(reviewEpoch, reviewId)) return "stale";
-			for (const warning of result?.warnings ?? []) this.acceptWarning(reviewEpoch, reviewId, warning);
-			if (result?.stopReason && result.stopReason !== "stop") {
+			if (!result) return "stale";
+			for (const warning of result.warnings ?? []) this.acceptWarning(reviewEpoch, reviewId, warning);
+			if (result.stopReason && result.stopReason !== "stop") {
 				this.fail(`Watchdog review ended with stop reason '${result.stopReason}'.`);
 				return "completed";
 			}

package/src/workflows/chat-progress.ts

@@ -0,0 +1,140 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Details } from "../shared/types.ts";
+
+export const WORKFLOW_CHAT_PROGRESS_MODES = ["auto", "off", "terminal", "milestones", "live-card"] as const;
+export type WorkflowChatProgressMode = typeof WORKFLOW_CHAT_PROGRESS_MODES[number];
+export type ResolvedWorkflowChatProgressMode = Exclude<WorkflowChatProgressMode, "auto">;
+
+export interface GitRepositoryIdentity {
+	root: string;
+	commonDir: string;
+}
+
+export interface WorkflowChatProgressProjection {
+	mode: ResolvedWorkflowChatProgressMode;
+	repoRelation: "same" | "other";
+	repoLabel?: string;
+}
+
+interface ResolveWorkflowChatProgressInput {
+	requested: unknown;
+	parentCwd: string;
+	workflowCwd: string;
+	background: boolean;
+}
+
+function git(cwd: string, args: string[]): string | undefined {
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	if (result.status !== 0) return undefined;
+	const output = result.stdout.trim();
+	return output || undefined;
+}
+
+function realPath(value: string): string {
+	try {
+		return fs.realpathSync.native(value);
+	} catch {
+		return path.resolve(value);
+	}
+}
+
+export function resolveGitRepositoryIdentity(cwd: string): GitRepositoryIdentity | undefined {
+	if (git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== "true") return undefined;
+	const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+	const commonDir = git(cwd, ["rev-parse", "--git-common-dir"]);
+	if (!root || !commonDir) return undefined;
+	const commonDirPath = path.isAbsolute(commonDir)
+		? commonDir
+		: [path.resolve(cwd, commonDir), path.resolve(root, commonDir)].find((candidate) => fs.existsSync(candidate)) ?? path.resolve(root, commonDir);
+	return {
+		root: realPath(root),
+		commonDir: realPath(commonDirPath),
+	};
+}
+
+function isSameGitRepositoryIdentity(left: GitRepositoryIdentity | undefined, right: GitRepositoryIdentity | undefined): boolean {
+	if (!left || !right) return false;
+	return left.commonDir === right.commonDir || left.root === right.root;
+}
+
+export function isSameGitRepository(leftCwd: string, rightCwd: string): boolean {
+	return isSameGitRepositoryIdentity(resolveGitRepositoryIdentity(leftCwd), resolveGitRepositoryIdentity(rightCwd));
+}
+
+function normalizeRequestedMode(value: unknown): { mode?: WorkflowChatProgressMode; error?: string } {
+	if (value === undefined) return { mode: "auto" };
+	if (typeof value !== "string" || !WORKFLOW_CHAT_PROGRESS_MODES.includes(value as WorkflowChatProgressMode)) {
+		return { error: `chatProgress must be one of: ${WORKFLOW_CHAT_PROGRESS_MODES.join(", ")}.` };
+	}
+	return { mode: value as WorkflowChatProgressMode };
+}
+
+export function resolveWorkflowChatProgress(input: ResolveWorkflowChatProgressInput): { projection?: WorkflowChatProgressProjection; error?: string } {
+	const requested = normalizeRequestedMode(input.requested);
+	if (requested.error) return { error: requested.error };
+	const parentIdentity = resolveGitRepositoryIdentity(input.parentCwd);
+	const workflowIdentity = resolveGitRepositoryIdentity(input.workflowCwd);
+	const sameRepo = !!(
+		parentIdentity
+		&& workflowIdentity
+		&& (parentIdentity.commonDir === workflowIdentity.commonDir || parentIdentity.root === workflowIdentity.root)
+	);
+	const repoLabel = workflowIdentity ? path.basename(workflowIdentity.root) : undefined;
+	const repoRelation = sameRepo ? "same" : "other";
+
+	const requestedMode = requested.mode ?? "auto";
+	let mode: ResolvedWorkflowChatProgressMode;
+	if (requestedMode === "auto") mode = sameRepo ? (input.background ? "milestones" : "live-card") : "terminal";
+	else mode = requestedMode;
+
+	if (mode === "live-card" && !sameRepo) return { error: "chatProgress: 'live-card' is only available for workflowScript runs in the same Git repository." };
+	if (mode === "live-card" && input.background) return { error: "chatProgress: 'live-card' requires a watched foreground workflow; pass async:false." };
+	return { projection: { mode, repoRelation, ...(repoLabel ? { repoLabel } : {}) } };
+}
+
+export interface WorkflowChatProgressRow {
+	key: string;
+	state: "running" | "complete" | "failed";
+	label?: string;
+	phase?: string;
+	runId?: string;
+	durationMs?: number;
+	error?: string;
+}
+
+function cleanLabel(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+export function buildWorkflowChatProgressRows(trace: NonNullable<Details["workflow"]>["trace"]): WorkflowChatProgressRow[] {
+	const rows = new Map<string, WorkflowChatProgressRow>();
+	for (const entry of trace) {
+		if (entry.operation !== "run") continue;
+		const existing = rows.get(entry.key);
+		if (entry.state === "reused") {
+			if (existing) {
+				const label = cleanLabel(entry.label);
+				const phase = cleanLabel(entry.phase);
+				if (label) existing.label = label;
+				if (phase) existing.phase = phase;
+			}
+			continue;
+		}
+		const next: WorkflowChatProgressRow = existing ?? { key: entry.key, state: "running" };
+		next.state = entry.state === "completed" ? "complete" : entry.state === "failed" ? "failed" : "running";
+		const label = cleanLabel(entry.label);
+		const phase = cleanLabel(entry.phase);
+		if (label) next.label = label;
+		if (phase) next.phase = phase;
+		if (entry.runId === undefined) delete next.runId;
+		else next.runId = entry.runId;
+		if (entry.durationMs === undefined) delete next.durationMs;
+		else next.durationMs = entry.durationMs;
+		if (entry.error === undefined) delete next.error;
+		else next.error = entry.error;
+		rows.set(entry.key, next);
+	}
+	return [...rows.values()];
+}