@estebanforge/pi-antigravity-bridge 1.5.3 → 1.6.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.6.1] - 2026-09-18
+
+### Added
+
+- **`thinking` / `effort` params on AskAntigravity (synonyms).** Delegation calls had no direct tier knob: the only lever was tier sugar inside `model` ("flash high"), so a caller told "peer review on high thinking" fell through to the configured default (medium) with no signal anything was dropped. The tool now takes `thinking` (pi vocabulary: minimal|low|medium|high|xhigh|max, clamped to agy's low|medium|high; unknown values fall back to low) plus `effort` as the same knob under agy's own name, so calling models reach for either word. An explicit level beats a tier embedded in `model` and the config default; passing both with different values errors; fixed-thinking families (Claude, GPT-OSS) ignore it because agy rejects `--effort` for them. `toAgyEffort` moved from `src/provider.ts` to `src/models.ts` so provider turns and the delegation tool share one clamp.
+
+## [1.6.0] - 2026-09-14
+
+### Added
+
+- Turn-cap knobs (`turnTimeoutMin`, `inactivityTimeoutMin`) with TTY-aware defaults. The "ACP turn exceeded the 10m deadline" error was the bridge's own overall turn cap - not a Google server limit: the ACP server binary exposes no timeout flag (`--helpfull` lists only debug/notices), and the stream-json engine carried the identical 10m cap ("agy exceeded the 10m turn timeout"). The cap never refreshed on activity, so healthy long turns died mid-task at exactly 10m. The default is now `0` (no cap) on an interactive pi - the user aborts with Esc and is the better backstop - and `20` minutes headless, where nobody can abort and one runaway turn blocks the drivers' serialized turn queue. Opt into a timed gate with 1-1440 minutes: free type via `config.json` or the new `/agy timeout <1-1440|off>` subcommand, or pick a preset (0/1/5/10/15/30/60/120/360/720/1440) in the `/agy` settings picker; `0` disables explicitly; garbage, negative, or >1440 falls back to the TTY-aware default. The 5m inactivity stall guard is unchanged, so a silent hung server still dies. Env `AGY_TURN_TIMEOUT_MIN` / `AGY_INACTIVITY_TIMEOUT_MIN` win over the file.
+
 ## [1.5.3] - 2026-09-10
 
 ### Fixed

package/README.md

@@ -123,8 +123,10 @@ If `agy models` fails at load (binary missing, auth not done, network stall), a
 | `bridgeTools` | `none` (bridge off), `all` (every non-builtin tool, incl. other `Ask*` delegations), `mcp` (pi-mcp-adapter tools + skills bridge only) | `all` |
 | `digest` | `off` (stable prompts; agy's prompt cache hits) or `on` (inject a delta of pi-side context - compaction summaries, other-provider turns - into each agy prompt; the delta changes every turn, so agy re-bills the full context). Enable for mixed-provider sessions where agy must see pi-side context | `off` |
 | `systemPrompt` | `on` (prepend pi's system prompt - operating instructions plus the global agent-dir `AGENTS.md` and ancestor `AGENTS.md`/`CLAUDE.md` - to the first prompt of each new agy conversation, plus a tool-priority note: Pi Bridge tools win over agy's native interactive ones, which never reach the user) or `off` (agy-native behavior) | `on` |
+| `turnTimeoutMin` | Overall cap on ONE agy turn, minutes, both engines. When it fires, the bridge kills the agy process mid-task ("ACP turn exceeded the 10m deadline" / "agy exceeded the 10m turn timeout") - it is a bridge cap, not a Google server limit. Default is TTY-aware: `0` (no cap) on an interactive pi - you are the backstop with Esc; `20` headless, where nobody can abort and one runaway turn blocks the serialized turn queue. Opt into a gate with 1-1440 (free type via `config.json` or `/agy timeout <1-1440|off>`, or the `/agy` picker's preset list); `0` disables explicitly; anything else falls back to the TTY-aware default. The 5m inactivity stall guard always still bounds a hung server | `0` TTY / `20` headless |
+| `inactivityTimeoutMin` | Silence cap, minutes, both engines: no stream-json stdout / no ACP session/update for this long fails the turn as a stall. `0` disables the guard | `5` |
 
-Env overrides: `AGY_BRIDGE_TOOLS`, `AGY_ASK_TOOL`, `AGY_DIGEST`, `AGY_SYSTEM_PROMPT`. Env wins over the file, so while `AGY_DIGEST` or `AGY_SYSTEM_PROMPT` is set, the matching `/agy digest` or `/agy system-prompt` toggle persists a value that never takes effect.
+Env overrides: `AGY_BRIDGE_TOOLS`, `AGY_ASK_TOOL`, `AGY_DIGEST`, `AGY_SYSTEM_PROMPT`, `AGY_TURN_TIMEOUT_MIN`, `AGY_INACTIVITY_TIMEOUT_MIN`. Env wins over the file, so while `AGY_DIGEST` or `AGY_SYSTEM_PROMPT` is set, the matching `/agy digest` or `/agy system-prompt` toggle persists a value that never takes effect.
 
 The `activate_skill` catalog mirrors pi's directory-based skill discovery: the two global dirs plus project dirs, the latter only when pi has trusted the project (same gate pi itself applies). Pi's other skill sources - the `skills` settings array, `package.json` entries, and `--skill` CLI paths - are not mirrored and won't appear in the catalog.
 

package/extensions/index.ts

@@ -65,7 +65,7 @@ import { runAcpAuth } from "../src/acp/auth.js";
 import { setupAuthUrlCapture } from "../src/acp/browser-capture.js";
 import { ensureAcpReady, inspectAcpSetup } from "../src/acp/setup.js";
 import type { TurnDriver, TurnOutcome } from "../src/driver-types.js";
-import { CONFIG_PATH, loadConfig, logsDir, saveConfig, type AgyMode, type BridgeTools, type Engine, type ThinkingTier } from "../src/config.js";
+import { CONFIG_PATH, loadConfig, logsDir, MAX_TURN_CAP_MIN, parseCapMinutes, saveConfig, type AgyMode, type BridgeTools, type Engine, type ThinkingTier } from "../src/config.js";
 import { agyMissingMessage, isAgyInstalled, savedEngineMessage, showEnginePicker, shouldOfferEnginePicker } from "../src/engine-picker.js";
 import { createDailyLogger, type DailyLogger } from "../src/daily-log.js";
 import { registerAskAntigravityTool, toolModelsFromRaw } from "../src/ask-tool.js";
@@ -905,6 +905,7 @@ interface PendingConfig {
 	skipPermissions?: boolean;
 	defaultModel?: string;
 	defaultThinking?: ThinkingTier;
+	turnTimeoutMin?: number;
 	askTool?: boolean;
 	bridgeTools?: BridgeTools;
 	digest?: boolean;
@@ -941,7 +942,7 @@ function statusText(ctx: AgyCommandCtx): string {
 function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 	pi.registerCommand("agy", {
 		description:
-			"Antigravity provider: status, doctor, settings picker, clear sessions. Usage: /agy [status|doctor|auth|auth-manual|engine stream-json|acp|mode plan|accept-edits|permissions on|off|ask on|off|model <alias>|thinking low|medium|high|bridge all|mcp|none|digest on|off|system-prompt on|off|acp-bin <path|auto>|patch-cleanup|clear]",
+			"Antigravity provider: status, doctor, settings picker, clear sessions. Usage: /agy [status|doctor|auth|auth-manual|engine stream-json|acp|mode plan|accept-edits|permissions on|off|ask on|off|model <alias>|thinking low|medium|high|bridge all|mcp|none|digest on|off|system-prompt on|off|timeout <1-1440|off>|acp-bin <path|auto>|patch-cleanup|clear]",
 		handler: async (args, cmdCtx: ExtensionCommandContext) => {
 			const ui = cmdCtx.ui;
 			if (ui) activeUi = ui;
@@ -976,6 +977,33 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				);
 				return;
 			}
+			if (sub === "timeout") {
+				// Free-type entry point for the turn cap (the TUI picker only offers
+				// presets). Same sanity rules as loadConfig: 1..MAX valid, off/0
+				// disables, anything else rejected with the valid range.
+				const live = loadConfig();
+				const cur = live.turnTimeoutMin;
+				if (!val) {
+					ui?.notify(
+						`Turn time cap: ${cur === 0 ? "off (no cap)" : `${cur}m`}. Usage: /agy timeout <1-${MAX_TURN_CAP_MIN}|off>. Default: off on an interactive pi, 20m headless.`,
+						"info",
+					);
+					return;
+				}
+				const parsed = val === "off" ? 0 : parseCapMinutes(val, Number.NaN);
+				if (Number.isNaN(parsed)) {
+					ui?.notify(`Invalid turn cap "${val}". Use 1-${MAX_TURN_CAP_MIN} minutes, or off/0 to disable.`, "error");
+					return;
+				}
+				saveConfig({ turnTimeoutMin: parsed });
+				ui?.notify(
+					parsed === 0
+						? `Turn time cap disabled. The inactivity stall guard (${live.inactivityTimeoutMin}m silence) still applies.`
+						: `Turn time cap set to ${parsed}m. Takes effect next turn.`,
+					"info",
+				);
+				return;
+			}
 			if (sub === "engine") {
 				if (val === "acp" || val === "stream-json") {
 					if (val === "acp" && loadConfig().mode === "plan") {
@@ -1354,6 +1382,14 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 			currentValue: config.bridgeTools,
 			values: ["all", "mcp", "none"],
 		},
+		{
+			id: "turn-cap",
+			label: "Turn time cap",
+			description:
+				"Max minutes for ONE agy turn before the bridge kills it. Default: no cap on an interactive pi (abort with Esc), 20 headless. 0 disables; 1-1440 enables the gate. Free type via /agy timeout <minutes|off> or config.json. Takes effect next turn.",
+			currentValue: String(config.turnTimeoutMin),
+			values: ["0", "1", "5", "10", "15", "30", "60", "120", "360", "720", "1440"],
+		},
 		{
 			id: "digest",
 			label: "Context digest",
@@ -1394,6 +1430,8 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 					pending.askTool = newValue === "on";
 				} else if (id === "bridge") {
 					pending.bridgeTools = newValue as BridgeTools;
+				} else if (id === "turn-cap") {
+					pending.turnTimeoutMin = Number(newValue);
 				} else if (id === "digest") {
 					pending.digest = newValue === "on";
 				} else if (id === "system-prompt") {
@@ -1441,6 +1479,7 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 			pending.bridgeTools !== undefined ? `bridge=${next.bridgeTools}` : null,
 			pending.digest !== undefined ? `digest=${next.digest ? "on" : "off"}` : null,
 			pending.systemPrompt !== undefined ? `system-prompt=${next.systemPrompt ? "on" : "off"}` : null,
+			pending.turnTimeoutMin !== undefined ? `turn cap=${next.turnTimeoutMin === 0 ? "off" : `${next.turnTimeoutMin}m`}` : null,
 		]
 			.filter(Boolean)
 			.join(", ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.5.3",
+  "version": "1.6.1",
   "description": "Gemini provider for Pi on the Antigravity ACP server (official Google ACP) or the stream-json agy CLI. antigravity/* models in Pi's /model picker, no-patch MCP bridge: agy runs Pi's tools. ToS safe to use.",
   "keywords": [
     "pi-package",

package/src/acp/driver.ts

@@ -611,6 +611,9 @@ export class AcpDriver implements TurnDriver {
 	}
 
 	#startOverallTimer(turn: ActiveTurn, ms: number): void {
+		// 0 disables the deadline (config turnTimeoutMin: 0). setTimeout(fn, 0)
+		// would fire instantly and kill every turn, guard or not.
+		if (ms <= 0) return;
 		// The deadline lives HERE, not just in the callers: the running branch
 		// of #armOverall never assigns it, and #pauseOverall keys off
 		// `deadline !== null` to do anything at all. Without this line every
@@ -649,13 +652,16 @@ export class AcpDriver implements TurnDriver {
 	#armIdle(turn: ActiveTurn): void {
 		if (turn.idleTimer) clearTimeout(turn.idleTimer);
 		if (turn.parks > 0) return; // parked: idle timer resumes on unpark
+		const idleMs = this.#idleBudgetMs(turn);
+		// 0 disables the stall guard (config inactivityTimeoutMin: 0).
+		if (idleMs <= 0) return;
 		turn.idleTimer = setTimeout(() => {
 			if (turn.closed) return;
 			this.#log("stall", { sessionId: turn.sessionId });
 			this.#conn?.abortAll("idle stall");
 			this.#conn?.kill();
-			this.#failTurn(turn, `ACP stalled for ${(this.#idleBudgetMs(turn) / 60_000) | 0}m with no output`);
-		}, this.#idleBudgetMs(turn));
+			this.#failTurn(turn, `ACP stalled for ${(idleMs / 60_000) | 0}m with no output`);
+		}, idleMs);
 	}
 
 	#clearIdle(turn: ActiveTurn): void {

package/src/ask-tool.ts

@@ -17,7 +17,7 @@ import * as path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildSessionContext, getAgentDir, keyHint } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { contentText } from "@earendil-works/pi-ai";
+import { contentText, type ThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 import {
 	CONVERSATIONS_DIR,
@@ -26,7 +26,7 @@ import {
 } from "./discovery.js";
 import { loadConfig, type AgyMode, type ThinkingTier } from "./config.js";
 import { acquireBridgeSuppression } from "./mcp-registration.js";
-import { spawnAgyModelsRaw } from "./models.js";
+import { AGY_EFFORT_ORDER, spawnAgyModelsRaw, toAgyEffort } from "./models.js";
 
 // --- Constants -------------------------------------------------------------
 
@@ -80,7 +80,12 @@ EXECUTION MODES (param: mode):
 - **plan**: agy reviews and plans without writing. Use for cross-review and read-only tasks.
 - **accept-edits** (default): agy applies edits directly inside the workspace.
 
-COMPACT OUTPUT (param: digest): when true, the prompt is prefixed to request compact digests instead of full file contents. Defaults on for plan, off for accept-edits.`;
+COMPACT OUTPUT (param: digest): when true, the prompt is prefixed to request compact digests instead of full file contents. Defaults on for plan, off for accept-edits.
+
+THINKING LEVEL (params: thinking, effort - SYNONYMS for one knob):
+- pi calls it thinking, agy calls it effort. Same thing. Pass ONE of the two.
+- Values (pi vocabulary): minimal|low|medium|high|xhigh|max. Clamped to agy's low|medium|high; unknown values fall back to low. "peer review on high thinking" -> thinking: "high".
+- An explicit level beats a tier embedded in model ("flash high") and the configured default. Omit both for the configured default.`;
 
 // --- Types -----------------------------------------------------------------
 
@@ -176,6 +181,10 @@ export function resolveModel(
 	input: string,
 	entries: ModelEntry[],
 	defaultThinking: ThinkingTier,
+	/** Explicit thinking param (thinking/effort). Beats a tier embedded in
+	 *  the alias ("flash high") and the configured default; clamped to the
+	 *  family's real tiers, ignored for fixed-thinking families. */
+	preferredTier?: ThinkingTier,
 ): ResolvedModel | null {
 	const lower = input.toLowerCase().trim();
 
@@ -232,6 +241,7 @@ export function resolveModel(
 	if (familyTiers.size === 0) return toResolved(candidates[0].full, null);
 
 	const preferred =
+		preferredTier ??
 		tier ??
 		(familyTiers.has(defaultThinking) ? defaultThinking : FAMILY_DEFAULT_TIER[family]);
 	const chosenTier = nearestTier([...familyTiers], preferred);
@@ -293,6 +303,18 @@ export async function registerAskAntigravityTool(
 						"Model alias or exact id. Friendly: 'flash', 'pro', 'gemini'. Add a tier: 'flash high'. Pin a version: '3.5 flash'. Exact: 'gemini-3.6-flash-medium'. Omit for the configured default.",
 				}),
 			),
+			thinking: Type.Optional(
+				Type.String({
+					description:
+						"Thinking level (= agy effort tier). pi vocabulary: minimal|low|medium|high|xhigh|max, clamped to agy's low|medium|high (unknown values fall back to low). Overrides a tier embedded in `model`. Omit for the configured default.",
+				}),
+			),
+			effort: Type.Optional(
+				Type.String({
+					description:
+						"Alias for `thinking` (agy's own name for the same knob). Pass ONE of the two; different values on both is an error.",
+				}),
+			),
 			mode: Type.Optional(
 				Type.Union([Type.Literal("plan"), Type.Literal("accept-edits")], {
 					description:
@@ -327,8 +349,14 @@ export async function registerAskAntigravityTool(
 			// row identifies what will actually run, not just explicit args.
 			const cfg = loadConfig();
 			const requestedModel = (args.model as string | undefined)?.trim() || cfg.defaultModel;
+			const thinkingArg = (args.thinking as string | undefined) ?? (args.effort as string | undefined);
 			const resolved =
-				resolveModel(requestedModel, entries, cfg.defaultThinking) ?? { model: requestedModel };
+				resolveModel(
+					requestedModel,
+					entries,
+					cfg.defaultThinking,
+					thinkingArg ? toAgyEffort(thinkingArg as ThinkingLevel, AGY_EFFORT_ORDER) : undefined,
+				) ?? { model: requestedModel };
 			const thinking: ThinkingTier = resolved.effort ?? cfg.defaultThinking;
 			const mode: AgyMode = (args.mode as AgyMode | undefined) ?? "accept-edits";
 			const useDigest = typeof args.digest === "boolean" ? args.digest : mode === "plan";
@@ -415,8 +443,27 @@ export async function registerAskAntigravityTool(
 					details: emptyDetails(requestedModel),
 				};
 			}
+			if (
+				typeof params.thinking === "string" &&
+				typeof params.effort === "string" &&
+				params.thinking !== params.effort
+			) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "thinking and effort are synonyms for the same knob - pass one, not both with different values.",
+						},
+					],
+					details: emptyDetails(requestedModel),
+				};
+			}
+			const thinkingArg = (params.thinking as string | undefined) ?? (params.effort as string | undefined);
+			const preferredTier = thinkingArg
+				? toAgyEffort(thinkingArg as ThinkingLevel, AGY_EFFORT_ORDER)
+				: undefined;
 			const resolved =
-				resolveModel(requestedModel, entries, config.defaultThinking) ?? {
+				resolveModel(requestedModel, entries, config.defaultThinking, preferredTier) ?? {
 					model: requestedModel,
 				};
 

package/src/config.ts

@@ -141,6 +141,26 @@ export interface AgyConfig {
 	 *  digest (per-turn) is not. Turn off for agy-native behavior (agy's own
 	 *  system prompt only). */
 	systemPrompt: boolean;
+	/** Overall cap on ONE agy turn in minutes, both engines. When it fires, the
+	 *  bridge kills the agy process mid-task ("ACP turn exceeded the Xm
+	 *  deadline" / "agy exceeded the Xm turn timeout"). The ACP server binary
+	 *  exposes no timeout flag of its own (--helpfull: debug/notices only), so
+	 *  this bridge cap is the only knob.
+	 *
+	 *  Default is TTY-aware: 0 (no cap) on an interactive pi - the user aborts
+	 *  with Esc and is the better backstop - and 20 on headless runs, where
+	 *  nobody can abort and one runaway turn blocks the drivers' serialized
+	 *  turn queue. Explicit values opt into the gate: 1..1440 valid, 0
+	 *  disables, anything else (garbage, negative, >1440) falls back to the
+	 *  TTY-aware default. The inactivity stall guard (5m silence) still bounds
+	 *  a hung server either way. Next-turn effect. Env AGY_TURN_TIMEOUT_MIN
+	 *  wins over the file. */
+	turnTimeoutMin: number;
+	/** Silence cap in minutes, both engines: no stream-json stdout / no ACP
+	 *  session/update for this long fails the turn as a stall. Default 5;
+	 *  0 disables the guard. Next-turn effect.
+	 *  Env AGY_INACTIVITY_TIMEOUT_MIN wins over the file. */
+	inactivityTimeoutMin: number;
 	/** Approval gate over agy NATIVE tool calls (create_file, run_command,
 	 *  ...). pi tools agy calls already pass through pi's gates via the G9
 	 *  round-trip; this covers the rest. Default auto (off until a
@@ -158,10 +178,34 @@ const DEFAULTS: AgyConfig = {
 	bridgeTools: "all",
 	digest: false,
 	systemPrompt: true,
+	turnTimeoutMin: 0, // placeholder: the real default is resolved per loadConfig call (defaultTurnTimeoutMin)
+	inactivityTimeoutMin: 5,
 	approvals: { gateMode: "auto", mode: "ask" },
 	acp: { bin: "", permissions: "auto", usageEstimate: "estimate" },
 };
 
+/** Hard ceiling for a free-typed turn cap: one day, in minutes. */
+export const MAX_TURN_CAP_MIN = 1440;
+
+/** TTY-aware default for the overall turn cap. An interactive user aborts
+ *  with Esc and is the better backstop; the wall clock only earns its keep
+ *  where nobody can abort (headless runs: one runaway turn also blocks the
+ *  drivers' serialized turn queue). */
+export function defaultTurnTimeoutMin(): number {
+	return process.stdout.isTTY || process.stdin.isTTY ? 0 : 20;
+}
+
+/** Explicit cap minutes: 0 keeps (disable), 1..MAX_TURN_CAP_MIN keeps;
+ *  garbage, negative, or out-of-range falls back to the caller's default.
+ *  Pass Number.NaN as the fallback to detect rejection via isNaN. */
+export function parseCapMinutes(raw: string | number | undefined, fallback: number): number {
+	if (raw === undefined || String(raw).trim() === "") return fallback;
+	const n = typeof raw === "number" ? raw : Number(String(raw).trim());
+	if (!Number.isFinite(n)) return fallback;
+	if (n === 0) return 0;
+	return n >= 1 && n <= MAX_TURN_CAP_MIN ? n : fallback;
+}
+
 /** Load config merged over defaults. Env vars override the file when set. */
 export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 	let file: Partial<AgyConfig> = {};
@@ -228,6 +272,16 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 		? ["1", "true", "on"].includes(envSys.toLowerCase())
 		: file.systemPrompt ?? DEFAULTS.systemPrompt;
 
+	// Turn caps, minutes. Env wins over the file (same pattern as mode).
+	const turnTimeoutMin = parseCapMinutes(
+		process.env.AGY_TURN_TIMEOUT_MIN ?? file.turnTimeoutMin,
+		defaultTurnTimeoutMin(),
+	);
+	const inactivityTimeoutMin = parseCapMinutes(
+		process.env.AGY_INACTIVITY_TIMEOUT_MIN ?? file.inactivityTimeoutMin,
+		DEFAULTS.inactivityTimeoutMin,
+	);
+
 	// Approval gate (docs/TODO.md 2.5). Unknown values fall back to "auto"
 	// so a typo can never silently force the gate on.
 	const gateRaw = (process.env.AGY_APPROVALS ?? file.approvals?.gateMode ?? DEFAULTS.approvals.gateMode).toLowerCase();
@@ -268,6 +322,8 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 		bridgeTools,
 		digest,
 		systemPrompt,
+		turnTimeoutMin,
+		inactivityTimeoutMin,
 		approvals: { gateMode, mode: gateAskMode },
 		patchCleanupNotified: file.patchCleanupNotified === true,
 	};

package/src/driver-types.ts

@@ -36,9 +36,9 @@ export interface DriverTurnRequest extends DriverProfile {
 	contextBlock?: { uri: string; text: string };
 	signal?: AbortSignal;
 	/** Overall turn cap in minutes (default 10). Fractional values are valid
-	 *  (tests use sub-minute caps). */
+	 *  (tests use sub-minute caps). 0 disables the cap. */
 	timeoutMin?: number;
-	/** Stdout-inactivity cap in minutes (default 5). */
+	/** Stdout-inactivity cap in minutes (default 5). 0 disables the cap. */
 	inactivityMin?: number;
 }
 

package/src/driver.ts

@@ -165,12 +165,15 @@ export class StreamDriver implements TurnDriver {
 		if (turn.parks > 0) turn.parks -= 1;
 		if (turn.parks === 0 && !turn.idleTimer) {
 			const idleMin = turn.request.inactivityMin ?? 5;
-			turn.idleTimer = setTimeout(() => {
-				if (turn.closed) return;
-				this.#log(`stall:${turn.id}`);
-				this.#killChild();
-				this.#failTurn(turn, `agy stalled for ${idleMin}m with no output`);
-			}, idleMin * 60_000);
+			// 0 disables the stall guard (config inactivityTimeoutMin: 0).
+			if (idleMin > 0) {
+				turn.idleTimer = setTimeout(() => {
+					if (turn.closed) return;
+					this.#log(`stall:${turn.id}`);
+					this.#killChild();
+					this.#failTurn(turn, `agy stalled for ${idleMin}m with no output`);
+				}, idleMin * 60_000);
+			}
 		}
 	}
 
@@ -295,20 +298,26 @@ export class StreamDriver implements TurnDriver {
 	}
 
 	#armTimers(turn: ActiveTurn): void {
+		// 0 disables a cap (config turnTimeoutMin / inactivityTimeoutMin: 0):
+		// setTimeout(fn, 0) would fire instantly and kill every turn.
 		const totalMin = turn.request.timeoutMin ?? 10;
-		turn.overallTimer = setTimeout(() => {
-			if (turn.closed) return;
-			this.#log(`timeout:${turn.id}`);
-			this.#killChild();
-			this.#failTurn(turn, `agy exceeded the ${totalMin}m turn timeout`);
-		}, totalMin * 60_000);
+		if (totalMin > 0) {
+			turn.overallTimer = setTimeout(() => {
+				if (turn.closed) return;
+				this.#log(`timeout:${turn.id}`);
+				this.#killChild();
+				this.#failTurn(turn, `agy exceeded the ${totalMin}m turn timeout`);
+			}, totalMin * 60_000);
+		}
 		const idleMin = turn.request.inactivityMin ?? 5;
-		turn.idleTimer = setTimeout(() => {
-			if (turn.closed) return;
-			this.#log(`stall:${turn.id}`);
-			this.#killChild();
-			this.#failTurn(turn, `agy stalled for ${idleMin}m with no output`);
-		}, idleMin * 60_000);
+		if (idleMin > 0) {
+			turn.idleTimer = setTimeout(() => {
+				if (turn.closed) return;
+				this.#log(`stall:${turn.id}`);
+				this.#killChild();
+				this.#failTurn(turn, `agy stalled for ${idleMin}m with no output`);
+			}, idleMin * 60_000);
+		}
 	}
 
 	#start(request: DriverTurnRequest): void {

package/src/models.ts

@@ -21,7 +21,7 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import type { Api, Model, ThinkingLevelMap } from "@earendil-works/pi-ai";
+import type { Api, Model, ThinkingLevel, ThinkingLevelMap } from "@earendil-works/pi-ai";
 
 const DISCOVERY_TIMEOUT_MS = 8_000;
 
@@ -31,6 +31,47 @@ export type AgyEffort = "low" | "medium" | "high";
 /** low < medium < high, for sorting/clamping. */
 const EFFORT_RANK: Record<AgyEffort, number> = { low: 0, medium: 1, high: 2 };
 
+/** pi thinking-effort order mirrors agy's, for clamping. */
+export const AGY_EFFORT_ORDER: readonly AgyEffort[] = ["low", "medium", "high"];
+
+/** Map pi's thinking level onto one of the tiers `efforts` the base actually
+ *  supports, clamping to the nearest available. agy rejects an effort tier a
+ *  base doesn't list (e.g. medium on Pro), so we never emit one. Shared by the
+ *  provider turns AND the AskAntigravity delegation tool (thinking/effort
+ *  params): one vocabulary, one clamp. When pi sends no level we fall to the
+ *  first available tier. */
+export function toAgyEffort(
+	reasoning: ThinkingLevel | undefined,
+	efforts: readonly AgyEffort[],
+): AgyEffort {
+	let candidate: AgyEffort;
+	switch (reasoning) {
+		case "minimal":
+		case "low":
+			candidate = "low";
+			break;
+		case "medium":
+			candidate = "medium";
+			break;
+		case "high":
+		case "xhigh":
+		case "max":
+			candidate = "high";
+			break;
+		default:
+			candidate = efforts[0] ?? "low";
+	}
+	if (efforts.includes(candidate)) return candidate;
+	const i = AGY_EFFORT_ORDER.indexOf(candidate);
+	for (let j = i; j < AGY_EFFORT_ORDER.length; j++) {
+		if (efforts.includes(AGY_EFFORT_ORDER[j])) return AGY_EFFORT_ORDER[j];
+	}
+	for (let j = i - 1; j >= 0; j--) {
+		if (efforts.includes(AGY_EFFORT_ORDER[j])) return AGY_EFFORT_ORDER[j];
+	}
+	return efforts[0] ?? "low";
+}
+
 /** Split an agy slug into (base, tier). tier is null when the slug has no
  *  -high/-medium/-low suffix (claude-sonnet-4-6, gpt-oss-120b-medium's "medium"
  *  IS its suffix here, claude-opus-4-6-thinking is not a tier). */

package/src/provider.ts

@@ -33,7 +33,7 @@ import type { Api } from "@earendil-works/pi-ai";
 import type { DriverActivity, TurnDriver, TurnHandle } from "./driver-types.js";
 import { toPiUsage } from "./stream-events.js";
 import { mapAgyToolToNative } from "./native-tools.js";
-import { type AgyEffort, type AgyModelEntry } from "./models.js";
+import { toAgyEffort, type AgyModelEntry } from "./models.js";
 import { SessionStore } from "./sessions.js";
 import { loadConfig } from "./config.js";
 import { GATE_MARKER, mapNativeToShadow, stripMarkerFields } from "./approval-gate.js";
@@ -338,46 +338,6 @@ export interface StreamSimpleDeps {
 	log?: (event: string, data?: unknown, level?: "debug" | "info" | "warn" | "error") => void;
 }
 
-/** pi thinking-effort order mirrors agy's, for clamping. */
-const AGY_EFFORT_ORDER: readonly AgyEffort[] = ["low", "medium", "high"];
-
-/** Map pi's thinking level onto one of the tiers `efforts` the base actually
- *  supports, clamping to the nearest available. agy rejects an effort tier a
- *  base doesn't list (e.g. medium on Pro), so we never emit one. A base slug is
- *  invalid without --effort, so when pi sends no level we default to the
- *  middle tier (or the highest available). */
-export function toAgyEffort(
-	reasoning: ThinkingLevel | undefined,
-	efforts: readonly AgyEffort[],
-): AgyEffort {
-	let candidate: AgyEffort;
-	switch (reasoning) {
-		case "minimal":
-		case "low":
-			candidate = "low";
-			break;
-		case "medium":
-			candidate = "medium";
-			break;
-		case "high":
-		case "xhigh":
-		case "max":
-			candidate = "high";
-			break;
-		default:
-			candidate = efforts[0] ?? "low";
-	}
-	if (efforts.includes(candidate)) return candidate;
-	const i = AGY_EFFORT_ORDER.indexOf(candidate);
-	for (let j = i; j < AGY_EFFORT_ORDER.length; j++) {
-		if (efforts.includes(AGY_EFFORT_ORDER[j])) return AGY_EFFORT_ORDER[j];
-	}
-	for (let j = i - 1; j >= 0; j--) {
-		if (efforts.includes(AGY_EFFORT_ORDER[j])) return AGY_EFFORT_ORDER[j];
-	}
-	return efforts[0] ?? "low";
-}
-
 // --- G9: no-patch pi-tool round-trips -----------------------------------------
 //
 // The MCP bridge's onToolCall parks the call here instead of executing it:
@@ -1231,6 +1191,8 @@ async function runTurnDriver(
 				effort,
 				mode: config.mode,
 				skipPermissions: config.skipPermissions,
+				timeoutMin: config.turnTimeoutMin,
+				inactivityMin: config.inactivityTimeoutMin,
 				conversationId: existing?.conversationId ?? null,
 				prompt: fullPrompt,
 				images: images.length > 0 ? images : undefined,