pi-openai-toolkit 0.8.0 → 0.10.0

package/src/auto-mode/transcript.ts

@@ -0,0 +1,133 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import {
+	boundReviewText,
+	MAX_TRANSCRIPT_CHARS,
+	MAX_TRANSCRIPT_ENTRY_CHARS,
+	MAX_TRANSCRIPT_RECENT_ENTRIES,
+	MAX_TRANSCRIPT_TOOL_CHARS,
+	TRUNCATION_MARKER,
+} from "./types";
+
+/**
+ * A transcript line already reduced to text, with the role kept so the reviewer can
+ * tell whose words these are. `[user]` is the only role that carries authorization.
+ */
+export type TranscriptLine = {
+	role: "user" | "assistant" | "tool";
+	text: string;
+};
+
+function textOfContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((block) => {
+			if (!block || typeof block !== "object") return "";
+			const record = block as Record<string, unknown>;
+			if (record.type === "text" && typeof record.text === "string") return record.text;
+			if (record.type === "image") return "[image omitted]";
+			if (record.type === "toolCall" && typeof record.name === "string") {
+				const args = record.arguments;
+				return `${record.name} ${typeof args === "object" && args ? JSON.stringify(args) : ""}`.trim();
+			}
+			return "";
+		})
+		.filter(Boolean)
+		.join("\n")
+		.trim();
+}
+
+/**
+ * Flatten session entries into reviewer lines. Non-message entries are skipped,
+ * except a compaction summary, which is kept as a `[user]`-adjacent context marker
+ * because it is the only surviving view of the older conversation.
+ */
+export function sessionEntriesToLines(entries: readonly SessionEntry[]): TranscriptLine[] {
+	const lines: TranscriptLine[] = [];
+	for (const entry of entries) {
+		if (entry.type === "compaction" && typeof entry.summary === "string") {
+			const summary = boundReviewText(entry.summary, MAX_TRANSCRIPT_ENTRY_CHARS);
+			if (summary) lines.push({ role: "assistant", text: `[earlier conversation summary] ${summary}` });
+			continue;
+		}
+		if (entry.type !== "message") continue;
+		const message = entry.message as { role?: unknown; content?: unknown };
+		const text = textOfContent(message.content);
+		if (!text) continue;
+		if (message.role === "user") lines.push({ role: "user", text });
+		else if (message.role === "assistant") lines.push({ role: "assistant", text });
+		else if (message.role === "toolResult") lines.push({ role: "tool", text });
+	}
+	return lines;
+}
+
+function renderLine(index: number, line: TranscriptLine): string {
+	const body = boundReviewText(line.text, MAX_TRANSCRIPT_ENTRY_CHARS);
+	return `[${index}] [${line.role}]: ${body}`;
+}
+
+/**
+ * Build a bounded transcript the way Codex's guardian does: user turns are the
+ * anchors and are protected, tool and assistant evidence gets its own smaller
+ * budget so verbose command output cannot crowd out the human conversation that
+ * actually establishes authorization.
+ *
+ * Selection order is newest-first, then rendered in chronological order.
+ */
+export function buildReviewTranscript(
+	lines: readonly TranscriptLine[],
+	budgets: {
+		maxTotalChars?: number;
+		maxToolChars?: number;
+		maxRecentEntries?: number;
+	} = {},
+): { text: string; omitted: boolean } {
+	const maxTotalChars = budgets.maxTotalChars ?? MAX_TRANSCRIPT_CHARS;
+	const maxToolChars = budgets.maxToolChars ?? MAX_TRANSCRIPT_TOOL_CHARS;
+	const maxRecentEntries = budgets.maxRecentEntries ?? MAX_TRANSCRIPT_RECENT_ENTRIES;
+
+	const recent = lines.slice(-Math.max(1, maxRecentEntries));
+	const omitted = recent.length < lines.length;
+
+	const userLines: number[] = [];
+	const otherLines: number[] = [];
+	recent.forEach((line, index) => {
+		if (line.role === "user") userLines.push(index);
+		else otherLines.push(index);
+	});
+
+	const selected = new Set<number>();
+	let userChars = 0;
+	// The first user turn carries the task; the latest carries the immediate ask.
+	for (const index of [userLines[0]!, userLines[userLines.length - 1]!, ...userLines.slice(1, -1).reverse()]) {
+		if (index === undefined || selected.has(index)) continue;
+		const cost = recent[index]!.text.length;
+		if (userChars + cost > maxTotalChars) break;
+		selected.add(index);
+		userChars += cost;
+	}
+
+	let toolChars = 0;
+	for (const index of [...otherLines].reverse()) {
+		const cost = recent[index]!.text.length;
+		if (toolChars + cost > maxToolChars) continue;
+		if (userChars + toolChars + cost > maxTotalChars) continue;
+		selected.add(index);
+		toolChars += cost;
+	}
+
+	const ordered = [...selected].sort((a, b) => a - b);
+	const rendered = ordered.map((index) => renderLine(index + 1, recent[index]!));
+	if (omitted) rendered.unshift(`${TRUNCATION_MARKER} earlier conversation entries were omitted.`);
+	return { text: rendered.join("\n"), omitted };
+}
+
+/**
+ * Build the reviewer transcript straight from session entries.
+ */
+export function transcriptFromEntries(
+	entries: readonly SessionEntry[],
+	budgets?: Parameters<typeof buildReviewTranscript>[1],
+): { text: string; omitted: boolean } {
+	return buildReviewTranscript(sessionEntriesToLines(entries), budgets);
+}

