@estebanforge/pi-antigravity-bridge 1.5.2 → 1.6.0

package/CHANGELOG.md

@@ -2,7 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
-## [1.5.2] - 2026-09-15
+## [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
+
+- **Parallel agy tool approvals no longer clobber each other.** The shadow-tool `GatePolicy` asked through pi's `ui.confirm`, but pi's TUI shows ONE extension dialog at a time and an overlapping call replaces the live dialog without settling it: with several agy bash/write/edit calls in flight, approvals were silently lost (the park timeout eventually resolved them as declines). The confirm now holds the same shared cross-extension dialog lock as the pi-*-me gates (`withDialogLock`, `Symbol.for("pi-me.dialog-lock")`), so approvals queue and render in turn; the park timeout still bounds each dialog and is held inside the lock. New `src/dialog-lock.ts` module plus contract tests (FIFO order, throw-release, shared key).
+
+## [1.5.2] - 2026-09-09
 
 ### 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";
@@ -88,6 +88,7 @@ import {
 import { mapAgyToolToNative } from "../src/native-tools.js";
 import { Type } from "typebox";
 import { patchStatus, restorePatch } from "../src/patch-cleanup.js";
+import { withDialogLock } from "../src/dialog-lock.js";
 
 // Last UI seen (session_start / /agy commands). The ACP login URL arrives
 // via the driver log sink, which has no command context; the stash lets that
@@ -808,7 +809,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 								: typeof params.path === "string"
 									? params.path
 									: JSON.stringify(stripMarkerFields(params)).slice(0, 200);
-						const ok = await extCtx.ui.confirm(`agy ${tool}?`, what, { timeout: APPROVAL_PARK_MS });
+						// Dialog lock: parallel agy tool approvals queue up instead of
+						// clobbering the live dialog (which silently loses the approval).
+						// Capture the narrowed method: TS drops the guard's narrowing
+						// inside the deferred closure.
+						const uiConfirm = extCtx.ui.confirm.bind(extCtx.ui);
+						const ok = await withDialogLock(() =>
+							uiConfirm(`agy ${tool}?`, what, { timeout: APPROVAL_PARK_MS }),
+						);
 						return ok ? { allow: true } : { allow: false, reason: `declined in pi (agy ${tool})` };
 					};
 					const handle = r.handle;
@@ -897,6 +905,7 @@ interface PendingConfig {
 	skipPermissions?: boolean;
 	defaultModel?: string;
 	defaultThinking?: ThinkingTier;
+	turnTimeoutMin?: number;
 	askTool?: boolean;
 	bridgeTools?: BridgeTools;
 	digest?: boolean;
@@ -933,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;
@@ -968,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") {
@@ -1346,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",
@@ -1386,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") {
@@ -1433,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.2",
+  "version": "1.6.0",
   "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/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/dialog-lock.ts

@@ -0,0 +1,48 @@
+// Process-wide FIFO lock for human-facing dialogs (confirm/editor/select).
+//
+// pi's interactive UI shows ONE extension dialog at a time; an overlapping
+// ctx.ui.* dialog call REPLACES the live dialog and the replaced promise
+// never settles, so parallel gated tool calls hang forever (or silently lose
+// their prompt). Holding this lock around each dialog serializes them: the
+// first renders, the rest appear in turn as each is answered.
+//
+// The lock is keyed via Symbol.for because ALL pi-* extensions run in the
+// SAME pi process and must share one queue: a per-module lock would still let
+// a dialog from one extension clobber a dialog from another in the same
+// parallel tool-call batch.
+const DIALOG_LOCK: unique symbol = Symbol.for("pi-me.dialog-lock");
+
+interface DialogQueue {
+  tail: Promise<void>;
+}
+
+function dialogQueue(): DialogQueue {
+  const host = globalThis as typeof globalThis & Record<symbol, unknown>;
+  const existing = host[DIALOG_LOCK] as DialogQueue | undefined;
+  if (existing) return existing;
+  const created: DialogQueue = { tail: Promise.resolve() };
+  host[DIALOG_LOCK] = created;
+  return created;
+}
+
+/**
+ * Run `run` while holding the cross-extension dialog lock. FIFO: each caller
+ * chains onto the queue tail synchronously (before its first await), so call
+ * order is the order the dialogs appear. Released in a finally block, so one
+ * throwing dialog can never wedge the queue for the callers behind it.
+ * NOT reentrant: calling it inside a held `run` self-deadlocks.
+ */
+export async function withDialogLock<T>(run: () => Promise<T>): Promise<T> {
+  const queue = dialogQueue();
+  const prev = queue.tail;
+  let release!: () => void;
+  queue.tail = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  await prev;
+  try {
+    return await run();
+  } finally {
+    release();
+  }
+}

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/provider.ts

@@ -1231,6 +1231,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,