@selesai/code 0.13.12 → 0.13.13

package/dist/extensions/pi-subagents/src/watchdog/permission-arbiter.ts

@@ -1,154 +0,0 @@
-import { Agent, type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
-import { convertToLlm, type ExtensionContext } from "@selesai/code";
-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 { 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 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,
-					...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/dist/extensions/pi-subagents/src/watchdog/register-child.ts

@@ -1,117 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
-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";
-
-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 } : {}),
-		},
-		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;
-}