package/src/auto-mode/types.ts

@@ -0,0 +1,137 @@
+import type { AutoModeConfig } from "../types";
+
+export const AUTO_MODE_ENTRY_TYPE = "pi-openai-toolkit.auto-mode-decision.v1";
+export const AUTO_MODE_STATUS_KEY = "pi-openai-toolkit:auto-mode";
+export const AUTO_MODE_FLAG = "auto";
+export const AUTO_MODE_COMMAND = "auto";
+
+/**
+ * Built-in tools that change state outside the conversation. Everything else is
+ * read-only by default and only reviewed when the user opts in through
+ * `autoMode.extraTools` or `gate: "all"`.
+ */
+export const SIDE_EFFECT_TOOLS = ["bash", "write", "edit"] as const;
+
+export const MAX_REVIEW_INPUT_CHARS = 8_000;
+export const MAX_REVIEW_INTENT_CHARS = 2_000;
+export const MAX_REVIEW_REASON_CHARS = 600;
+export const MAX_REVIEW_MODEL_KEY_CHARS = 256;
+
+/** Budgets for the compact transcript handed to the reviewer. */
+export const MAX_TRANSCRIPT_CHARS = 24_000;
+export const MAX_TRANSCRIPT_TOOL_CHARS = 12_000;
+export const MAX_TRANSCRIPT_ENTRY_CHARS = 2_000;
+export const MAX_TRANSCRIPT_RECENT_ENTRIES = 40;
+export const TRUNCATION_MARKER = "<truncated />";
+
+/** Risk of the planned action itself, as scored by the reviewer. */
+export type RiskLevel = "low" | "medium" | "high" | "critical";
+
+/** How far the observed conversation actually authorizes that action. */
+export type UserAuthorization = "unknown" | "low" | "medium" | "high";
+
+/**
+ * Why a review could not be completed. Kept separate from `deny` on purpose: an
+ * infrastructure failure must never be reported to the agent as a safety verdict.
+ */
+export type ReviewFailureCause =
+	| "not-configured"
+	| "timeout"
+	| "cancelled"
+	| "provider-error"
+	| "invalid-output";
+
+/**
+ * The reviewer's full verdict. Only `outcome` is required from the model; the
+ * remaining fields are back-filled by `parseReviewVerdict` so that a terse
+ * `{"outcome":"allow"}` answer is still a usable, recordable decision.
+ */
+export type GuardianVerdict = {
+	outcome: "allow" | "deny";
+	riskLevel: RiskLevel;
+	userAuthorization: UserAuthorization;
+	rationale: string;
+};
+
+/**
+ * Result of asking the reviewer model about one pending tool call.
+ * `unavailable` means the review could not be completed at all; it is never
+ * treated as approval.
+ */
+export type ReviewOutcome =
+	| {
+			kind: "allow";
+			verdict: GuardianVerdict;
+			reviewerModel: string;
+			evidenceRounds: number;
+	  }
+	| {
+			kind: "deny";
+			verdict: GuardianVerdict;
+			reviewerModel: string;
+			evidenceRounds: number;
+	  }
+	| { kind: "unavailable"; reason: string; cause: ReviewFailureCause };
+
+/** Non-blocking pre-score produced by the trajectory classifier. */
+export type ClassifierRisk = "low" | "high";
+
+/**
+ * Why the classifier's cached score could or could not satisfy a gated call.
+ * Mirrors the deferral reasons the blocking reviewer exists to cover: anything
+ * other than `low_risk` falls through to the synchronous review.
+ */
+export type FastDecisionReason =
+	| "low_risk"
+	| "elevated_risk"
+	| "stale_score"
+	| "scoring_failure"
+	| "missing_score"
+	| "authorization_changed"
+	| "requires_synchronous_review";
+
+export type AutoModeDecisionSource =
+	| "reviewer"
+	| "classifier"
+	| "human"
+	| "policy"
+	| "circuit-breaker";
+
+export type AutoModeDecisionRecord = {
+	timestamp: number;
+	toolName: string;
+	toolCallId: string;
+	decision:
+		| "allow"
+		| "deny"
+		| "unavailable-allowed"
+		| "unavailable-blocked"
+		| "turn-interrupted";
+	reason: string;
+	reviewerModel?: string;
+	source: AutoModeDecisionSource;
+	/** Present on reviewer verdicts; omitted for classifier fast paths. */
+	riskLevel?: RiskLevel;
+	userAuthorization?: UserAuthorization;
+	evidenceRounds?: number;
+	/** Only present when `source` is `classifier`. */
+	fastDecision?: FastDecisionReason;
+};
+
+export type AutoModeModelRef = {
+	provider?: string;
+	id?: string;
+};
+
+export type AutoModeGateSource = AutoModeConfig["gate"];
+
+/**
+ * Truncate to a bounded single-line-safe diagnostic. Reviewer reasons and tool
+ * arguments both originate from untrusted text, so every persisted copy is capped.
+ */
+export function boundReviewText(value: unknown, maxChars: number): string {
+	const text = typeof value === "string" ? value : String(value ?? "");
+	const collapsed = text.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim();
+	if (collapsed.length <= maxChars) return collapsed;
+	return `${collapsed.slice(0, Math.max(0, maxChars - 3))}...`;
+}

