pi-subagents 0.63.0 → 0.64.0

package/src/watchdog/runtime.ts

@@ -9,7 +9,8 @@ import {
 	watchdogWarningFromLspDiagnostics,
 	type WatchdogLspDiagnosticsFunction,
 } from "./lsp-diagnostics.ts";
-import { WatchdogScopeArtifact, isWatchdogAutoFollowPromptEvent } from "./scope.ts";
+import { ruleViolationWarning, type WatchdogRuleViolation } from "./rules.ts";
+import { WatchdogScopeArtifact } from "./scope.ts";
 import { resolveWatchdogConfig } from "./settings.ts";
 import { formatWatchdogTurnDelta } from "./turn-delta.ts";
 import {
@@ -62,9 +63,8 @@ export interface WatchdogRuntimeSnapshot {
 	staleReviews: number;
 	reviewConnected: boolean;
 	reviewDescription: string;
-	autoFollowQueued: boolean;
-	autoFollowAttempts: number;
-	autoFollowStalemate: boolean;
+	boundaryRepeats: number;
+	stalemate: boolean;
 	reviewTrigger: "turn-delta" | "repo-edits";
 	changedPaths?: string[];
 	lsp: WatchdogLspRuntimeSnapshot;
@@ -80,20 +80,29 @@ interface MainWatchdogRuntimeOptions {
 	resolveConfig?: (cwd: string, options?: { session?: Record<string, unknown> }) => WatchdogSettingsResult;
 	review?: WatchdogReviewFunction;
 	reviewDescription?: string;
-	displayWarning?: (warning: WatchdogWarningDetails, options?: { deliverAs?: "steer" }) => void;
-	sendUserMessage?: (message: string) => void | Promise<void>;
+	displayWarning?: (warning: WatchdogWarningDetails, options?: WatchdogWarningSendOptions) => void;
 	reviewChangesOnly?: boolean;
 	lspDiagnostics?: WatchdogLspDiagnosticsFunction;
 	repoChangeSignature?: typeof computeWatchdogRepoChangeSignature;
 }
 
+export type WatchdogWarningSendOptions = { deliverAs: "steer" } | { triggerTurn: false };
+
 type ContextLike = Pick<ExtensionContext, "cwd">;
 type ReviewDeltaOutcome = "completed" | "timeout" | "stale";
 
 const DEFAULT_REVIEW: WatchdogReviewFunction = () => ({ warnings: [] });
 const MAX_REVIEW_INPUT_CHARS = 24_000;
+const REVIEW_INPUT_HEAD_CHARS = 6_000;
 const REVIEW_DELTA_SEPARATOR = "\n\n---\n\n";
 
+export function boundWatchdogReviewText(text: string, cap = MAX_REVIEW_INPUT_CHARS): string {
+	if (text.length <= cap) return text;
+	const head = Math.min(REVIEW_INPUT_HEAD_CHARS, Math.floor(cap / 4));
+	const marker = `\n\n[... about ${text.length - cap} characters omitted ...]\n\n`;
+	return `${text.slice(0, head)}${marker}${text.slice(text.length - (cap - head - marker.length))}`;
+}
+
 function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -116,8 +125,7 @@ export class MainWatchdogRuntime {
 	private readonly review: WatchdogReviewFunction;
 	private readonly reviewConnected: boolean;
 	private readonly reviewDescription: string;
-	private readonly displayWarning: ((warning: WatchdogWarningDetails, options?: { deliverAs?: "steer" }) => void) | undefined;
-	private readonly sendUserMessage: ((message: string) => void | Promise<void>) | undefined;
+	private readonly displayWarning: ((warning: WatchdogWarningDetails, options?: WatchdogWarningSendOptions) => void) | undefined;
 	private readonly reviewChangesOnly: boolean;
 	private readonly lspDiagnostics: WatchdogLspDiagnosticsFunction;
 	private readonly repoChangeSignature: typeof computeWatchdogRepoChangeSignature;
@@ -145,7 +153,6 @@ export class MainWatchdogRuntime {
 	private userPrompt: string | undefined;
 	private waiters: Waiter[] = [];
 	private lastWarning: WatchdogWarningDetails | undefined;
-	private displayedWarningSequence = 0;
 	private lastError: string | undefined;
 	private lastReviewInputSignature: string | undefined;
 	private turnStartChangeSignature: WatchdogRepoChangeSignature | undefined;
@@ -155,12 +162,10 @@ export class MainWatchdogRuntime {
 	private observedRepoEditThisTurn = false;
 	private toolResultsThisRun = 0;
 	private midRunReviewing = false;
-	private autoFollowQueued = false;
-	private autoFollowAttempts = 0;
-	private consecutiveAutoFollowIdentity: string | undefined;
-	private consecutiveAutoFollowRepeats = 0;
-	private autoFollowStalemate = false;
-	private pendingAutoFollowPrompts: string[] = [];
+	private lastBoundaryIdentity: string | undefined;
+	private boundaryRepeats = 0;
+	private stalemate = false;
+	private ruleWarningsThisRun = new Set<string>();
 	private midRunGeneration = 0;
 	private activeReviewAbortController: AbortController | undefined;
 	private failedReviews = 0;
@@ -173,7 +178,6 @@ export class MainWatchdogRuntime {
 		this.reviewConnected = Boolean(options.review);
 		this.reviewDescription = options.reviewDescription ?? (options.review ? "injected seam" : "not wired");
 		this.displayWarning = options.displayWarning;
-		this.sendUserMessage = options.sendUserMessage;
 		this.reviewChangesOnly = options.reviewChangesOnly === true;
 		this.lspDiagnostics = options.lspDiagnostics ?? collectWatchdogLspDiagnostics;
 		this.repoChangeSignature = options.repoChangeSignature ?? computeWatchdogRepoChangeSignature;
@@ -189,7 +193,8 @@ export class MainWatchdogRuntime {
 		this.sessionOverrideEnabled = undefined;
 		this.sessionModelOverride = undefined;
 		this.refreshConfig(ctx.cwd);
-		this.reset("session_start", { clearReviewInputSignature: true, resetChangeSignature: true, clearLspLedger: true, clearScope: true, resetAutoFollow: true });
+		this.reset("session_start", { clearReviewInputSignature: true, resetChangeSignature: true, clearLspLedger: true, clearScope: true });
+		this.resetBoundaryRepeats();
 	}
 
 	refreshConfig(cwd = this.cwd): WatchdogSettingsResult {
@@ -247,7 +252,7 @@ export class MainWatchdogRuntime {
 		return this.getSnapshot();
 	}
 
-	reset(_reason = "reset", options: { clearReviewInputSignature?: boolean; resetChangeSignature?: boolean; clearLspLedger?: boolean; clearScope?: boolean; resetAutoFollow?: boolean } = {}): void {
+	reset(_reason = "reset", options: { clearReviewInputSignature?: boolean; resetChangeSignature?: boolean; clearLspLedger?: boolean; clearScope?: boolean } = {}): void {
 		this.abortActiveAgentEnd();
 		this.epoch++;
 		this.status = "idle";
@@ -263,16 +268,12 @@ export class MainWatchdogRuntime {
 		this.observedRepoEditThisTurn = false;
 		this.toolResultsThisRun = 0;
 		this.midRunReviewing = false;
-		this.autoFollowQueued = false;
+		this.ruleWarningsThisRun.clear();
 		if (options.clearLspLedger) {
 			this.lspLedger.reset();
 			this.lastLspSnapshot = undefined;
 		}
-		if (options.clearScope) {
-			this.scope.reset();
-			this.pendingAutoFollowPrompts = [];
-		}
-		if (options.resetAutoFollow) this.resetAutoFollowState();
+		if (options.clearScope) this.scope.reset();
 		if (options.clearReviewInputSignature) this.lastReviewInputSignature = undefined;
 		if (options.resetChangeSignature) this.resetRepoChangeBaseline({ reviewed: true });
 		this.guard.reset();
@@ -297,22 +298,17 @@ export class MainWatchdogRuntime {
 		this.observedRepoEditThisTurn = false;
 		this.toolResultsThisRun = 0;
 		this.midRunReviewing = false;
-		this.autoFollowQueued = false;
 		this.resolveWaiters(false);
 	}
 
 	handleBeforeAgentStart(event: unknown, ctx: ContextLike): void {
 		if (this.disposed) return;
 		const incomingPrompt = promptFromBeforeAgentStart(event);
-		// Only exact queued auto-follow text is treated as an auto-follow turn; a real user
-		// prompt racing in ahead of one stays real and the pending matches survive for later.
-		const pendingIndex = incomingPrompt === undefined ? -1 : this.pendingAutoFollowPrompts.indexOf(incomingPrompt);
-		const autoFollowPrompt = pendingIndex >= 0 || isWatchdogAutoFollowPromptEvent(event);
-		if (pendingIndex >= 0) this.pendingAutoFollowPrompts.splice(pendingIndex, 1);
-		this.reset("before_agent_start", { resetAutoFollow: !autoFollowPrompt });
+		this.reset("before_agent_start");
+		this.resetBoundaryRepeats();
 		this.refreshConfig(ctx.cwd);
 		this.userPrompt = incomingPrompt;
-		if (!autoFollowPrompt && this.userPrompt?.trim()) {
+		if (this.userPrompt?.trim()) {
 			this.includeUserPromptInNextDelta = true;
 			this.scope.addPrompt(this.userPrompt);
 		} else {
@@ -383,8 +379,6 @@ export class MainWatchdogRuntime {
 		const lspAbortController = new AbortController();
 		this.activeAgentEndId = agentEndId;
 		this.activeAgentEndAbortController = lspAbortController;
-		let displayedDuringAgentEnd: WatchdogWarningDetails | undefined;
-		const previousDisplayedSequence = this.displayedWarningSequence;
 		try {
 			this.guard.startModelUpdate();
 			const lspBlock = await this.collectLspDiagnostics(changeSignature, {
@@ -425,8 +419,6 @@ export class MainWatchdogRuntime {
 				this.currentChangedPaths = changeSignature?.changedPaths;
 				this.status = "idle";
 			}
-			displayedDuringAgentEnd = this.displayedWarningSequence !== previousDisplayedSequence ? this.lastWarning : undefined;
-			this.queueAutoFollowIfNeeded(displayedDuringAgentEnd);
 			this.resolveWaiters(true);
 		} finally {
 			if (this.activeAgentEndAbortController === lspAbortController) this.activeAgentEndAbortController = undefined;
@@ -434,6 +426,14 @@ export class MainWatchdogRuntime {
 		}
 	}
 
+	displayRuleWarning(violation: WatchdogRuleViolation): void {
+		if (this.disposed || this.ruleWarningsThisRun.has(violation.summary)) return;
+		this.ruleWarningsThisRun.add(violation.summary);
+		const details = normalizeWatchdogWarningDetails(ruleViolationWarning(violation), { state: "displayed", displayedAt: new Date().toISOString() });
+		this.lastWarning = details;
+		this.displayWarning?.(details, { deliverAs: "steer" });
+	}
+
 	recordDisplayedWarning(warning: WatchdogWarning): WatchdogWarningDetails {
 		const details = normalizeWatchdogWarningDetails(warning, { state: "displayed", source: warning.source ?? "main" });
 		this.lastWarning = details;
@@ -460,9 +460,8 @@ export class MainWatchdogRuntime {
 			staleReviews: this.staleReviews,
 			reviewConnected: this.reviewConnected,
 			reviewDescription: this.reviewDescription,
-			autoFollowQueued: this.autoFollowQueued,
-			autoFollowAttempts: this.autoFollowAttempts,
-			autoFollowStalemate: this.autoFollowStalemate,
+			boundaryRepeats: this.boundaryRepeats,
+			stalemate: this.stalemate,
 			reviewTrigger: this.reviewChangesOnly ? "repo-edits" : "turn-delta",
 			...(this.currentChangedPaths?.length ? { changedPaths: [...this.currentChangedPaths] } : {}),
 			lsp: this.lspSnapshot(),
@@ -497,7 +496,7 @@ export class MainWatchdogRuntime {
 
 	private acceptWarning(epoch: number, reviewId: number, warning: WatchdogWarning): boolean {
 		if (!this.isCurrent(epoch, reviewId) || !this.isEnabled() || !this.warningMeetsThreshold(warning)) return false;
-		const decision = this.guard.evaluate(warning);
+		const decision = this.guard.evaluate(warning, { allowRepeatOf: this.repeatableBoundaryIdentity() });
 		if (!decision.accepted) return false;
 		const details = normalizeWatchdogWarningDetails(warning, {
 			state: "candidate",
@@ -511,7 +510,7 @@ export class MainWatchdogRuntime {
 
 	private displayBoundaryWarning(warning: WatchdogWarning): boolean {
 		if (!this.isEnabled() || !this.warningMeetsThreshold(warning)) return false;
-		const decision = this.guard.evaluate(warning);
+		const decision = this.guard.evaluate(warning, { allowRepeatOf: this.repeatableBoundaryIdentity() });
 		if (!decision.accepted) return false;
 		const details = normalizeWatchdogWarningDetails(warning, {
 			state: "displayed",
@@ -519,9 +518,7 @@ export class MainWatchdogRuntime {
 			identity: decision.identity,
 			displayedAt: new Date().toISOString(),
 		});
-		this.lastWarning = details;
-		this.displayedWarningSequence++;
-		this.displayWarning?.(details);
+		this.deliverBoundaryWarning(details);
 		return true;
 	}
 
@@ -635,51 +632,41 @@ export class MainWatchdogRuntime {
 			state: "displayed",
 			displayedAt: new Date().toISOString(),
 		};
-		this.lastWarning = details;
-		this.displayedWarningSequence++;
-		this.displayWarning?.(details, correction ? { deliverAs: "steer" } : undefined);
-	}
-
-	private resetAutoFollowState(): void {
-		this.autoFollowQueued = false;
-		this.autoFollowAttempts = 0;
-		this.consecutiveAutoFollowIdentity = undefined;
-		this.consecutiveAutoFollowRepeats = 0;
-		this.autoFollowStalemate = false;
+		if (correction) {
+			this.lastWarning = details;
+			this.displayWarning?.(details, { deliverAs: "steer" });
+			return;
+		}
+		this.deliverBoundaryWarning(details);
 	}
 
-	private queueAutoFollowIfNeeded(warning: WatchdogWarningDetails | undefined): void {
-		if (!warning || warning.severity !== "blocker" || warning.stale || !this.configResult.config.autoFollow.blockers || !this.isEnabled()) return;
-		const identity = warning.identity ?? reviewInputSignature([warning.severity, warning.summary, warning.evidence].join("\n"));
-		if (this.consecutiveAutoFollowIdentity === identity) this.consecutiveAutoFollowRepeats++;
+	// A displayed boundary warning continues the run; the same identity back from consecutive
+	// boundaries means no progress, so it is shown held instead of continuing again.
+	private deliverBoundaryWarning(details: WatchdogWarningDetails): void {
+		const identity = details.identity ?? reviewInputSignature([details.severity, details.summary, details.evidence].join("\n"));
+		if (this.lastBoundaryIdentity === identity) this.boundaryRepeats++;
 		else {
-			this.consecutiveAutoFollowIdentity = identity;
-			this.consecutiveAutoFollowRepeats = 1;
-		}
-		if (this.consecutiveAutoFollowRepeats >= this.configResult.config.autoFollow.stalemateRepeats) {
-			this.autoFollowStalemate = true;
-			this.lastWarning = { ...warning, state: "stalemate", stalemateRepeats: this.consecutiveAutoFollowRepeats };
-			return;
+			this.lastBoundaryIdentity = identity;
+			this.boundaryRepeats = 1;
 		}
-		const maxAttempts = this.configResult.config.autoFollow.maxAttempts;
-		if (maxAttempts !== null && this.autoFollowAttempts >= maxAttempts) return;
-		if (!this.sendUserMessage) return;
-		this.autoFollowAttempts++;
-		this.autoFollowQueued = true;
-		const prompt = [
-			"Watchdog auto-follow: address this blocker before continuing.",
-			`Summary: ${warning.summary}`,
-			`Evidence: ${warning.evidence}`,
-			`Recommended action: ${warning.recommendedAction}`,
-		].join("\n");
-		this.pendingAutoFollowPrompts.push(prompt);
-		if (this.pendingAutoFollowPrompts.length > 8) this.pendingAutoFollowPrompts.shift();
-		void Promise.resolve(this.sendUserMessage(prompt)).catch((error) => {
-			this.autoFollowQueued = false;
-			const index = this.pendingAutoFollowPrompts.indexOf(prompt);
-			if (index >= 0) this.pendingAutoFollowPrompts.splice(index, 1);
-			this.lastError = `Watchdog auto-follow failed: ${errorMessage(error)}`;
-		});
+		const stalemate = this.boundaryRepeats >= this.configResult.config.stalemateRepeats;
+		const delivered: WatchdogWarningDetails = stalemate
+			? { ...details, state: "stalemate", stalemateRepeats: this.boundaryRepeats }
+			: details;
+		this.stalemate = stalemate;
+		this.lastWarning = delivered;
+		this.displayWarning?.(delivered, stalemate ? { triggerTurn: false } : undefined);
+	}
+
+	// The previous boundary finding is a repeat to count, not a duplicate, until stalemate.
+	private repeatableBoundaryIdentity(): string | undefined {
+		return this.waitingAtAgentEnd && !this.stalemate ? this.lastBoundaryIdentity : undefined;
+	}
+
+	private resetBoundaryRepeats(): void {
+		this.lastBoundaryIdentity = undefined;
+		this.boundaryRepeats = 0;
+		this.stalemate = false;
 	}
 
 	private currentRepoChangeSignature(cwd = this.cwd): WatchdogRepoChangeSignature | undefined {
@@ -783,7 +770,7 @@ export class MainWatchdogRuntime {
 	private appendBoundedDelta(delta: string): void {
 		let entry = delta.trim();
 		if (!entry) return;
-		if (entry.length > MAX_REVIEW_INPUT_CHARS) entry = entry.slice(-MAX_REVIEW_INPUT_CHARS);
+		if (entry.length > MAX_REVIEW_INPUT_CHARS) entry = boundWatchdogReviewText(entry);
 		this.pendingDeltas.push(entry);
 		this.pendingDeltaChars += entry.length;
 		while (this.pendingDeltas.length > 1 && this.pendingDeltaChars + (this.pendingDeltas.length - 1) * REVIEW_DELTA_SEPARATOR.length > MAX_REVIEW_INPUT_CHARS) {
@@ -799,7 +786,7 @@ export class MainWatchdogRuntime {
 			? ["Changed repo paths:", ...changeSignature.changedPaths.slice(0, 200).map((file) => `- ${file}`)].join("\n")
 			: "";
 		const contextPieces = [scopeBlock, changes, lspBlock].filter(Boolean);
-		if (!contextPieces.length) return input.length > MAX_REVIEW_INPUT_CHARS ? input.slice(-MAX_REVIEW_INPUT_CHARS) : input;
+		if (!contextPieces.length) return boundWatchdogReviewText(input);
 
 		const maxContextLength = Math.floor(MAX_REVIEW_INPUT_CHARS / 2);
 		const maxPieceLength = Math.max(1_000, Math.floor(maxContextLength / contextPieces.length));
@@ -808,11 +795,7 @@ export class MainWatchdogRuntime {
 			: piece).join(REVIEW_DELTA_SEPARATOR);
 		const separatorLength = input ? REVIEW_DELTA_SEPARATOR.length : 0;
 		const inputBudget = MAX_REVIEW_INPUT_CHARS - boundedContext.length - separatorLength;
-		const boundedInput = inputBudget <= 0
-			? ""
-			: input.length > inputBudget
-				? input.slice(-inputBudget)
-				: input;
+		const boundedInput = inputBudget <= 0 ? "" : boundWatchdogReviewText(input, inputBudget);
 		return [boundedContext, boundedInput].filter(Boolean).join(REVIEW_DELTA_SEPARATOR);
 	}
 

package/src/watchdog/scope.ts

@@ -1,5 +1,3 @@
-export const WATCHDOG_AUTO_FOLLOW_PROMPT_MARKER = Symbol("subagent-watchdog-auto-follow-prompt");
-
 const MAX_SCOPE_ENTRIES = 8;
 const MAX_SCOPE_ENTRY_CHARS = 2_000;
 const MAX_SCOPE_TOTAL_CHARS = 16_000;
@@ -51,12 +49,3 @@ export class WatchdogScopeArtifact {
 		}
 	}
 }
-
-export function isWatchdogAutoFollowPromptEvent(event: unknown): boolean {
-	return Boolean(event && typeof event === "object" && (event as { [WATCHDOG_AUTO_FOLLOW_PROMPT_MARKER]?: unknown })[WATCHDOG_AUTO_FOLLOW_PROMPT_MARKER]);
-}
-
-export function markWatchdogAutoFollowPromptEvent<T extends object>(event: T): T {
-	Object.defineProperty(event, WATCHDOG_AUTO_FOLLOW_PROMPT_MARKER, { value: true });
-	return event;
-}