@estebanforge/pi-antigravity-bridge 1.7.3 → 1.7.5

package/src/driver.ts

@@ -7,7 +7,7 @@
 //
 // Recycle semantics: the child is killed and respawned when the next turn's
 // process profile (model / effort / mode / cwd / conversation) drifts from the
-// running one, mirroring tianzuo/pi-antigravity's driver. Stats and a bounded
+// running one. Stats and a bounded
 // lifecycle log feed /agy doctor.
 //
 // The driver never talks to the MCP bridge directly: the provider owns the
@@ -20,6 +20,7 @@ import { parseAgyLine } from "./stream-events.js";
 import { isKnownNoiseLine, MAX_FRAME_BYTES, stripGluedNoise } from "./frame-guard.js";
 import { bridgeMcpConfigDir, bridgeMcpConfigExists } from "./mcp-server.js";
 import { gateHooksStaged } from "./approval-hook.js";
+import { parkedTurnAnswer } from "./parked-turn.js";
 import { redactText } from "./redact.js";
 import type {
 	AgyUsage,
@@ -62,6 +63,9 @@ interface ActiveTurn {
 	response: string;
 	usage?: AgyUsage;
 	conversationId?: string;
+	/** Wall clock at turn creation; the parked-turn probe filters
+	 *  transcript steps to those written after this. */
+	startedAt: number;
 	sawResult: boolean;
 	/** Text-dedupe guard state (delta vs cumulative response_text). */
 	cumulativeText: boolean | undefined;
@@ -71,6 +75,15 @@ interface ActiveTurn {
 	parks: number;
 }
 
+/** The skip-permissions flag actually passed to agy. Plan mode never
+ *  carries it: the flag auto-approves every permission request including
+ *  plan mode's own approval gate, silently turning review-only into full
+ *  write access. #start (argv + profile) and #recycleCause (comparison)
+ *  must both go through this, or plan turns recycle on every turn. */
+function effectiveSkipPermissions(mode: DriverTurnRequest["mode"], skipPermissions: boolean): boolean {
+	return mode !== "plan" && skipPermissions;
+}
+
 function emit(turn: ActiveTurn, activity: DriverActivity): void {
 	if (turn.closed) return;
 	if (turn.wake.length > 0) turn.wake.shift()!();
@@ -171,10 +184,7 @@ export class StreamDriver implements TurnDriver {
 			// 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`);
+					void this.#turnDeadlineGuard(turn, "stall", `agy stalled for ${idleMin}m with no output`);
 				}, idleMin * 60_000);
 			}
 		}
@@ -279,6 +289,7 @@ export class StreamDriver implements TurnDriver {
 			sawResult: false,
 			cumulativeText: undefined,
 			parks: 0,
+			startedAt: Date.now(),
 		};
 		if (request.signal) {
 			turn.onAbort = () => {
@@ -306,19 +317,13 @@ export class StreamDriver implements TurnDriver {
 		const totalMin = turn.request.timeoutMin ?? 10;
 		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`);
+				void this.#turnDeadlineGuard(turn, "timeout", `agy exceeded the ${totalMin}m turn timeout`);
 			}, totalMin * 60_000);
 		}
 		const idleMin = turn.request.inactivityMin ?? 5;
 		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`);
+				void this.#turnDeadlineGuard(turn, "stall", `agy stalled for ${idleMin}m with no output`);
 			}, idleMin * 60_000);
 		}
 	}
@@ -327,12 +332,21 @@ export class StreamDriver implements TurnDriver {
 		this.#state = "starting";
 		this.#generation += 1;
 		const generation = this.#generation;
+		// Plan mode never carries the skip flag: the flag auto-approves ALL
+		// permission requests including plan mode's own approval gate, which
+		// would silently turn "review-only" into full write access (probed
+		// 2026-09-25: with the flag a plan session wrote files; without it,
+		// file and command attempts end exit 0 in ~20-30s with a "confirm
+		// plan" message). The profile stores the EFFECTIVE value so the
+		// recycle comparison stays consistent with the argv.
+		const skipPermissions = effectiveSkipPermissions(request.mode, request.skipPermissions);
 		this.#profile = {
 			cwd: request.cwd,
 			model: request.model,
 			effort: request.effort,
 			mode: request.mode,
-			skipPermissions: request.skipPermissions,
+			skipPermissions,
+			agent: request.agent,
 		};
 		this.#boundConversation = request.conversationId ?? undefined;
 		this.#stderrTail = "";
