@oh-my-pi/pi-coding-agent 15.13.2 → 16.0.0

package/src/advisor/advise-tool.ts

@@ -0,0 +1,87 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { z } from "zod/v4";
+import adviseDescription from "../prompts/advisor/advise-tool.md" with { type: "text" };
+
+const adviseSchema = z.object({
+	note: z
+		.string()
+		.describe("One concrete piece of advice for the agent you are watching. Terse, specific, actionable."),
+	severity: z
+		.enum(["nit", "concern", "blocker"])
+		.optional()
+		.describe("How strongly to weigh this. Omit for a plain nit."),
+});
+
+export type AdviseParams = z.infer<typeof adviseSchema>;
+
+export type AdvisorSeverity = "nit" | "concern" | "blocker";
+
+export interface AdviseDetails {
+	note: string;
+	severity?: AdvisorSeverity;
+}
+
+/** One queued advice note. */
+export interface AdvisorNote {
+	note: string;
+	severity?: AdvisorSeverity;
+}
+
+/** Details payload on the batched `advisor` custom message rendered in the transcript. */
+export interface AdvisorMessageDetails {
+	notes: AdvisorNote[];
+}
+
+/**
+ * Prose framing prepended to every batched advisor message. Kept here so the
+ * non-interrupting YieldQueue dispatcher and the interrupting steer path build
+ * byte-identical content.
+ */
+const ADVISOR_BATCH_PREFIX = "Advisor (a senior reviewer watching your work — weigh it, don't blindly obey):";
+
+/** Render one advisor card body from a batch of notes (prefix + one bullet per note). */
+export function formatAdvisorBatchContent(notes: readonly AdvisorNote[]): string {
+	return `${ADVISOR_BATCH_PREFIX}\n${notes.map(n => `- ${n.severity ? `[${n.severity}] ` : ""}${n.note}`).join("\n")}`;
+}
+
+/**
+ * Whether advice at this severity should interrupt the running agent (delivered
+ * via the steering channel, aborting in-flight tools) rather than ride the
+ * non-interrupting aside queue that lands at the next step boundary. `concern`
+ * and `blocker` interrupt; a plain `nit` queues.
+ */
+export function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean {
+	return severity === "concern" || severity === "blocker";
+}
+
+/**
+ * Side-effect-free investigation tools handed to the advisor agent so it can
+ * inspect the workspace before weighing in. Names match the primary session's
+ * tool instances, which the advisor reuses.
+ */
+export const ADVISOR_READONLY_TOOL_NAMES: ReadonlySet<string> = new Set(["read", "search", "find"]);
+
+export class AdviseTool implements AgentTool<typeof adviseSchema, AdviseDetails> {
+	readonly name = "advise";
+	readonly label = "Advise";
+	readonly description = adviseDescription;
+	readonly parameters = adviseSchema;
+	readonly intent = "omit" as const;
+
+	constructor(private readonly onAdvice: (note: string, severity?: AdviseDetails["severity"]) => void) {}
+
+	async execute(
+		_toolCallId: string,
+		args: AdviseParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<AdviseDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<AdviseDetails>> {
+		this.onAdvice(args.note, args.severity);
+		return {
+			content: [{ type: "text", text: "Recorded." }],
+			details: { note: args.note, severity: args.severity },
+			useless: true,
+		};
+	}
+}

package/src/advisor/index.ts

@@ -0,0 +1,3 @@
+export * from "./advise-tool";
+export * from "./runtime";
+export * from "./watchdog";

package/src/advisor/runtime.ts

@@ -0,0 +1,248 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
+import { logger } from "@oh-my-pi/pi-utils";
+import { formatSessionHistoryMarkdown } from "../session/session-history-format";
+
+/** Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core `Agent`. */
+export interface AdvisorAgent {
+	prompt(input: string): Promise<void>;
+	abort(reason?: unknown): void;
+	reset(): void;
+	readonly state: { messages: AgentMessage[] };
+}
+
+export interface AdvisorRuntimeHost {
+	/** Live primary transcript (use `agent.state.messages`). */
+	snapshotMessages(): AgentMessage[];
+	/** Surface one advice note to the primary (enqueues into the session YieldQueue). */
+	enqueueAdvice(note: string, severity?: "nit" | "concern" | "blocker"): void;
+	/**
+	 * Pre-prompt context maintenance for the advisor's own append-only context.
+	 * Promotes the advisor model to a larger sibling when its context nears the
+	 * window (mirroring the primary's promote-first policy) and resolves `true`
+	 * when the advisor should re-prime — reset and replay the current
+	 * primary-bounded transcript — because promotion did not free enough room.
+	 * Optional: hosts that omit it get no maintenance (context only shrinks when
+	 * the primary's next compaction triggers {@link AdvisorRuntime.reset}).
+	 */
+	maintainContext?(incomingTokens: number): Promise<boolean>;
+}
+
+interface PendingDelta {
+	text: string;
+	turns: number;
+}
+
+interface CatchupWaiter {
+	threshold: number;
+	resolve: () => void;
+	finish: () => void;
+	timer?: NodeJS.Timeout;
+}
+
+export class AdvisorRuntime {
+	#lastCount = 0;
+	#pending: PendingDelta[] = [];
+	#busy = false;
+	#backlog = 0;
+	#consecutiveFailures = 0;
+	#latestMessages?: AgentMessage[];
+	#waiters: CatchupWaiter[] = [];
+	disposed = false;
+
+	constructor(
+		private readonly agent: AdvisorAgent,
+		private readonly host: AdvisorRuntimeHost,
+		private readonly retryDelayMs = 1000,
+	) {}
+
+	get backlog(): number {
+		return this.#backlog;
+	}
+
+	onTurnEnd(messages?: AgentMessage[]): void {
+		if (this.disposed) return;
+		const all = messages ?? this.host.snapshotMessages();
+		this.#latestMessages = all;
+		const render = this.#renderDelta(all);
+		if (render) {
+			this.#pending.push({ text: render, turns: 1 });
+			this.#backlog++;
+			this.#notifyWaiters();
+			void this.#drain();
+		}
+	}
+
+	waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<void> {
+		if (this.disposed || signal?.aborted || this.#backlog < threshold) return Promise.resolve();
+		const { promise, resolve } = Promise.withResolvers<void>();
+		let waiter!: CatchupWaiter;
+		const finish = (): void => {
+			const idx = this.#waiters.indexOf(waiter);
+			if (idx >= 0) this.#waiters.splice(idx, 1);
+			clearTimeout(waiter.timer);
+			signal?.removeEventListener("abort", finish);
+			resolve();
+		};
+		waiter = { threshold, resolve, finish, timer: setTimeout(finish, maxMs) };
+		this.#waiters.push(waiter);
+		signal?.addEventListener("abort", finish, { once: true });
+		if (signal?.aborted) {
+			finish();
+		}
+		return promise;
+	}
+
+	dispose(): void {
+		this.disposed = true;
+		this.#pending = [];
+		this.#backlog = 0;
+		this.#consecutiveFailures = 0;
+		this.#wakeAllWaiters();
+		try {
+			this.agent.abort("advisor disposed");
+		} catch {}
+	}
+
+	#resetAdvisorContext(clearBacklog: boolean, wakeWaiters: boolean): void {
+		this.#lastCount = 0;
+		this.#pending = [];
+		this.#consecutiveFailures = 0;
+		if (clearBacklog) {
+			this.#backlog = 0;
+		}
+		if (wakeWaiters) {
+			this.#wakeAllWaiters();
+		}
+		try {
+			this.agent.reset();
+		} catch {}
+		try {
+			this.agent.abort("advisor reset");
+		} catch {}
+	}
+
+	/**
+	 * Re-prime the advisor after a history rewrite (compaction, session
+	 * switch/resume, branch). Clears the advisor's own (non-persisted) context
+	 * and rewinds the cursor to 0 so the NEXT turn replays the full current —
+	 * post-compaction — transcript, giving the advisor fresh context instead of
+	 * leaving it blind to everything before the rewrite.
+	 */
+	reset(): void {
+		this.#resetAdvisorContext(true, true);
+	}
+
+	/**
+	 * Seed the cursor to the current transcript length when the advisor is enabled
+	 * mid-session. Prevents the next turn from replaying the entire history to the
+	 * advisor (which would be expensive and likely stale).
+	 */
+	seedTo(count: number): void {
+		this.#lastCount = count;
+		this.#pending = [];
+		this.#backlog = 0;
+		this.#consecutiveFailures = 0;
+		this.#wakeAllWaiters();
+	}
+
+	#renderDelta(messages?: AgentMessage[]): string | null {
+		const all = messages ?? this.#latestMessages ?? this.host.snapshotMessages();
+		if (all.length < this.#lastCount) {
+			this.#lastCount = all.length;
+			return null;
+		}
+		const delta = all
+			.slice(this.#lastCount)
+			.filter(m => !(m.role === "custom" && (m as { customType?: string }).customType === "advisor"));
+		this.#lastCount = all.length;
+		if (delta.length === 0) return null;
+		const md = formatSessionHistoryMarkdown(delta, { includeThinking: true, includeToolIntent: true });
+		return md.trim() ? md : null;
+	}
+
+	#notifyWaiters(): void {
+		for (let i = this.#waiters.length - 1; i >= 0; i--) {
+			const w = this.#waiters[i];
+			if (this.#backlog < w.threshold) {
+				w.finish();
+			}
+		}
+	}
+
+	#wakeAllWaiters(): void {
+		for (const w of [...this.#waiters]) {
+			w.finish();
+		}
+	}
+
+	async #drain(): Promise<void> {
+		if (this.#busy) return;
+		this.#busy = true;
+		try {
+			while (!this.disposed && this.#pending.length) {
+				const popped = this.#pending.splice(0);
+				const candidateBatch = popped.map(b => b.text).join("\n\n---\n\n");
+				const turnsCovered = popped.reduce((sum, b) => sum + b.turns, 0);
+				const incomingTokens = estimateTokens({
+					role: "user",
+					content: candidateBatch,
+					timestamp: Date.now(),
+				});
+
+				let shouldReprime = false;
+				if (this.host.maintainContext) {
+					try {
+						shouldReprime = await this.host.maintainContext(incomingTokens);
+					} catch (err) {
+						logger.debug("advisor context maintenance failed", { err: String(err) });
+					}
+				}
+
+				let batch: string | null;
+				let finalTurns: number;
+				if (shouldReprime) {
+					// Promotion could not fit the advisor's context — re-prime.
+					const newTurns = this.#pending.reduce((sum, b) => sum + b.turns, 0);
+					this.#resetAdvisorContext(false, false);
+					batch = this.#renderDelta(this.#latestMessages);
+					finalTurns = turnsCovered + newTurns;
+				} else {
+					batch = candidateBatch;
+					finalTurns = turnsCovered;
+				}
+
+				if (this.disposed || batch === null) {
+					this.#backlog = Math.max(0, this.#backlog - finalTurns);
+					this.#notifyWaiters();
+					continue;
+				}
+
+				let success = false;
+				try {
+					await this.agent.prompt(batch);
+					success = true;
+					this.#consecutiveFailures = 0;
+				} catch (err) {
+					logger.debug("advisor turn failed", { err: String(err) });
+					this.#consecutiveFailures++;
+					if (this.#consecutiveFailures >= 3) {
+						logger.warn("advisor failed consecutively 3 times; dropping backlog to prevent stall");
+						this.#consecutiveFailures = 0;
+						success = true;
+					} else {
+						this.#pending.unshift({ text: batch, turns: finalTurns });
+						await Bun.sleep(this.retryDelayMs);
+					}
+				}
+
+				if (success) {
+					this.#backlog = Math.max(0, this.#backlog - finalTurns);
+					this.#notifyWaiters();
+				}
+			}
+		} finally {
+			this.#busy = false;
+		}
+	}
+}