package/src/config.ts

@@ -6,14 +6,32 @@ import {
 	DEFAULT_COMPACTION_CONFIG,
 	DEFAULT_TOOLKIT_CONFIG,
 	DEFAULT_AUTO_COMPACTION_CONFIG,
+	DEFAULT_AUTO_MODE_CONFIG,
 	DEFAULT_IMAGE_GENERATION_CONFIG,
+	DEFAULT_NATIVE_FALLBACK_CONFIG,
 	DEFAULT_WEB_SEARCH_CONFIG,
 	RESPONSES_COMPACT_CAPABLE_APIS,
+	BREAKER_LIMIT_MAX,
+	BREAKER_LIMIT_MIN,
+	BREAKER_WINDOW_MAX,
+	BREAKER_WINDOW_MIN,
+	CLASSIFIER_MAX_LAG_MAX,
+	CLASSIFIER_MAX_LAG_MIN,
+	DEFAULT_CLASSIFIER_TIMEOUT_MS,
+	EVIDENCE_ROUNDS_MAX,
+	EVIDENCE_ROUNDS_MIN,
+	REVIEWER_TIMEOUT_MAX_MS,
+	REVIEWER_TIMEOUT_MIN_MS,
 	THINKING_LEVELS,
 	TOOLKIT_ID,
+	type AutoModeCircuitBreakerConfig,
+	type AutoModeClassifierConfig,
+	type AutoModeConfig,
+	type AutoModeGate,
 	type CompactionConfig,
 	type ImageGenerationConfig,
 	type LoadedToolkitConfig,
+	type NativeFallbackConfig,
 	type ToolkitConfig,
 	type WebSearchConfig,
 } from "./types";