@@ -346,7 +360,8 @@ export class StreamDriver implements TurnDriver {
 		args.push("--model", request.model);
 		if (request.effort) args.push("--effort", request.effort);
 		args.push("--mode", request.mode);
-		if (request.skipPermissions) args.push("--dangerously-skip-permissions");
+		if (request.agent) args.push("--agent", request.agent);
+		if (skipPermissions) args.push("--dangerously-skip-permissions");
 		if (request.conversationId) args.push("--conversation", request.conversationId);
 		args.push(
 			"--input-format",
@@ -607,6 +622,40 @@ export class StreamDriver implements TurnDriver {
 		}
 	}
 
+	/** Stall / total-timeout guard shared by both timer sites. Kills the
+	 *  child FIRST (bumping the generation so a racing exit handler cannot
+	 *  settle the turn ERROR mid-probe), then probes the conversation's
+	 *  brain transcript for a clean final-response step written during the
+	 *  turn (parked turn: agy finished its answer but never streamed it).
+	 *  One found, the turn settles OK with the withheld answer instead of
+	 *  discarding finished work; either way the next turn respawns into a
+	 *  known state. */
+	async #turnDeadlineGuard(turn: ActiveTurn, label: string, message: string): Promise<void> {
+		if (turn.closed) return;
+		this.#log(`${label}:${turn.id}`);
+		this.#killChild();
+		let parked: string | undefined;
+		try {
+			parked = turn.conversationId
+				? await parkedTurnAnswer(turn.conversationId, turn.startedAt)
+				: undefined;
+		} catch {
+			parked = undefined; // the guard must never throw
+		}
+		if (parked !== undefined) {
+			this.#settle(turn, {
+				conversationId: turn.conversationId,
+				status: "OK",
+				response: parked,
+				usage: turn.usage,
+				finished: true,
+				aborted: false,
+			});
+			return;
+		}
+		this.#failTurn(turn, message);
+	}
+
 	#failTurn(turn: ActiveTurn, message: string): void {
 		this.#settle(turn, {
 			conversationId: turn.conversationId,
@@ -626,7 +675,10 @@ export class StreamDriver implements TurnDriver {
 		if (cur.model !== next.model) return "model";
 		if (cur.effort !== next.effort) return "effort";
 		if (cur.mode !== next.mode) return "mode";
-		if (cur.skipPermissions !== next.skipPermissions) return "permissions";
+		if (cur.skipPermissions !== effectiveSkipPermissions(next.mode, next.skipPermissions)) {
+			return "permissions";
+		}
+		if (cur.agent !== next.agent) return "agent";
 		if (!next.conversationId) return this.#boundConversation ? "conversation-reset" : undefined;
 		return next.conversationId === this.#boundConversation ? undefined : "conversation";
 	}

package/src/models.ts

@@ -25,6 +25,14 @@ import type { Api, Model, ThinkingLevel, ThinkingLevelMap } from "@earendil-work
 
 const DISCOVERY_TIMEOUT_MS = 8_000;
 
+/** Stdout ceiling for `agy models`. Real output is a few KB of ASCII slugs;
+ *  anything past 1 MiB is a runaway process. Fail closed to "" so the
+ *  fallback catalog engages instead of letting the buffer grow without
+ *  limit. The check counts decoded string length (UTF-16 code units), not
+ *  raw bytes — a deliberate proxy, since the margin between a few KB of
+ *  real output and 1 MiB dwarfs any encoding difference. */
+export const MODELS_OUTPUT_CAP_BYTES = 1024 * 1024;
+
 /** Reasoning-effort tiers agy accepts via --effort. */
 export type AgyEffort = "low" | "medium" | "high";
 
@@ -104,28 +112,50 @@ export interface AgyModelEntry {
 	efforts?: AgyEffort[];
 }
 
