pi-subagents 0.67.0 → 0.69.0

package/src/tui/render.ts

@@ -26,7 +26,7 @@ import {
 	WIDGET_KEY,
 } from "../shared/types.ts";
 import { previewDisplayText, sanitizeDisplayText, truncateDisplayText } from "../shared/display-text.ts";
-import { FLEET_OPEN_SHORTCUT, formatShortcutLabel } from "../shared/shortcuts.ts";
+import { formatShortcutLabel } from "../shared/shortcuts.ts";
 import { formatContextUsage, formatTokens, formatUsage, formatDuration, formatModelThinking, formatToolCall, formatTokenUsage, shortenPath } from "../shared/formatters.ts";
 import { getDisplayItems, getSingleResultOutput, PROMPT_REDACTED } from "../shared/utils.ts";
 import { flatToLogicalStepIndex } from "../runs/background/parallel-groups.ts";
@@ -95,11 +95,11 @@ function liveDetailKeyText(): string {
 }
 
 export function liveDetailHintText(): string {
-	return `Press ${liveDetailKeyText()} for live detail · ${formatShortcutLabel(FLEET_OPEN_SHORTCUT)} Fleet`;
+	return `Press ${liveDetailKeyText()} for live detail`;
 }
 
 function workflowDetailHintText(): string {
-	return `Press ${liveDetailKeyText()} for details · ${formatShortcutLabel(FLEET_OPEN_SHORTCUT)} Fleet`;
+	return `Press ${liveDetailKeyText()} for details`;
 }
 
 function foregroundSingleHintText(shortcut?: string): string {
@@ -2545,6 +2545,10 @@ function buildSingleLineWidgetLines(jobs: AsyncJobState[], theme: Theme, width:
 	if (counts.failed.length > 0) parts.push(`${counts.failed.length} failed`);
 	if (counts.stopped.length > 0) parts.push(`${counts.stopped.length} stopped`);
 	if (counts.paused.length > 0) parts.push(`${counts.paused.length} paused`);
+	for (const status of ["partial", "rejected"] as const) {
+		const count = jobs.filter((job) => job.status === status).length;
+		if (count > 0) parts.push(`${count} ${status}`);
+	}
 	if (!hasActive && counts.complete.length > 0) parts.push(`${counts.complete.length}/${jobs.length} done`);
 	return [truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "subagents")} (${parts.join(", ") || `${jobs.length} total`})`, width)];
 }
@@ -2817,6 +2821,7 @@ function buildWidgetComponent(jobs: AsyncJobState[], ui: ExtensionContext["ui"])
 		let cachedExpanded: boolean | undefined;
 		let cachedLines: string[] | undefined;
 		let cachedCoverage = "[]";
+		let collapsed = false;
 		const invalidate = (): void => {
 			cachedLines = undefined;
 			resetWidgetLayoutSession();
@@ -2830,6 +2835,14 @@ function buildWidgetComponent(jobs: AsyncJobState[], ui: ExtensionContext["ui"])
 		};
 		asyncWidgetUpdates.set(ui, update);
 		const component = Object.assign(container, {
+			// Only the mouse fields used here, without requiring newer Pi type exports.
+			handleMouse(event: { type: string; button: string; y: number; shift: boolean; alt: boolean; ctrl: boolean }) {
+				if (event.type !== "click" || event.button !== "left" || event.y !== 0) return undefined;
+				if (event.shift || event.alt || event.ctrl) return undefined;
+				collapsed = !collapsed;
+				invalidate();
+				return { handled: true };
+			},
 			dispose(): void {
 				if (asyncWidgetUpdates.get(ui) === update) asyncWidgetUpdates.delete(ui);
 				if (asyncWidgetInvalidations.get(ui) === invalidate) asyncWidgetInvalidations.delete(ui);
@@ -2872,7 +2885,10 @@ function buildWidgetComponent(jobs: AsyncJobState[], ui: ExtensionContext["ui"])
 			cachedRenderWidth = renderWidth;
 			cachedFrame = frame;
 			cachedExpanded = expanded;
-			cachedLines = fitAdaptiveWidgetLines(roots, buildLines, theme, width, expanded, frame, projectionFor).map((line) => paddedWidgetLine(line, renderWidth));
+			cachedLines = (collapsed
+				? buildSingleLineWidgetLines(jobs, theme, width, frame)
+				: fitAdaptiveWidgetLines(roots, buildLines, theme, width, expanded, frame, projectionFor)
+			).map((line) => paddedWidgetLine(line, renderWidth));
 			return cachedLines;
 		};
 		return component;
@@ -3468,9 +3484,6 @@ export function renderSubagentResult(
 		if (r.skillsWarning) {
 			c.addChild(new Text(fit(theme.fg("warning", `Warning: ${r.skillsWarning}`)), 0, 0));
 		}
-		if (r.attemptedModels && r.attemptedModels.length > 1) {
-			c.addChild(new Text(fit(theme.fg("dim", `Fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
-		}
 		c.addChild(new Text(fit(theme.fg("dim", formatUsage(r.usage, r.model))), 0, 0));
 		if (r.sessionFile) {
 			c.addChild(new Text(fit(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`)), 0, 0));
@@ -3647,9 +3660,6 @@ export function renderSubagentResult(
 		if (r.skillsWarning) {
 			c.addChild(new Text(fit(theme.fg("warning", `    Warning: ${r.skillsWarning}`)), 0, 0));
 		}
-		if (r.attemptedModels && r.attemptedModels.length > 1) {
-			c.addChild(new Text(fit(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
-		}
 
 		if (rRunning && rProg) {
 			if (rProg.skills?.length) {

package/src/watchdog/child-status.ts

@@ -1,5 +1,5 @@
 import type { ChildWatchdogProgress, ChildWatchdogWarningSummary } from "../shared/types.ts";
-import { SUBAGENT_WATCHDOG_WARNING_TYPE, type ResolvedWatchdogConfig, type WatchdogCadenceConfig, type WatchdogCategory, type WatchdogLspConfig } from "./types.ts";
+import { WATCHDOG_WARNING_CATEGORIES, WATCHDOG_WARNING_IMPORTANCES, type ResolvedWatchdogConfig, type WatchdogCadenceConfig, type WatchdogLspConfig } from "./types.ts";
 
 export const CHILD_WATCHDOG_WARNING_LIMIT = 20;
 
@@ -16,7 +16,6 @@ export interface ChildWatchdogConfig {
 	agentEndTimeoutMs: number;
 	maxWarnings: number | null;
 	model?: string;
-	fallbackModels?: string[];
 	thinking?: string | false;
 	lsp: WatchdogLspConfig;
 	stalemateRepeats: number;
@@ -34,6 +33,7 @@ export interface ChildWatchdogStatusEvent {
 	phase: ChildWatchdogPhase;
 	ts: number;
 	reason?: string;
+	warning?: ChildWatchdogWarningSummary;
 }
 
 export type ChildWatchdogStateSnapshot = ChildWatchdogProgress;
@@ -48,7 +48,6 @@ export function resolveChildWatchdogConfig(input: {
 	const enabled = input.config.enabled && (override?.enabled ?? input.config.children.enabled);
 	if (!enabled) return undefined;
 	const model = override?.model ?? input.config.children.model;
-	const fallbackModels = override?.fallbackModels ?? input.config.children.fallbackModels;
 	const thinking = override?.thinking ?? input.config.children.thinking;
 	const cadence = override?.cadence ?? input.config.children.cadence ?? input.config.cadence;
 	return {
@@ -59,7 +58,6 @@ export function resolveChildWatchdogConfig(input: {
 		agentEndTimeoutMs: input.config.agentEndTimeoutMs,
 		maxWarnings: input.config.maxWarnings,
 		...(model ? { model } : {}),
-		...(fallbackModels !== undefined ? { fallbackModels: [...fallbackModels] } : {}),
 		...(thinking !== undefined ? { thinking } : {}),
 		lsp: { ...input.config.lsp },
 		stalemateRepeats: input.config.stalemateRepeats,
@@ -130,6 +128,9 @@ function childConfigLsp(value: unknown): WatchdogLspConfig {
 export function decodeChildWatchdogConfig(raw: string | undefined): ChildWatchdogConfig | undefined {
 	if (!raw) return undefined;
 	const parsed = childConfigObject(JSON.parse(raw), "root");
+	if (Object.hasOwn(parsed, "fallbackModels")) {
+		throw new Error("Invalid child watchdog config: fallbackModels was removed; configure one model instead.");
+	}
 	if (parsed.enabled === false) return undefined;
 	if ("enabled" in parsed && parsed.enabled !== true) throw new Error("Invalid child watchdog config: enabled must be true or false.");
 	const thinking = parsed.thinking;
@@ -140,10 +141,6 @@ export function decodeChildWatchdogConfig(raw: string | undefined): ChildWatchdo
 	const agent = childConfigOptionalString(parsed, "agent");
 	const childIndex = childConfigOptionalIndex(parsed, "childIndex");
 	const model = childConfigOptionalString(parsed, "model");
-	const fallbackModels = parsed.fallbackModels;
-	if (fallbackModels !== undefined && (!Array.isArray(fallbackModels) || fallbackModels.some((value) => typeof value !== "string" || !value.trim()))) {
-		throw new Error("Invalid child watchdog config: fallbackModels must be an array of non-empty strings.");
-	}
 	return {
 		...(runId ? { runId } : {}),
 		...(agent ? { agent } : {}),
@@ -152,7 +149,6 @@ export function decodeChildWatchdogConfig(raw: string | undefined): ChildWatchdo
 		agentEndTimeoutMs: childConfigPositiveInteger(parsed, "agentEndTimeoutMs"),
 		maxWarnings: childConfigNullableNonNegativeInteger(parsed, "maxWarnings"),
 		...(model ? { model } : {}),
-		...(fallbackModels !== undefined ? { fallbackModels: (fallbackModels as string[]).map((value) => value.trim()) } : {}),
 		...(thinking !== undefined ? { thinking: thinking as string | false } : {}),
 		lsp: childConfigLsp(parsed.lsp),
 		stalemateRepeats: childConfigPositiveInteger(parsed, "stalemateRepeats"),
@@ -163,6 +159,15 @@ export function decodeChildWatchdogConfig(raw: string | undefined): ChildWatchdo
 export function isChildWatchdogStatusEvent(value: unknown): value is ChildWatchdogStatusEvent {
 	if (!value || typeof value !== "object") return false;
 	const event = value as Partial<ChildWatchdogStatusEvent>;
+	const warningValue = event.warning;
+	const warning = warningValue as Partial<ChildWatchdogWarningSummary>;
+	const validWarning = warningValue === undefined || (warningValue !== null && typeof warningValue === "object" && !Array.isArray(warningValue)
+		&& (warning.severity === "concern" || warning.severity === "blocker")
+		&& typeof warning.importance === "string" && (WATCHDOG_WARNING_IMPORTANCES as readonly string[]).includes(warning.importance)
+		&& typeof warning.category === "string" && (WATCHDOG_WARNING_CATEGORIES as readonly string[]).includes(warning.category)
+		&& typeof warning.summary === "string" && typeof warning.evidence === "string" && typeof warning.recommendedAction === "string"
+		&& typeof warning.addressed === "boolean" && typeof warning.stalemate === "boolean"
+		&& (warning.displayedAt === undefined || typeof warning.displayedAt === "string"));
 	return event.type === CHILD_WATCHDOG_STATUS_EVENT
 		&& typeof event.seq === "number"
 		&& Number.isInteger(event.seq)
@@ -170,7 +175,8 @@ export function isChildWatchdogStatusEvent(value: unknown): value is ChildWatchd
 		&& typeof event.ts === "number"
 		&& Number.isFinite(event.ts)
 		&& typeof event.phase === "string"
-		&& (CHILD_WATCHDOG_PHASES as readonly string[]).includes(event.phase);
+		&& (CHILD_WATCHDOG_PHASES as readonly string[]).includes(event.phase)
+		&& validWarning;
 }
 
 export function childWatchdogIsActive(snapshot: ChildWatchdogStateSnapshot | undefined): boolean {
@@ -190,40 +196,20 @@ export function acceptChildWatchdogEvent(input: {
 	const eventIndex = input.event.childIndex ?? input.event.stepIndex;
 	if (input.childIndex !== undefined && eventIndex !== input.childIndex) return undefined;
 	if (input.current && input.event.seq <= input.current.seq) return undefined;
+	const warnings = input.event.warning
+		? [...(input.current?.warnings ?? []), input.event.warning].slice(-CHILD_WATCHDOG_WARNING_LIMIT)
+		: input.current?.warnings;
 	return {
 		phase: input.event.phase,
 		seq: input.event.seq,
 		lastUpdate: input.event.ts,
 		...(input.event.reason ? { reason: input.event.reason } : {}),
-		...(input.current?.warnings?.length ? { warnings: input.current.warnings } : {}),
+		...(warnings?.length ? { warnings } : {}),
 	};
 }
 
-function childWatchdogWarningFromMessage(message: unknown): ChildWatchdogWarningSummary | undefined {
-	const candidate = message as { role?: unknown; customType?: unknown; details?: Record<string, unknown> } | undefined;
-	if (candidate?.role !== "custom" || candidate.customType !== SUBAGENT_WATCHDOG_WARNING_TYPE) return undefined;
-	const details = candidate.details ?? {};
-	if (details.severity !== "concern" && details.severity !== "blocker") return undefined;
-	if (typeof details.summary !== "string" || typeof details.evidence !== "string" || typeof details.recommendedAction !== "string") return undefined;
-	return {
-		severity: details.severity,
-		category: details.category as WatchdogCategory,
-		summary: details.summary,
-		evidence: details.evidence,
-		recommendedAction: details.recommendedAction,
-		...(typeof details.displayedAt === "string" ? { displayedAt: details.displayedAt } : {}),
-		addressed: false,
-		stalemate: details.state === "stalemate",
-	};
-}
-
-/** A watchdog warning message is appended; an assistant turn marks earlier warnings addressed. Undefined when unchanged. */
-export function applyChildWatchdogMessage(current: ChildWatchdogStateSnapshot | undefined, message: unknown, now = Date.now()): ChildWatchdogStateSnapshot | undefined {
-	const warning = childWatchdogWarningFromMessage(message);
-	if (warning) {
-		const warnings = [...(current?.warnings ?? []), warning].slice(-CHILD_WATCHDOG_WARNING_LIMIT);
-		return current ? { ...current, warnings } : { phase: "idle", seq: 0, lastUpdate: now, warnings };
-	}
+/** An assistant turn marks earlier warnings addressed. Undefined when unchanged. */
+export function applyChildWatchdogMessage(current: ChildWatchdogStateSnapshot | undefined, message: unknown): ChildWatchdogStateSnapshot | undefined {
 	if ((message as { role?: unknown } | undefined)?.role !== "assistant" || !current?.warnings?.some((entry) => !entry.addressed)) return undefined;
 	return { ...current, warnings: current.warnings.map((entry) => entry.addressed ? entry : { ...entry, addressed: true }) };
 }
@@ -231,3 +217,9 @@ export function applyChildWatchdogMessage(current: ChildWatchdogStateSnapshot |
 export function unresolvedChildWatchdogBlockers(progress: Pick<ChildWatchdogProgress, "warnings"> | undefined): ChildWatchdogWarningSummary[] {
 	return (progress?.warnings ?? []).filter((warning) => warning.severity === "blocker" && (!warning.addressed || warning.stalemate));
 }
+
+export function childWatchdogProgressForModel(progress: ChildWatchdogProgress | undefined): ChildWatchdogProgress | undefined {
+	if (!progress) return undefined;
+	const warnings = (progress.warnings ?? []).filter((warning) => warning.importance === "high");
+	return { ...progress, warnings: warnings.length ? warnings : undefined };
+}

package/src/watchdog/lsp-diagnostics.ts

@@ -216,7 +216,7 @@ export function watchdogWarningFromLspDiagnostics(result: WatchdogLspResult): Wa
 	return {
 		severity,
 		category: "correctness",
-		confidence: "high",
+		importance: "high",
 		source: "lsp",
 		summary: `LSP found ${count} ${kind}${count === 1 ? "" : "s"} in changed ${count === 1 ? "file" : "files"}.`,
 		evidence: evidence || formatDiagnostic(primary),

package/src/watchdog/model-selection.ts

@@ -1,5 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { normalizeModelSegment, resolveModelCandidate } from "../runs/shared/model-fallback.ts";
+import { normalizeModelSegment, resolveModelCandidate } from "../runs/shared/model-resolution.ts";
 import type { WatchdogEndpointConfig } from "./types.ts";
 import {
 	getSupportedThinkingLevels,

package/src/watchdog/register-child.ts

@@ -10,7 +10,8 @@ import {
 	type ChildWatchdogPhase,
 	type ChildWatchdogStatusEvent,
 } from "./child-status.ts";
-import type { ResolvedWatchdogConfig, WatchdogWarningDetails } from "./types.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 {
@@ -21,7 +22,6 @@ export function childResolvedConfig(config: ChildWatchdogConfig): ResolvedWatchd
 		main: {
 			enabled: true,
 			...(config.model ? { model: config.model } : {}),
-			...(config.fallbackModels !== undefined ? { fallbackModels: [...config.fallbackModels] } : {}),
 			...(config.thinking !== undefined ? { thinking: config.thinking } : {}),
 		},
 		stalemateRepeats: config.stalemateRepeats,
@@ -58,7 +58,7 @@ export function registerChildWatchdog(
 	let currentContext: ExtensionContext | undefined;
 	let diffBaseline: WatchdogDiffBaseline | undefined;
 	let seq = 0;
-	const emitStatus = (phase: ChildWatchdogPhase, reason?: string): void => {
+	const emitStatus = (phase: ChildWatchdogPhase, reason?: string, warning?: ChildWatchdogWarningSummary): void => {
 		writeStatus({
 			type: CHILD_WATCHDOG_STATUS_EVENT,
 			...(childConfig.runId ? { runId: childConfig.runId } : {}),
@@ -68,6 +68,7 @@ export function registerChildWatchdog(
 			phase,
 			ts: Date.now(),
 			...(reason ? { reason } : {}),
+			...(warning ? { warning } : {}),
 		});
 	};
 	const resolved = childResolvedConfig(childConfig);
@@ -78,8 +79,14 @@ export function registerChildWatchdog(
 		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;

package/src/watchdog/register-main.ts

@@ -63,16 +63,11 @@ function mainThinkingLine(snapshot: ReturnType<MainWatchdogRuntime["getSnapshot"
 }
 
 function mainModelLine(snapshot: ReturnType<MainWatchdogRuntime["getSnapshot"]>, ctx: ExtensionContext): string {
-	const fallbacks = fallbackLine(snapshot.config.main.fallbackModels);
 	if (snapshot.config.main.model) {
 		const source = snapshot.sessionModelOverride?.model ? "session override" : "configured";
-		return `Main model: ${splitKnownThinkingSuffix(snapshot.config.main.model).baseModel} (${source})${fallbacks}`;
+		return `Main model: ${splitKnownThinkingSuffix(snapshot.config.main.model).baseModel} (${source})`;
 	}
-	return `Main model: ${currentSessionModelLine(ctx)}${fallbacks}`;
-}
-
-function fallbackLine(models: string[] | undefined): string {
-	return models === undefined ? "" : ` · fallbacks ${models.length ? models.join(" → ") : "none"}`;
+	return `Main model: ${currentSessionModelLine(ctx)}`;
 }
 
 function childrenLine(snapshot: ReturnType<MainWatchdogRuntime["getSnapshot"]>): string {
@@ -85,12 +80,11 @@ function childrenLine(snapshot: ReturnType<MainWatchdogRuntime["getSnapshot"]>):
 			const bits = [agent];
 			if (override.enabled !== undefined) bits.push(boolLabel(override.enabled));
 			if (override.model) bits.push(splitKnownThinkingSuffix(override.model).baseModel);
-			if (override.fallbackModels !== undefined) bits.push(fallbackLine(override.fallbackModels));
 			if (override.thinking !== undefined) bits.push(`thinking ${override.thinking === false ? "off" : override.thinking}`);
 			return bits.join(" ");
 		}).join("; ")}`
 		: "";
-	return `Children: ${boolLabel(snapshot.config.enabled && children.enabled)} · model ${model}${fallbackLine(children.fallbackModels)} · thinking ${thinking}${overrideText}`;
+	return `Children: ${boolLabel(snapshot.config.enabled && children.enabled)} · model ${model} · thinking ${thinking}${overrideText}`;
 }
 
 function recommendationLine(snapshot: ReturnType<MainWatchdogRuntime["getSnapshot"]>, ctx: ExtensionContext): string {
@@ -160,10 +154,10 @@ export function buildWatchdogStatus(snapshot: ReturnType<MainWatchdogRuntime["ge
 	return lines.join("\n");
 }
 
-function parseTestCommand(input: string): { severity: "concern" | "blocker"; text: string } | undefined {
-	const match = input.match(/^test\s+(concern|blocker)\s+([\s\S]+)$/);
+function parseTestCommand(input: string): { severity: "concern" | "blocker"; importance: "low" | "medium" | "high"; text: string } | undefined {
+	const match = input.match(/^test\s+(concern|blocker)\s+(low|medium|high)\s+([\s\S]+)$/);
 	if (!match) return undefined;
-	return { severity: match[1] as "concern" | "blocker", text: match[2]!.trim() };
+	return { severity: match[1] as "concern" | "blocker", importance: match[2] as "low" | "medium" | "high", text: match[3]!.trim() };
 }
 
 function formatThinking(value: ThinkingLevel | false | undefined): string {
@@ -231,11 +225,11 @@ function buildCheckText(runtime: MainWatchdogRuntime, ctx: ExtensionCommandConte
 	return lines.join("\n");
 }
 
-function createTestWarning(severity: "concern" | "blocker", text: string): WatchdogWarning {
+function createTestWarning(severity: "concern" | "blocker", importance: "low" | "medium" | "high", text: string): WatchdogWarning {
 	return {
 		severity,
 		category: "other",
-		confidence: "high",
+		importance,
 		source: "main",
 		state: "displayed",
 		summary: text,
@@ -366,15 +360,14 @@ async function handleWatchdogCommand(
 	const test = parseTestCommand(input);
 	if (test) {
 		if (!test.text) {
-			ctx.ui.notify("Usage: /subagents-watchdog test concern|blocker <text>", "error");
+			ctx.ui.notify("Usage: /subagents-watchdog test concern|blocker low|medium|high <text>", "error");
 			return;
 		}
-		const warning = createTestWarning(test.severity, test.text);
-		const details = runtime.recordDisplayedWarning(warning);
-		pi.sendMessage(createWatchdogWarningMessage(details, { display: true, details }));
+		const warning = createTestWarning(test.severity, test.importance, test.text);
+		runtime.displayRecordedWarning(warning);
 		return;
 	}
-	ctx.ui.notify(`Usage: /subagents-watchdog [status|on|off|session on|session off|recommend-model|model recommended|model <provider/model[:thinking]>|model inherit|thinking ${THINKING_LEVELS.join("|")}|thinking inherit|session model recommended|check|test concern <text>|test blocker <text>]`, "error");
+	ctx.ui.notify(`Usage: /subagents-watchdog [status|on|off|session on|session off|recommend-model|model recommended|model <provider/model[:thinking]>|model inherit|thinking ${THINKING_LEVELS.join("|")}|thinking inherit|session model recommended|check|test concern|blocker low|medium|high <text>]`, "error");
 }
 
 export function registerMainWatchdog(pi: ExtensionAPI, options: RegisterMainWatchdogOptions = {}): MainWatchdogRuntime {
@@ -388,6 +381,7 @@ export function registerMainWatchdog(pi: ExtensionAPI, options: RegisterMainWatc
 		reviewDescription: options.review ? "injected seam" : "real model review",
 		reviewChangesOnly: true,
 		displayWarning: (details, options) => pi.sendMessage(createWatchdogWarningMessage(details, { display: true, details }), options),
+		displayUserWarning: (details) => pi.appendEntry(SUBAGENT_WATCHDOG_WARNING_TYPE, details),
 		displayClarification: (content) => pi.sendMessage({ customType: "subagent_watchdog_clarification", content, display: true }, { deliverAs: "steer", triggerTurn: true }),
 	});
 
@@ -401,6 +395,12 @@ export function registerMainWatchdog(pi: ExtensionAPI, options: RegisterMainWatc
 		}
 		return renderWatchdogWarning(details, renderOptions, theme);
 	});
+	pi.registerEntryRenderer<WatchdogWarningDetails>(SUBAGENT_WATCHDOG_WARNING_TYPE, (entry, renderOptions, theme) => {
+		const details = entry.data as WatchdogWarningDetails | undefined;
+		return details?.summary && details.evidence && details.recommendedAction
+			? renderWatchdogWarning(details, renderOptions, theme)
+			: undefined;
+	});
 
 	pi.registerCommand("subagents-watchdog", {
 		description: "Show or toggle the default-off subagent watchdog",
@@ -435,7 +435,7 @@ export function registerMainWatchdog(pi: ExtensionAPI, options: RegisterMainWatc
 	});
 	pi.on("session_before_switch", () => runtime.reset("session switch", { clearReviewInputSignature: true, clearLspLedger: true, clearScope: true }));
 	pi.on("session_before_fork", () => runtime.reset("session fork", { clearReviewInputSignature: true, clearLspLedger: true, clearScope: true }));
-	pi.on("session_compact", () => runtime.reset("session compact", { clearScope: true }));
+	pi.on("session_compact", () => runtime.reset("session compact", { clearActivity: true }));
 	pi.on("session_shutdown", () => {
 		currentContext = undefined;
 		runtime.dispose();

package/src/watchdog/render.ts

@@ -26,7 +26,7 @@ export function formatWatchdogWarningRenderText(warning: WatchdogWarningDetails)
 		`Subagent watchdog ${subject}${labels.length ? ` (${labels.join(", ")})` : ""}: ${warning.summary}`,
 		`Evidence: ${warning.evidence}`,
 		`Recommended action: ${warning.recommendedAction}`,
-		`Category: ${titleCase(warning.category)} · Source: ${warning.source}${warning.agent ? ` · Agent: ${warning.agent}` : ""}${warning.runId ? ` · Run: ${warning.runId}` : ""}`,
+		`Importance: ${titleCase(warning.importance)} · Category: ${titleCase(warning.category)} · Source: ${warning.source}${warning.agent ? ` · Agent: ${warning.agent}` : ""}${warning.runId ? ` · Run: ${warning.runId}` : ""}`,
 	];
 	if (warning.state === "failed" && warning.error) lines.push(`Failure: ${warning.error}`);
 	if (warning.state === "stalemate" && warning.stalemateRepeats !== undefined) {

package/src/watchdog/review.ts

@@ -3,7 +3,7 @@ import { createReadOnlyTools, convertToLlm, type ExtensionContext } from "@earen
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import type { Model, ProviderHeaders } from "@earendil-works/pi-ai";
 import { Type, type Static } from "typebox";
-import { buildModelCandidates, isContextOverflow, isRetryableModelFailureAttempt, resolveModelCandidate } from "../runs/shared/model-fallback.ts";
+import { resolveModelCandidate } from "../runs/shared/model-resolution.ts";
 import { agentStreamOptions } from "../shared/agent-stream-options.ts";
 import { opencodeSessionHeaders } from "../shared/opencode-session-headers.ts";
 import { resolveEffectiveThinking, splitKnownThinkingSuffix, THINKING_LEVELS, toModelInfo } from "../shared/model-info.ts";
@@ -12,11 +12,11 @@ import { loadWatchdogGuidance } from "./guidance.ts";
 import { boundWatchdogReviewText, type WatchdogReviewFunction, type WatchdogReviewRequest } from "./runtime.ts";
 import {
 	WATCHDOG_WARNING_CATEGORIES,
-	WATCHDOG_WARNING_CONFIDENCES,
+	WATCHDOG_WARNING_IMPORTANCES,
 	WATCHDOG_WARNING_SEVERITIES,
 	type ResolvedWatchdogConfig,
 	type WatchdogCategory,
-	type WatchdogConfidence,
+	type WatchdogImportance,
 	type WatchdogSeverity,
 	type WatchdogWarning,
 } from "./types.ts";
@@ -27,11 +27,11 @@ const WatchdogAskParams = Type.Object({ question: Type.String(), evidence: Type.
 
 const WatchdogWarnParams = Type.Object({
 	severity: Type.String({ enum: WATCHDOG_WARNING_SEVERITIES, description: "concern for actionable risk, blocker for a likely wrong or unsafe outcome" }),
+	importance: Type.String({ enum: WATCHDOG_WARNING_IMPORTANCES, description: "low or medium for user-only visibility; high when the parent model must receive the finding" }),
 	summary: Type.String({ description: "One concise sentence naming the issue." }),
 	evidence: Type.String({ description: "Specific evidence from the turn delta or inspected files." }),
 	recommendedAction: Type.String({ description: "Specific action the parent should take before accepting or continuing." }),
 	category: Type.Optional(Type.String({ enum: WATCHDOG_WARNING_CATEGORIES })),
-	confidence: Type.Optional(Type.String({ enum: WATCHDOG_WARNING_CONFIDENCES })),
 }, { additionalProperties: false });
 
 type WatchdogWarnParams = Static<typeof WatchdogWarnParams>;
@@ -182,8 +182,8 @@ function nonEmptyString(value: string, field: string): string {
 function toWatchdogWarning(params: WatchdogWarnParams): WatchdogWarning {
 	return {
 		severity: params.severity as WatchdogSeverity,
+		importance: params.importance as WatchdogImportance,
 		category: (params.category ?? "other") as WatchdogCategory,
-		confidence: (params.confidence ?? "medium") as WatchdogConfidence,
 		source: "main",
 		summary: nonEmptyString(params.summary, "summary"),
 		evidence: nonEmptyString(params.evidence, "evidence"),
@@ -197,7 +197,7 @@ function createWatchdogWarnTool(request: WatchdogReviewRequest): AgentTool<typeo
 		label: "Watchdog warning",
 		description: [
 			"Emit one actionable main-session watchdog warning.",
-			"Use only for medium/high confidence concerns or blockers that the parent should consider before accepting the work.",
+			"Set importance explicitly: low or medium for user-only visibility, high only when the parent model must receive the finding.",
 			"Do not use for nits, praise, informational notes, or clean reviews.",
 		].join(" "),
 		parameters: WatchdogWarnParams,
@@ -227,8 +227,8 @@ export function buildWatchdogSystemPrompt(ctx: Pick<ExtensionContext, "cwd">, op
 		options.hasScope ? "Use the Current scope record alongside supplied activity evidence; an unrelated user question does not cancel older authorized work." : undefined,
 		`You are read-only. You may use ${options.hasDiff ? "read, grep, find, ls, and watchdog_diff (the full repo diff since the session baseline; pass a path to narrow it)" : "read, grep, find, and ls"}. Do not edit files, run shell commands, spawn agents, or mutate state.`,
 		"Emit warnings only by calling watchdog_warn. Freeform assistant text is ignored and must not be used to report warnings.",
-		"Emit only medium/high confidence actionable concerns or blockers: missed user constraints, correctness risks, test gaps that matter, unsafe changes, stale facts, loop risks, or scope drift.",
-		"Do not emit nits, style preferences, low-confidence guesses, informational notes, praise, or summaries.",
+		"Emit only actionable concerns or blockers: missed user constraints, correctness risks, test gaps that matter, unsafe changes, stale facts, loop risks, or scope drift.",
+		"Do not emit nits, style preferences, unsupported guesses, informational notes, praise, or summaries.",
 		"If the turn is clean, call no tools and end normally.",
 		"Use severity='blocker' only when the issue should stop acceptance until addressed; otherwise use severity='concern'.",
 		guidance ? `\nStanding instructions from WATCHDOG.md (project first, then user):\n${guidance}` : undefined,
@@ -256,32 +256,17 @@ export function createMainWatchdogReview(provider: WatchdogContextProvider, opti
 		if (!ctx) throw new Error("Main watchdog review cannot run without an active Pi extension context.");
 		const aborted = () => ctx.signal?.aborted || request.signal?.aborted;
 		if (aborted()) return { stopReason: "aborted" };
-		const inherited = !request.config.main.model && ctx.model ? fullModelId(ctx.model) : undefined;
-		const candidates = request.config.main.fallbackModels?.length
-			? buildModelCandidates(request.config.main.model ?? inherited, request.config.main.fallbackModels,
-				ctx.modelRegistry.getAvailable().map(toModelInfo), ctx.model?.provider, { primaryModelFromParent: Boolean(inherited) })
-			: [request.config.main.model];
-		for (let index = 0; index < candidates.length; index++) {
-			if (aborted()) return { stopReason: "aborted" };
-			const candidate = candidates[index];
-			const config = { ...request.config, main: { ...request.config.main, model: candidate === inherited ? undefined : candidate } };
-			try {
-				const attempt = await runWatchdogAttempt(ctx, { ...request, config }, options);
-				if (aborted()) return { stopReason: "aborted" };
-				if (!attempt.retryable || index === candidates.length - 1) return attempt.result;
-			} catch (error) {
-				if (aborted()) return { stopReason: "aborted" };
-				if (!(error instanceof WatchdogAuthError)) throw error;
-				if (isContextOverflow(error.message) || !isRetryableModelFailureAttempt({ error: error.message }) || index === candidates.length - 1) throw error.cause ?? error;
-			}
+		try {
+			return (await runWatchdogAttempt(ctx, request, options)).result;
+		} catch (error) {
+			if (error instanceof WatchdogAuthError) throw error.cause ?? error;
+			throw error;
 		}
-		throw new Error("No usable watchdog model candidates.");
 	};
 }
 
 async function runWatchdogAttempt(ctx: ExtensionContext, request: WatchdogReviewRequest, options: CreateMainWatchdogReviewOptions): Promise<{
 	result: Awaited<ReturnType<WatchdogReviewFunction>>;
-	retryable?: boolean;
 }> {
 	const selection = await resolveWatchdogReviewModel(ctx, request.config, {
 		currentThinkingLevel: options.getThinkingLevel?.(),
@@ -373,7 +358,6 @@ async function runWatchdogAttempt(ctx: ExtensionContext, request: WatchdogReview
 	const stopReason = reason === "error" || reason === "aborted" || reason === "length" ? reason : "stop";
 	const error = terminal && "errorMessage" in terminal && typeof terminal.errorMessage === "string" ? terminal.errorMessage : undefined;
 	return {
-		result: clarification ? { clarification } : { stopReason },
-		retryable: !clarification && stopReason === "error" && !isContextOverflow(error) && isRetryableModelFailureAttempt({ error, messages: agent.state.messages, toolCount }),
+		result: clarification ? { clarification } : error ? { stopReason, errorMessage: error } : { stopReason },
 	};
 }

package/src/watchdog/rules.ts

@@ -51,7 +51,7 @@ export function evaluateLaunchRule(rules: WatchdogRulesConfig | undefined, agent
 }
 
 export function ruleViolationWarning(violation: WatchdogRuleViolation): WatchdogWarning {
-	return { severity: "concern", category: "missed-constraint", confidence: "high", source: "main", ...violation };
+	return { severity: "concern", category: "missed-constraint", importance: "high", source: "main", ...violation };
 }
 
 export function applyWatchdogLaunchRules(input: { cwd: string; agent: string; model?: string; warn?: (violation: WatchdogRuleViolation) => void }): string | undefined {