@@ -21,13 +39,12 @@ import {
 export const CONFIG_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", TOOLKIT_ID);
 export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 
-const TOP_LEVEL_FIELDS = new Set(["compaction", "webSearch", "imageGeneration"]);
+const TOP_LEVEL_FIELDS = new Set(["compaction", "webSearch", "imageGeneration", "autoMode"]);
 const COMPACTION_FIELDS = new Set([
 	"enabled",
 	"allowCompactionContinuityBreak",
 	"remoteCompactModel",
-	"model",
-	"thinkingLevel",
+	"nativeFallback",
 	"autoCompaction",
 	"responsesApis",
 	"notifyOnLoad",
@@ -37,9 +54,25 @@ const COMPACTION_FIELDS = new Set([
 	"redactSensitiveData",
 	"artifactRoot",
 ]);
+const NATIVE_FALLBACK_FIELDS = new Set(["enabled", "model", "thinkingLevel"]);
 const AUTO_COMPACTION_FIELDS = new Set(["enabled", "continuation", "unsupportedFallback", "reserveTokens"]);
 const WEB_SEARCH_FIELDS = new Set(["enabled", "models"]);
-const IMAGE_GENERATION_FIELDS = new Set(["enabled", "models"]);
+const IMAGE_GENERATION_FIELDS = new Set(["enabled"]);
+const AUTO_MODE_FIELDS = new Set([
+	"enabled",
+	"models",
+	"reviewerModel",
+	"gate",
+	"extraTools",
+	"timeoutMs",
+	"transcript",
+	"evidenceTools",
+	"maxEvidenceRounds",
+	"classifier",
+	"circuitBreaker",
+]);
+const AUTO_MODE_CLASSIFIER_FIELDS = new Set(["enabled", "model", "timeoutMs", "maxLag"]);
+const AUTO_MODE_BREAKER_FIELDS = new Set(["consecutiveDenials", "recentDenials", "windowSize"]);
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
@@ -148,6 +181,21 @@ function toNonNegativeInteger(value: unknown, fieldPath: string, warnings: strin
 	return undefined;
 }
 
+function toBoundedInteger(
+	value: unknown,
+	fieldPath: string,
+	warnings: string[],
+	min: number,
+	max: number,
+): number | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value >= min && value <= max) {
+		return value;
+	}
+	warnings.push(`Ignoring ${fieldPath}: expected an integer between ${min} and ${max}.`);
+	return undefined;
+}
+
 function toSupportedApis(
 	value: unknown,
 	fieldPath: string,
@@ -175,7 +223,7 @@ function toSupportedApis(
 	return accepted;
 }
 
-function toModelAllowlist(value: unknown, fieldPath: string, warnings: string[]): string[] | undefined {
+function toStringList(value: unknown, fieldPath: string, warnings: string[]): string[] | undefined {
 	if (value === undefined) return undefined;
 	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
 		warnings.push(`Ignoring ${fieldPath}: expected a string array.`);
@@ -185,10 +233,34 @@ function toModelAllowlist(value: unknown, fieldPath: string, warnings: string[])
 	return [...new Set(value.map((entry) => entry.trim()).filter(Boolean))];
 }
 
+function toAutoModeGate(value: unknown, fieldPath: string, warnings: string[]): AutoModeGate | undefined {
+	if (value === undefined) return undefined;
+	if (value === "side-effect" || value === "all") return value;
+	warnings.push(`Ignoring ${fieldPath}: expected one of side-effect, all.`);
+	return undefined;
+}
+
+function toReviewerTimeoutMs(value: unknown, fieldPath: string, warnings: string[]): number | undefined {
+	if (value === undefined) return undefined;
+	if (
+		typeof value === "number" &&
+		Number.isInteger(value) &&
+		value >= REVIEWER_TIMEOUT_MIN_MS &&
+		value <= REVIEWER_TIMEOUT_MAX_MS
+	) {
+		return value;
+	}
+	warnings.push(
+		`Ignoring ${fieldPath}: expected an integer between ${REVIEWER_TIMEOUT_MIN_MS} and ${REVIEWER_TIMEOUT_MAX_MS} ms.`,
+	);
+	return undefined;
+}
+
 function cloneDefaults(): ToolkitConfig {
 	return {
 		compaction: {
 			...DEFAULT_COMPACTION_CONFIG,
+			nativeFallback: { ...DEFAULT_NATIVE_FALLBACK_CONFIG },
 			autoCompaction: { ...DEFAULT_AUTO_COMPACTION_CONFIG },
 			responsesApis: [...DEFAULT_COMPACTION_CONFIG.responsesApis],
 		},
@@ -196,13 +268,36 @@ function cloneDefaults(): ToolkitConfig {
 			...DEFAULT_WEB_SEARCH_CONFIG,
 			models: [...DEFAULT_WEB_SEARCH_CONFIG.models],
 		},
-		imageGeneration: {
-			...DEFAULT_IMAGE_GENERATION_CONFIG,
-			models: [...DEFAULT_IMAGE_GENERATION_CONFIG.models],
+		imageGeneration: { ...DEFAULT_IMAGE_GENERATION_CONFIG },
+		autoMode: {
+			...DEFAULT_AUTO_MODE_CONFIG,
+			models: [...DEFAULT_AUTO_MODE_CONFIG.models],
+			extraTools: [...DEFAULT_AUTO_MODE_CONFIG.extraTools],
+			classifier: { ...DEFAULT_AUTO_MODE_CONFIG.classifier },
+			circuitBreaker: { ...DEFAULT_AUTO_MODE_CONFIG.circuitBreaker },
 		},
 	};
 }
 
+function applyNativeFallbackConfig(
+	raw: Record<string, unknown>,
+	resolved: NativeFallbackConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, NATIVE_FALLBACK_FIELDS, "compaction.nativeFallback", warnings);
+	resolved.enabled =
+		toBoolean(raw.enabled, "compaction.nativeFallback.enabled", warnings) ?? resolved.enabled;
+
+	const modelSpec = toModelSpec(raw.model, "compaction.nativeFallback.model", warnings);
+	if (modelSpec !== undefined) {
+		resolved.model = modelSpec === null ? undefined : modelSpec;
+	}
+
+	resolved.thinkingLevel =
+		toThinkingLevel(raw.thinkingLevel, "compaction.nativeFallback.thinkingLevel", warnings) ??
+		resolved.thinkingLevel;
+}
+
 function applyAutoCompactionConfig(
 	raw: Record<string, unknown>,
 	resolved: CompactionConfig["autoCompaction"],
@@ -265,14 +360,14 @@ function applyCompactionConfig(
 		resolved.remoteCompactModel = remoteCompactModelSpec === null ? undefined : remoteCompactModelSpec;
 	}
 
-	const modelSpec = toModelSpec(raw.model, "compaction.model", warnings);
-	if (modelSpec !== undefined) {
-		resolved.model = modelSpec === null ? undefined : modelSpec;
+	if (raw.nativeFallback !== undefined) {
+		if (isRecord(raw.nativeFallback)) {
+			applyNativeFallbackConfig(raw.nativeFallback, resolved.nativeFallback, warnings);
+		} else {
+			warnings.push("Ignoring compaction.nativeFallback: expected a JSON object.");
+		}
 	}
 
-	resolved.thinkingLevel =
-		toThinkingLevel(raw.thinkingLevel, "compaction.thinkingLevel", warnings) ?? resolved.thinkingLevel;
-
 	if (raw.autoCompaction !== undefined) {
 		if (isRecord(raw.autoCompaction)) {
 			applyAutoCompactionConfig(raw.autoCompaction, resolved.autoCompaction, warnings);
@@ -306,7 +401,7 @@ function applyWebSearchConfig(
 	warnUnknownFields(raw, WEB_SEARCH_FIELDS, "webSearch", warnings);
 	resolved.enabled = toBoolean(raw.enabled, "webSearch.enabled", warnings) ?? resolved.enabled;
 
-	const models = toModelAllowlist(raw.models, "webSearch.models", warnings);
+	const models = toStringList(raw.models, "webSearch.models", warnings);
 	if (models !== undefined) {
 		resolved.models = models;
 	}
@@ -320,11 +415,147 @@ function applyImageGenerationConfig(
 	warnUnknownFields(raw, IMAGE_GENERATION_FIELDS, "imageGeneration", warnings);
 	resolved.enabled =
 		toBoolean(raw.enabled, "imageGeneration.enabled", warnings) ?? resolved.enabled;
+}
+
+function applyAutoModeConfig(
+	raw: Record<string, unknown>,
+	resolved: AutoModeConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, AUTO_MODE_FIELDS, "autoMode", warnings);
+	resolved.enabled = toBoolean(raw.enabled, "autoMode.enabled", warnings) ?? resolved.enabled;
 
-	const models = toModelAllowlist(raw.models, "imageGeneration.models", warnings);
+	const models = toStringList(raw.models, "autoMode.models", warnings);
 	if (models !== undefined) {
 		resolved.models = models;
 	}
+
+	const reviewerModel = toModelSpec(raw.reviewerModel, "autoMode.reviewerModel", warnings);
+	if (reviewerModel !== undefined) {
+		resolved.reviewerModel = reviewerModel === null ? undefined : reviewerModel;
+	}
+
+	resolved.gate = toAutoModeGate(raw.gate, "autoMode.gate", warnings) ?? resolved.gate;
+
+	const extraTools = toStringList(raw.extraTools, "autoMode.extraTools", warnings);
+	if (extraTools !== undefined) {
+		resolved.extraTools = extraTools;
+	}
+
+	const timeoutMs = toReviewerTimeoutMs(raw.timeoutMs, "autoMode.timeoutMs", warnings);
+	if (timeoutMs !== undefined) {
+		resolved.timeoutMs = timeoutMs;
+	}
+
+	resolved.transcript = toBoolean(raw.transcript, "autoMode.transcript", warnings) ?? resolved.transcript;
+	resolved.evidenceTools =
+		toBoolean(raw.evidenceTools, "autoMode.evidenceTools", warnings) ?? resolved.evidenceTools;
+
+	const maxEvidenceRounds = toBoundedInteger(
+		raw.maxEvidenceRounds,
+		"autoMode.maxEvidenceRounds",
+		warnings,
+		EVIDENCE_ROUNDS_MIN,
+		EVIDENCE_ROUNDS_MAX,
+	);
+	if (maxEvidenceRounds !== undefined) {
+		resolved.maxEvidenceRounds = maxEvidenceRounds;
+	}
+
+	if (raw.classifier !== undefined) {
+		if (isRecord(raw.classifier)) {
+			applyAutoModeClassifierConfig(raw.classifier, resolved.classifier, warnings);
+		} else {
+			warnings.push("Ignoring autoMode.classifier: expected a JSON object.");
+		}
+	}
+
+	if (raw.circuitBreaker !== undefined) {
+		if (isRecord(raw.circuitBreaker)) {
+			applyAutoModeBreakerConfig(raw.circuitBreaker, resolved.circuitBreaker, warnings);
+		} else {
+			warnings.push("Ignoring autoMode.circuitBreaker: expected a JSON object.");
+		}
+	}
+}
+
+function applyAutoModeClassifierConfig(
+	raw: Record<string, unknown>,
+	resolved: AutoModeClassifierConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, AUTO_MODE_CLASSIFIER_FIELDS, "autoMode.classifier", warnings);
+	resolved.enabled =
+		toBoolean(raw.enabled, "autoMode.classifier.enabled", warnings) ?? resolved.enabled;
+
+	const model = toModelSpec(raw.model, "autoMode.classifier.model", warnings);
+	if (model !== undefined) {
+		resolved.model = model === null ? undefined : model;
+	}
+
+	const timeoutMs =
+		toBoundedInteger(
+			raw.timeoutMs,
+			"autoMode.classifier.timeoutMs",
+			warnings,
+			REVIEWER_TIMEOUT_MIN_MS,
+			REVIEWER_TIMEOUT_MAX_MS,
+		) ?? DEFAULT_CLASSIFIER_TIMEOUT_MS;
+	if (raw.timeoutMs !== undefined) {
+		resolved.timeoutMs = timeoutMs;
+	}
+
+	const maxLag = toBoundedInteger(
+		raw.maxLag,
+		"autoMode.classifier.maxLag",
+		warnings,
+		CLASSIFIER_MAX_LAG_MIN,
+		CLASSIFIER_MAX_LAG_MAX,
+	);
+	if (maxLag !== undefined) {
+		resolved.maxLag = maxLag;
+	}
+}
+
+function applyAutoModeBreakerConfig(
+	raw: Record<string, unknown>,
+	resolved: AutoModeCircuitBreakerConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, AUTO_MODE_BREAKER_FIELDS, "autoMode.circuitBreaker", warnings);
+
+	const consecutiveDenials = toBoundedInteger(
+		raw.consecutiveDenials,
+		"autoMode.circuitBreaker.consecutiveDenials",
+		warnings,
+		BREAKER_LIMIT_MIN,
+		BREAKER_LIMIT_MAX,
+	);
+	if (consecutiveDenials !== undefined) {
+		resolved.consecutiveDenials = consecutiveDenials;
+	}
+
+	const recentDenials = toBoundedInteger(
+		raw.recentDenials,
+		"autoMode.circuitBreaker.recentDenials",
+		warnings,
+		BREAKER_LIMIT_MIN,
+		BREAKER_LIMIT_MAX,
+	);
+	if (recentDenials !== undefined) {
+		resolved.recentDenials = recentDenials;
+	}
+
+	const windowSize = toBoundedInteger(
+		raw.windowSize,
+		"autoMode.circuitBreaker.windowSize",
+		warnings,
+		BREAKER_WINDOW_MIN,
+		BREAKER_WINDOW_MAX,
+	);
+	if (windowSize !== undefined) {
+		resolved.windowSize = windowSize;
+	}
 }
 
 /**
@@ -365,6 +596,14 @@ export function loadToolkitConfig(configPath: string = CONFIG_PATH): LoadedToolk
 				warnings.push("Ignoring imageGeneration: expected a JSON object.");
 			}
 		}
+
+		if (raw.autoMode !== undefined) {
+			if (isRecord(raw.autoMode)) {
+				applyAutoModeConfig(raw.autoMode, resolved.autoMode, warnings);
+			} else {
+				warnings.push("Ignoring autoMode: expected a JSON object.");
+			}
+		}
 	}
 
 	resolved.compaction.artifactRoot = resolveConfiguredPath(

package/src/extension-runtime.ts

@@ -316,6 +316,7 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 	}
 
 	// Branch 1: Responses-family APIs use remote_compaction_v2 on the normal Responses stream.
+	let remoteAttempted = false;
 	const resolution = await resolveRemoteCompactionExecution(
 		ctx,
 		{
@@ -325,6 +326,7 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 		config.remoteCompactModel,
 	);
 	if (resolution.ok) {
+		remoteAttempted = true;
 		const responsesOutcome = await runResponsesNativeCompact(event, ctx, config, resolution.execution);
 		if (responsesOutcome.outcome === "success") {
 			return { compaction: responsesOutcome.compaction };
@@ -357,8 +359,10 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 		}
 	}
 
-	// Branch 2: run pi's native compaction method with the configured model.
-	const fallback = await runNativeFallbackCompaction({ ctx, event, config });
+	// Branch 2: run pi's native compaction method. A failed remote request is compacted by the
+	// remote producer itself; a model that cannot use remote v2 at all uses nativeFallback.model.
+	const fallbackModelSpec = remoteAttempted ? config.remoteCompactModel : config.nativeFallback.model;
+	const fallback = await runNativeFallbackCompaction({ ctx, event, config, modelSpec: fallbackModelSpec });
 	if (fallback.ok) {
 		if (ctx.hasUI) {
 			ctx.ui.notify(
@@ -394,8 +398,12 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 		ctx,
 	);
 
-	// Intentional pi-default paths: no configured model, or it matches the current one.
-	if (fallback.reason !== "no-model-configured" && fallback.reason !== "same-as-current-model") {
+	// Intentional pi-default paths: feature disabled, nothing configured, or it matches the current one.
+	const intentionalSkip =
+		fallback.reason === "disabled" ||
+		fallback.reason === "no-model-configured" ||
+		fallback.reason === "same-as-current-model";
+	if (!intentionalSkip) {
 		notifyWarning(
 			ctx,
 			`compaction model "${fallback.modelSpec}" unusable (${fallback.reason}${fallback.errorMessage ? `: ${fallback.errorMessage}` : ""}); using pi's default compaction`,