-/** Spawn `agy models` and return its raw stdout text. Returns "" on any
- *  failure (non-zero exit, spawn error, or watchdog timeout). Bounded by
- *  DISCOVERY_TIMEOUT_MS so a hung agy (auth prompt, network stall) can't
- *  block extension load. Shared by the provider and the tool catalog so the
- *  extension spawns `agy models` ONCE per load. */
-export async function spawnAgyModelsRaw(binary: string): Promise<string> {
+/** Spawn a read-only agy listing subcommand and return its raw stdout text.
+ *  Returns "" on any failure (non-zero exit, spawn error, watchdog timeout,
+ *  or output cap). Bounded by timeoutMs (default DISCOVERY_TIMEOUT_MS) so a
+ *  hung agy (auth prompt, network stall) can't block the caller, and by
+ *  capBytes (default MODELS_OUTPUT_CAP_BYTES) so a runaway agy can't grow
+ *  the buffer without limit. Shared by the model catalog (spawned ONCE per
+ *  load, provider + tool catalog), the agent roster, and the quota fetch
+ *  (which passes its own 30s budget: /usage answers in ~10s live). */
+export async function spawnAgyRaw(
+	binary: string,
+	args: string[],
+	timeoutMs: number = DISCOVERY_TIMEOUT_MS,
+	capBytes: number = MODELS_OUTPUT_CAP_BYTES,
+): Promise<string> {
 	try {
 		return await new Promise<string>((resolve, reject) => {
-			const proc = spawn(binary, ["models"], {
+			const proc = spawn(binary, args, {
 				stdio: ["ignore", "pipe", "ignore"],
 				shell: false,
 			});
 			proc.stdout?.setEncoding("utf8");
 			let out = "";
 			let done = false;
+			let capped = false;
 			const finish = (v: string) => {
 				if (done) return;
 				done = true;
 				clearTimeout(watchdog);
 				resolve(v);
 			};
-			proc.stdout?.on("data", (d: string) => (out += d));
+			proc.stdout?.on("data", (d: string) => {
+				if (capped) return;
+				if (out.length + d.length > capBytes) {
+					capped = true;
+					try {
+						proc.kill("SIGKILL");
+					} catch {
+						/* already gone */
+					}
+					finish("");
+					return;
+				}
+				out += d;
+			});
 			proc.on("error", (err) => {
 				clearTimeout(watchdog);
 				reject(err);
@@ -138,13 +168,18 @@ export async function spawnAgyModelsRaw(binary: string): Promise<string> {
 					/* already gone */
 				}
 				finish("");
-			}, DISCOVERY_TIMEOUT_MS);
+			}, timeoutMs);
 		});
 	} catch {
 		return "";
 	}
 }
 
+/** Spawn `agy models`: the model catalog listing. */
+export async function spawnAgyModelsRaw(binary: string): Promise<string> {
+	return spawnAgyRaw(binary, ["models"]);
+}
+
 // --- catalog cache ----------------------------------------------------------
 //
 // `agy models` can take seconds (OAuth refresh, cold start) and its output

package/src/native-tools.ts

@@ -5,7 +5,7 @@
 //
 // Mutating tools (commands, edits, writes) and agy-specialty tools are never
 // re-executed - they replay through the display-only `antigravity` wrapper
-// tool. Ported from tianzuo/pi-antigravity lib/native-tools.ts (MIT).
+// tool.
 
 export interface NativeToolCall {
 	/** pi builtin tool name (`read`, `ls`, `grep`, `find`). */

package/src/parked-turn.ts

@@ -0,0 +1,125 @@
+// Parked-turn stall probe (stream-json engine only).
+//
+// The stall guard fails a turn after N minutes of stdout silence. But agy
+// sometimes finishes its answer without streaming it (parked turn): the
+// response only ever lands in the conversation's brain transcript. Before
+// failing, this module reads the transcript tail and looks for a DONE,
+// MODEL-sourced final-response step written DURING the turn. One found, the
+// driver can settle the turn OK with the withheld answer instead of
+// throwing away finished work.
+//
+// Live-verified format (agy 1.2.10, transcript_full.jsonl last line):
+//   {"step_index":1,"source":"MODEL","type":"PLANNER_RESPONSE",
+//    "status":"DONE","created_at":"2026-09-08T16:11:43Z","content":"..."}
+// A corpus sweep (2026-09-24, 9205 response steps across all local
+// transcripts) shows PLANNER_RESPONSE is the only *RESPONSE type agy
+// writes, so the gate matches it exactly. A deeper sweep during the agy
+// peer review (2026-09-25, 9547 steps) found 96.6% of PLANNER_RESPONSE
+// steps carry tool_calls — they are intermediate plan-and-act steps whose
+// content is status text ("Running test..."), NOT answers. The probe
+// therefore requires the NEWEST step written during the turn to be a
+// clean, tool-free response; any other newer step means the turn was
+// still mid-flight. If a future agy renames the type, the probe degrades
+// to the old stall-fail — the safe direction.
+// The ACP engine writes no transcript under its brain tree (probed
+// 2026-09-24) and reports turn completion itself, so this probe is
+// deliberately stream-json-only.
+
+import { open } from "node:fs/promises";
+import { agyConversationDir } from "./agy-paths.js";
+
+/** How much of the transcript tail to read. One final step is a few KiB;
+ *  512KiB covers it plus slack for big tool-step lines above it. */
+export const PARKED_PROBE_MAX_BYTES = 512 * 1024;
+
+/** Clock tolerance for "written during the turn": transcript timestamps are
+ *  second-precision and may come from a slightly skewed source. */
+const CREATED_AT_TOLERANCE_MS = 2_000;
+
+/** Pull the parked answer out of a transcript tail. Scans from the END;
+ *  the FIRST step written during the turn decides: a clean, tool-free DONE
+ *  MODEL response yields its content; any other step from the turn (tool
+ *  output, error, plan step with tool_calls) means no answer landed and
+ *  the probe returns undefined. Steps older than the turn (clock tolerance
+ *  2s) end the scan. Malformed or foreign lines are skipped without
+ *  deciding. Pure; exported for tests. */
+export function extractParkedAnswer(
+	tail: string,
+	turnStartedMs: number,
+): string | undefined {
+	const lines = tail.split("\n");
+	for (let i = lines.length - 1; i >= 0; i -= 1) {
+		const line = lines[i]?.trim();
+		if (!line) continue;
+		let step: {
+			source?: unknown;
+			type?: unknown;
+			status?: unknown;
+			created_at?: unknown;
+			content?: unknown;
+			tool_calls?: unknown;
+		};
+		try {
+			step = JSON.parse(line) as typeof step;
+		} catch {
+			continue;
+		}
+		if (typeof step.created_at !== "string") continue;
+		const createdAtMs = Date.parse(step.created_at);
+		if (Number.isNaN(createdAtMs)) continue;
+		if (createdAtMs < turnStartedMs - CREATED_AT_TOLERANCE_MS) break;
+
+		// The newest step written during this turn must be a completed MODEL
+		// response without tool calls. Intermediate tool steps, errors, or
+		// non-terminal responses mean the turn did not finish with a parked answer.
+		if (step.source !== "MODEL" || step.status !== "DONE") return undefined;
+		if (step.type !== "PLANNER_RESPONSE") return undefined;
+		if (Array.isArray(step.tool_calls) && step.tool_calls.length > 0) return undefined;
+		if (typeof step.content !== "string" || step.content.length === 0) return undefined;
+		return step.content;
+	}
+	return undefined;
+}
+
+/** Read at most `maxBytes` from the end of a file. Empty string on any
+ *  error (missing file, permission, ...) — the caller degrades to the old
+ *  stall-fail behavior. */
+export async function readTranscriptTail(filePath: string, maxBytes: number): Promise<string> {
+	let handle;
+	try {
+		handle = await open(filePath, "r");
+	} catch {
+		return "";
+	}
+	try {
+		const { size } = await handle.stat();
+		const start = Math.max(0, size - maxBytes);
+		const length = size - start;
+		const buffer = Buffer.alloc(length);
+		let read = 0;
+		while (read < length) {
+			const { bytesRead } = await handle.read(buffer, read, length - read, start + read);
+			if (bytesRead === 0) break;
+			read += bytesRead;
+		}
+		return buffer.subarray(0, read).toString("utf8");
+	} catch {
+		return "";
+	} finally {
+		await handle.close().catch(() => {});
+	}
+}
+
+/** Probe one stream-json conversation's transcript for a parked answer.
+ *  Undefined whenever nothing usable is found (missing transcript, no DONE
+ *  step from this turn) — never throws; the stall guard must not fail. */
+export async function parkedTurnAnswer(
+	conversationId: string,
+	turnStartedMs: number,
+	home: string | undefined = undefined,
+): Promise<string | undefined> {
+	const transcript = `${agyConversationDir("stream-json", conversationId, home)}/.system_generated/logs/transcript_full.jsonl`;
+	const tail = await readTranscriptTail(transcript, PARKED_PROBE_MAX_BYTES);
+	if (tail === "") return undefined;
+	return extractParkedAnswer(tail, turnStartedMs);
+}

package/src/provider.ts

@@ -33,6 +33,7 @@ import {
 import fs from "node:fs";
 import type { Api } from "@earendil-works/pi-ai";
 import type { DriverActivity, TurnDriver, TurnHandle } from "./driver-types.js";
+import { SubagentRoster } from "./subagent-roster.js";
 import { toPiUsage } from "./stream-events.js";
 import { mapAgyToolToNative } from "./native-tools.js";
 import { toAgyEffort, type AgyModelEntry } from "./models.js";
@@ -349,6 +350,8 @@ export interface StreamSimpleDeps {
 	/** Output-only ACP tool events; persisted as TUI entries, never sent to
 	 *  Antigravity or dispatched through Pi's executable tools. */
 	onNativeEvent?: (event: NativeDisplayEvent) => void;
+	/** Subagent roster (both engines); folded from every activity. */
+	roster?: SubagentRoster;
 	/** Daily file log sink (src/daily-log.ts). Records pre-dispatch turn
 	 *  errors that never create a driver turn (and so never reach onTurnEnd). */
 	log?: (event: string, data?: unknown, level?: "debug" | "info" | "warn" | "error") => void;
@@ -916,6 +919,8 @@ export interface DriverDeps {
 	replay?: WrapperReplay;
 	nativeActive?: (name: string) => boolean;
 	onNativeEvent?: (event: NativeDisplayEvent) => void;
+	/** Subagent roster fold target (both engines; best-effort telemetry). */
+	roster?: SubagentRoster;
 	/** Active engine (config), for engine-scoped session keys. */
 	engine: "stream-json" | "acp";
 	/** Daily file log sink for pre-dispatch errors (see StreamSimpleDeps). */
@@ -930,6 +935,7 @@ export interface ActivityFeatures {
 	roundTrips?: ToolRoundTrips;
 	engine?: "stream-json" | "acp";
 	onNativeEvent?: (event: NativeDisplayEvent) => void;
+	roster?: SubagentRoster;
 }
 
 /** Process-wide counter: round-trip ids must never repeat across turns in
@@ -976,6 +982,10 @@ export function consumeActivity(
 	feats: ActivityFeatures,
 ): "parked" | "continue" {
 	const partial = blocks.partial;
+	// Subagent roster folds BEFORE any rendering branch: pure in-memory
+	// telemetry over the same activities both engines emit, and it must see
+	// spawn/message/manage steps regardless of how they render.
+	feats.roster?.fold(activity);
 	switch (activity.type) {
 		case "text":
 			appendText(stream, blocks, activity.delta);
@@ -1232,6 +1242,7 @@ async function runTurnDriver(
 				effort,
 				mode: config.mode,
 				skipPermissions: config.skipPermissions,
+				agent: config.agent,
 				timeoutMin: config.turnTimeoutMin,
 				inactivityMin: config.inactivityTimeoutMin,
 				conversationId: existing?.conversationId ?? null,
@@ -1261,6 +1272,7 @@ async function runTurnDriver(
 		roundTrips: deps.roundTrips,
 		engine: deps.engine,
 		onNativeEvent: deps.onNativeEvent,
+		roster: deps.roster,
 	};
 
 	for (;;) {
@@ -1285,7 +1297,7 @@ async function runTurnDriver(
 		finalize(stream, blocks, "error", outcome.error ?? "agy turn failed");
 		return;
 	}
-	if (blocks.textIdx === null && blocks.thinkingIdx === null && outcome.response) {
+	if (blocks.textIdx === null && outcome.response) {
 		appendText(stream, blocks, outcome.response);
 	}
 	if (blocks.textIdx === null && blocks.thinkingIdx === null) {
@@ -1328,6 +1340,7 @@ export function createStreamSimple(
 				replay: deps.replay,
 				nativeActive: deps.nativeActive,
 				onNativeEvent: deps.onNativeEvent,
+				roster: deps.roster,
 				// Record the engine of the driver that will ACTUALLY run: if the
 				// ACP driver is absent, the config switch falls back to stream,
 				// and keying the session as @acp would store a stream

package/src/skills.ts

@@ -5,7 +5,6 @@
 // can tell when a skill applies. Calling it returns the full SKILL.md plus the
 // bundled resource dir. Nothing is appended to the prompt: agy sees the
 // catalog in tools/list on every spawn, including after pi compaction.
-// Shape borrowed from tianzuo/pi-antigravity lib/skills.ts (MIT).
 
 import fs from "node:fs";
 import os from "node:os";

package/src/stream-events.ts

@@ -3,8 +3,7 @@
 // `agy --input-format stream-json --output-format stream-json` emits one JSON
 // object per line on stdout: `init` (conversation binding), `step_update`
 // (user_input / agent_response / checkpoint / tool steps), `result` (terminal).
-// Shapes captured from live output and cross-checked against
-// tianzuo/pi-antigravity lib/events.ts (MIT). Unknown event kinds parse as
+// Shapes captured from live output. Unknown event kinds parse as
 // {kind:"unknown"} so a future agy release degrades instead of crashing the
 // reader loop.