package/src/advisor/watchdog.ts

@@ -0,0 +1,83 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { expandAtImports } from "../discovery/at-imports";
+import { repo } from "../utils/git";
+
+/**
+ * Discover and load WATCHDOG.md files walking up from cwd, project .omp folder, and user agent dir.
+ * Returns formatted watchdog file blocks ready to be appended to the advisor system prompt.
+ */
+export async function discoverWatchdogFiles(cwd: string, agentDir?: string): Promise<string[]> {
+	const home = os.homedir();
+	const resolvedAgentDir = agentDir ?? getAgentDir();
+	const userPath = resolvedAgentDir ? path.resolve(resolvedAgentDir, "WATCHDOG.md") : null;
+	let repoRoot: string | null = null;
+	try {
+		repoRoot = await repo.root(cwd);
+	} catch (err) {
+		logger.debug("Failed to resolve git root for watchdog discovery", { err: String(err) });
+	}
+
+	const candidates = new Set<string>();
+
+	// 1. User level: ~/.omp/WATCHDOG.md (or active profile agent dir)
+	if (resolvedAgentDir) {
+		candidates.add(path.resolve(resolvedAgentDir, "WATCHDOG.md"));
+	}
+
+	// 2. Project levels (both standalone and native config .omp/): walk up from cwd to repoRoot / home
+	let current = cwd;
+	while (true) {
+		candidates.add(path.resolve(current, ".omp", "WATCHDOG.md"));
+		candidates.add(path.resolve(current, "WATCHDOG.md"));
+
+		if (current === (repoRoot ?? home)) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+
+	const items: Array<{ path: string; content: string; level: "user" | "project"; depth: number }> = [];
+
+	for (const candidate of candidates) {
+		try {
+			const content = await Bun.file(candidate).text();
+			const expanded = await expandAtImports(content, candidate);
+			const parent = path.dirname(candidate);
+			const baseName = parent.split(path.sep).pop() ?? "";
+
+			const isUser = userPath !== null && candidate === userPath;
+			const ownerDir = baseName === ".omp" ? path.dirname(parent) : parent;
+			const ownerBaseName = ownerDir.split(path.sep).pop() ?? "";
+
+			if (isUser || !ownerBaseName.startsWith(".") || baseName === ".omp") {
+				const relative = path.relative(cwd, ownerDir);
+				const depth = relative === "" ? 0 : relative.split(path.sep).filter(Boolean).length;
+				items.push({
+					path: candidate,
+					content: expanded,
+					level: isUser ? "user" : "project",
+					depth,
+				});
+			}
+		} catch (err) {
+			if (!isEnoent(err)) {
+				logger.warn("Failed to read WATCHDOG.md candidate", { path: candidate, error: String(err) });
+			}
+		}
+	}
+
+	// Sort files so that user level comes first, then project level sorted by depth (descending).
+	// This means user-level rules are first, then project-level rules from ancestor directories down to the leaf directory (depth 0 is last/most prominent).
+	items.sort((a, b) => {
+		if (a.level !== b.level) {
+			return a.level === "user" ? -1 : 1;
+		}
+		return b.depth - a.depth;
+	});
+
+	return items.map(item => {
+		return `Especially pay attention to:\n<attention>\n${item.content}\n</attention>`;
+	});
+}

package/src/cli.ts

@@ -14,6 +14,7 @@ try {
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
+import { parentPort } from "node:worker_threads";
 import type { CliConfig } from "@oh-my-pi/pi-utils/cli";
 import {
 	APP_NAME,
@@ -23,7 +24,7 @@ import {
 	setProfile,
 	VERSION,
 } from "@oh-my-pi/pi-utils/dirs";
-import { declareWorkerHostEntry } from "@oh-my-pi/pi-utils/worker-host";
+import { declareWorkerHostEntry, installWorkerInbox } from "@oh-my-pi/pi-utils/worker-host";
 import { installProfileAlias, resolveProfileAliasCommandFromProcess } from "./cli/profile-alias";
 import { extractProfileFlags } from "./cli/profile-bootstrap";
 
@@ -67,6 +68,7 @@ async function runSmokeTest(): Promise<void> {
 	const { smokeTestTinyTitleWorker } = await import("./tiny/title-client");
 	const { smokeTestSttWorker } = await import("./stt/asr-client");
 	const { smokeTestTtsWorker } = await import("./tts/tts-client");
+	const { smokeTestJsEvalWorker } = await import("./eval/js/context-manager");
 	await smokeTestSyncWorker();
 
 	const statsServer = await startServer(0);
@@ -83,18 +85,23 @@ async function runSmokeTest(): Promise<void> {
 
 	await smokeTestTinyTitleWorker();
 	await smokeTestSttWorker();
+	await smokeTestJsEvalWorker();
 	await smokeTestTtsWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
-const TINY_WORKER_ARGS = new Set(["--tiny-worker", "__tiny_worker"]);
-const STATS_SYNC_WORKER_ARG = "__omp_stats_sync_worker";
-const TAB_WORKER_ARG = "__omp_tab_worker";
-const JS_EVAL_WORKER_ARG = "__omp_js_eval_worker";
-const STT_WORKER_ARG = "__omp_stt_worker";
-const TTS_WORKER_ARG = "__omp_tts_worker";
+const TINY_WORKER_ARG = "__omp_worker_tiny_inference";
+const STATS_SYNC_WORKER_ARG = "__omp_worker_stats_sync";
+const TAB_WORKER_ARG = "__omp_worker_tab";
+const JS_EVAL_WORKER_ARG = "__omp_worker_js_eval";
+const STT_WORKER_ARG = "__omp_worker_stt";
+const TTS_WORKER_ARG = "__omp_worker_tts";
 
 async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
+	if (arg === TINY_WORKER_ARG) {
+		await runTinyWorker();
+		return true;
+	}
 	if (arg === STATS_SYNC_WORKER_ARG) {
 		// The sync worker handles messages via `self.onmessage`, assigned during
 		// this *async* dynamic import. Bun flushes the worker's initial message
@@ -117,11 +124,20 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 		}
 		return true;
 	}
+	// Bun flushes messages the parent posted before spawn once this entry's
+	// top-level evaluation completes, delivering them only to listeners present
+	// at that moment. These worker modules are imported dynamically below, so
+	// their own `parentPort.on("message")` lands after the flush and the parent's
+	// synchronous `init` is dropped. Install a buffering inbox synchronously here
+	// (still inside the entry's sync prefix) so the handshake survives; the worker
+	// module binds the real handler once loaded.
 	if (arg === TAB_WORKER_ARG) {
+		if (parentPort) installWorkerInbox(parentPort);
 		await import("./tools/browser/tab-worker-entry");
 		return true;
 	}
 	if (arg === JS_EVAL_WORKER_ARG) {
+		if (parentPort) installWorkerInbox(parentPort);
 		await import("./eval/js/worker-entry");
 		return true;
 	}
@@ -251,11 +267,8 @@ export async function runCli(argv: string[]): Promise<void> {
 	// synchronous prefix of `runWorkerEntrypoint`, and Bun flushes the
 	// worker's parked initial messages as soon as the entry module's
 	// top-level evaluation finishes.
-	if (TINY_WORKER_ARGS.has(resolvedArgv[0] ?? "")) {
-		await runTinyWorker();
-		return;
-	}
-	if (await runWorkerEntrypoint(resolvedArgv[0])) {
+	if (resolvedArgv[0]?.startsWith("__omp_worker_")) {
+		await runWorkerEntrypoint(resolvedArgv[0]);
 		return;
 	}
 

package/src/config/model-registry.ts

@@ -59,7 +59,7 @@ import {
 	resolveCanonicalVariant,
 	resolveModelReference,
 } from "@oh-my-pi/pi-catalog/identity";
-import { isRecord, logger } from "@oh-my-pi/pi-utils";
+import { isBunTestRuntime, isRecord, logger } from "@oh-my-pi/pi-utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
 import { type ApiKeyResolverModel, type ApiKeyResolverOptions, createApiKeyResolver } from "./api-key-resolver";
@@ -690,7 +690,11 @@ export class ModelRegistry {
 		modelsPath?: string,
 		options?: { fetch?: FetchImpl },
 	) {
-		this.#fetch = options?.fetch ?? fetch;
+		this.#fetch =
+			options?.fetch ??
+			(isBunTestRuntime()
+				? () => Promise.reject(new Error("network disabled in model-registry runtime test"))
+				: fetch);
 		this.#modelsConfigFile = ModelsConfigFile.relocate(modelsPath);
 		this.#cacheDbPath = modelsPath ? path.join(path.dirname(modelsPath), "models.db") : undefined;
 		// Set up fallback resolver for custom provider API keys

package/src/config/model-roles.ts

@@ -5,7 +5,17 @@
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { Settings } from "./settings";
 
-export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "title" | "task";
+export type ModelRole =
+	| "default"
+	| "smol"
+	| "slow"
+	| "vision"
+	| "plan"
+	| "designer"
+	| "commit"
+	| "title"
+	| "task"
+	| "advisor";
 
 export interface ModelRoleInfo {
 	tag?: string;
@@ -25,6 +35,7 @@ export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
 	commit: { tag: "COMMIT", name: "Commit", color: "dim" },
 	title: { tag: "TITLE", name: "Title", color: "dim", hidden: true },
 	task: { tag: "TASK", name: "Subtask", color: "muted" },
+	advisor: { tag: "ADVISOR", name: "Advisor", color: "accent" },
 };
 
 export const MODEL_ROLE_IDS: ModelRole[] = [
@@ -37,6 +48,7 @@ export const MODEL_ROLE_IDS: ModelRole[] = [
 	"commit",
 	"title",
 	"task",
+	"advisor",
 ];
 
 export type RoleInfo = ModelRoleInfo;

package/src/config/settings-schema.ts

@@ -106,7 +106,7 @@ export const TAB_METADATA: Record<SettingTab, { label: string; icon: `tab.${stri
  */
 export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 	appearance: ["Theme", "Status Line", "Display", "Images"],
-	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback"],
+	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback", "Advisor"],
 	interaction: [
 		"Input",
 		"Approvals",
@@ -116,6 +116,7 @@ export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 		"Magic Keywords",
 		"Startup & Updates",
 		"Power (macOS)",
+		"Agent",
 	],
 	context: ["General", "Compaction", "Rules (TTSR)", "Experimental"],
 	memory: ["General", "Auto-Learn", "Mnemopi", "Hindsight"],
@@ -380,6 +381,39 @@ export const SETTINGS_SCHEMA = {
 			description: "Keep the display from idle-sleeping while a session is open (caffeinate -d)",
 		},
 	},
+	"advisor.enabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Advisor",
+			label: "Enable Advisor",
+			description:
+				"Pair a second model (assigned to the 'advisor' role) that passively reviews each turn and injects notes.",
+		},
+	},
+	"advisor.subagents": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Advisor",
+			label: "Advisor for Subagents",
+			description: "Also enable the advisor on spawned task/eval subagents.",
+		},
+	},
+	"advisor.syncBacklog": {
+		type: "enum",
+		values: ["off", "1", "3", "5"] as const,
+		default: "off",
+		ui: {
+			tab: "model",
+			group: "Advisor",
+			label: "Advisor Sync Backlog",
+			description:
+				"Pause the main agent for up to 30 seconds if the advisor falls behind by this many turns. Off disables catch-up delays.",
+		},
+	},
 	shellPath: { type: "string", default: undefined },
 
 	extensions: { type: "array", default: EMPTY_STRING_ARRAY },
@@ -1733,14 +1767,16 @@ export const SETTINGS_SCHEMA = {
 			"harmony",
 			"pi",
 			"qwen3",
+			"gemini",
+			"gemma",
 		] as const,
 		default: "auto",
 		ui: {
 			tab: "context",
 			group: "Experimental",
-			label: "Tool Call Format",
+			label: "Tool Calling Mode",
 			description:
-				"Controls how tools are exposed to the model. Auto uses native tool calls unless the selected model is marked as not supporting tools, then falls back to GLM-style in-band tool calls. Native forces provider-native tools; the other values force the named in-band syntax. Applies on session start.",
+				"Controls how tools are exposed to the model. Auto uses provider-native tool calls unless the selected model is marked as not supporting them, then falls back to the GLM owned dialect. Native forces provider-native tools; the other values force the named owned dialect. Applies on session start.",
 			options: [
 				{
 					value: "auto",
@@ -1755,8 +1791,10 @@ export const SETTINGS_SCHEMA = {
 				{ value: "anthropic", label: "Anthropic", description: "Use Anthropic-style in-band tool calls." },
 				{ value: "deepseek", label: "DeepSeek", description: "Use DeepSeek-style in-band tool calls." },
 				{ value: "harmony", label: "Harmony", description: "Use Harmony-style in-band tool calls." },
-				{ value: "pi", label: "Pi", description: "Use Pi-style in-band tool calls." },
-				{ value: "qwen3", label: "Qwen3", description: "Use Qwen3-style in-band tool calls." },
+				{ value: "pi", label: "Pi", description: "Use the Pi owned dialect." },
+				{ value: "qwen3", label: "Qwen3", description: "Use the Qwen3 owned dialect." },
+				{ value: "gemini", label: "Gemini", description: "Use the Gemini owned dialect." },
+				{ value: "gemma", label: "Gemma", description: "Use the Gemma owned dialect." },
 			],
 		},
 	},
@@ -3993,6 +4031,30 @@ export const SETTINGS_SCHEMA = {
 			options: AUTO_THINKING_MODEL_OPTIONS,
 		},
 	},
+	"features.unexpectedStopDetection": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "interaction",
+			group: "Agent",
+			label: "Detect unexpected stops",
+			description:
+				"Use a small model to detect when the assistant says it will continue but stops without tool calls; automatically prompt it to continue.",
+		},
+	},
+	"providers.unexpectedStopModel": {
+		type: "enum",
+		values: TINY_MEMORY_MODEL_VALUES,
+		default: ONLINE_MEMORY_MODEL_KEY,
+		ui: {
+			tab: "providers",
+			group: "Tiny Model",
+			label: "Unexpected Stop Model",
+			description: "Classifier for unexpected-stop detection: online smol by default, or a local on-device model.",
+			condition: "unexpectedStopDetection",
+			options: TINY_MEMORY_MODEL_OPTIONS,
+		},
+	},
 
 	"providers.kimiApiFormat": {
 		type: "enum",