@estebanforge/pi-antigravity-bridge 1.7.7 → 1.7.9

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.7.9] - 2026-10-06
+
+### Changed
+
+- **Breaking: Claude models are effort-tiered now, and the ids moved to the Claude 5.5 family.** Google retired Claude 4.6 on Antigravity and ships Claude Opus 5.5 (2026-09-22) and Claude Sonnet 5.5 (2026-09-28) in its place, each with low/medium/high thinking tiers - the same shape Gemini already had. Claude joins the verified effort-capable families (probed live 2026-10: base slug + `--effort` accepted; a bare base is rejected with "requires --effort"), so `claude-opus-5-5` and `claude-sonnet-5-5` register as single toggleable models whose turns always send `--effort`, instead of per-tier fixed ids. The catalog fixtures mirror the live listing and the no-`agy models` fallback carries its head (3.8 flash, 3.1 pro, sonnet 5.5). A pattern pinned to `antigravity/claude-sonnet-4-6` (settings enabledModels, `--model`, or a scoped-model config) matches nothing after agy's upgrade and must move to `antigravity/claude-sonnet-5-5`; the bare base id itself resolves through the delegation tool to the nearest tier variant.
+- **The `gpt-oss-120b-medium` family is dropped now, not next month.** Upstream announced its removal; nobody used the fixed-thinking single slug and it loses to the cheaper effort-tiered options, so the provider catalog and the delegation tool catalog both filter it before that date lands. The `gpt-oss` alias stops resolving: unrecognized input passes raw to agy and fails loudly there, instead of the tool offering a dying model.
+
+## [1.7.8] - 2026-09-30
+
+### Fixed
+
+- **The system prompt no longer rides the prompt line on stream-json.** Probed on agy 1.2.14: the CLI silently drops any single prompt past a ~25KB input cap. The drop reports SUCCESS with an empty response, zero usage, and no model step, and a conversation whose turn was dropped never answers again - resuming it hangs with no result frame. The G10 system-prompt block shipped inline on the first prompt of every fresh conversation by default and routinely crossed the cap, so provider sessions answered boilerplate while the user's message never ran (issue #2). The block now stages as an agy agent file under the agents discovery root and rides `--agent`: the CLI reads agent files from disk, so the cap never applies, and the prompt line carries only the user message. Staging is content-addressed - one dir per distinct body, write-once, pid-marked, orphan-swept - so two conversations in one process can never overwrite each other's carrier (the round-2 review blocked the original per-process slot for exactly that cross-contamination). A user-configured `config.agent` always wins, with the inline block as fallback and a one-time warning. ACP keeps the inline block: the JSON-RPC transport has no cap and no `--agent` slot.
+- **A dropped or dead turn now fails loudly instead of poisoning the session.** The stream-json driver settles every turn with model-output and result-frame evidence. An OK outcome with no model output - the exact signature of the silent over-cap drop - fails the turn with the cause and the remedy, and never stores the conversation binding; a deadline on a bound conversation with no result frame clears the binding so the next turn starts a fresh conversation instead of hanging forever on a dead one. Real terse turns (tool steps, thinking, any usage) are untouched; a deadline that recovered a withheld answer keeps settling OK.
+- **Regression coverage pins the whole failure chain at both layers.** The fake agy binary grew a SILENT-DROP branch reproducing the exact wire signature; driver tests pin the evidence fields; provider tests cover the drop, the poisoned resume, a deadline-with-result keeping its binding, terse-turn false positives, carrier isolation across interleaved conversations, and deadline-flavored error copy. 1343 tests, tsc clean; round-2 adversarial review signed off after the carrier-isolation blocker fix.
+
+Thanks @Jamsa for the report (#2).
+
 ## [1.7.7] - 2026-09-30
 
 ### Fixed

package/README.md

@@ -119,7 +119,7 @@ If `agy models` fails at load (binary missing, auth not done, network stall), a
 | `webTools` | `off` (no web tools), `on` (register `agy_web_search` + `agy_read_url` as Pi tools, usable by ANY provider's model). Each call spawns a one-shot search-only `agy` agent (plan mode, bridge MCP inheritance off), gates the answer on an observed native `search_web`/`read_url_content` step, and spends Antigravity quota. Off by default: Antigravity sessions already have native web tools on both engines; these serve other providers | `off` |
 | `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` |
+| `systemPrompt` | `on` (send 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. Delivery: stream-json stages it as an agy agent file via `--agent`, off the prompt line - the CLI silently drops single prompts past a ~25KB cap and the dropped turn kills the conversation; ACP prepends it to the first prompt) 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` |
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.7.7",
-  "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.",
+  "version": "1.7.9",
+  "description": "Gemini provider for Pi on the Antigravity ACP server (official Google ACP) or the stream-json agy CLI. Use antigravity/* models in Pi. Full /model picker support. Models runs Pi's tools. ToS safe to use.",
   "keywords": [
     "pi-package",
     "pi-extension",
@@ -46,7 +46,7 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "^1.0.0"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {

package/src/approval-gate.ts

@@ -25,7 +25,7 @@
 import type {
 	AgentToolResult,
 	AgentToolUpdateCallback,
-	ExtensionContext,
+	ExtensionToolContext,
 	ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 
@@ -151,7 +151,7 @@ export function createShadowTool(base: AnyToolDefinition, policy: GatePolicy, op
 		params: any,
 		signal: AbortSignal | undefined,
 		onUpdate: AgentToolUpdateCallback<any> | undefined,
-		ctx: ExtensionContext,
+		ctx: ExtensionToolContext,
 	): Promise<AgentToolResult<unknown>> => {
 		const p = (params ?? {}) as Record<string, unknown>;
 		if (p[GATE_MARKER] !== true) {

package/src/ask-tool.ts

@@ -56,16 +56,19 @@ const TIER_RANK: Record<ThinkingTier, number> = { low: 0, medium: 1, high: 2 };
 // Static alias overlay for non-Gemini models agy may or may not surface.
 // Live catalog entries win on case-insensitive full-string equality; the
 // overlay resolves the alias when agy doesn't list it. Names are agy's stable
-// slugs (the same ids `agy models` prints and `--model` accepts).
+// slugs (the same ids `agy models` prints and `--model` accepts). Claude ships
+// tiered like Gemini now, so the overlay carries the full tier spread.
 const STATIC_ALIAS_OVERLAY: ReadonlyArray<ModelEntry> = [
-	{ full: "claude-sonnet-4-6", family: "other", version: null, tier: null },
-	{ full: "claude-opus-4-6-thinking", family: "other", version: null, tier: null },
-	{ full: "gpt-oss-120b-medium", family: "other", version: null, tier: null },
+	{ full: "claude-sonnet-5-5-low", family: "other", version: null, tier: "low" },
+	{ full: "claude-sonnet-5-5-medium", family: "other", version: null, tier: "medium" },
+	{ full: "claude-sonnet-5-5-high", family: "other", version: null, tier: "high" },
+	{ full: "claude-opus-5-5-low", family: "other", version: null, tier: "low" },
+	{ full: "claude-opus-5-5-medium", family: "other", version: null, tier: "medium" },
+	{ full: "claude-opus-5-5-high", family: "other", version: null, tier: "high" },
 ];
 const STATIC_SHORT_ALIAS: ReadonlyMap<string, string> = new Map([
-	["sonnet", "claude-sonnet-4-6"],
-	["opus", "claude-opus-4-6-thinking"],
-	["gpt-oss", "gpt-oss-120b-medium"],
+	["sonnet", "claude-sonnet-5-5"],
+	["opus", "claude-opus-5-5"],
 ]);
 
 // agy conversation ids are UUID DB-stems. First char must be alphanumeric so a
@@ -164,19 +167,47 @@ function nearestTier(available: ThinkingTier[], preferred: ThinkingTier): Thinki
 	return sorted[0] ?? preferred;
 }
 
-/** Build the argv-facing resolution from a picked catalog entry. Gemini bases
- *  (slugs starting "gemini-") accept a separate --effort, so split the tier
- *  suffix out of the slug: the base alone (gemini-3.6-flash) is what --model
- *  wants, and the tier goes to --effort. Fixed-thinking families keep agy's
- *  exact slug even when it carries a -medium suffix (gpt-oss-120b-medium):
- *  agy rejects --effort for them, so the suffix stays part of the slug. */
+/** Build the argv-facing resolution from a picked catalog entry. Gemini and
+ *  Claude bases (slugs starting "gemini-"/"claude-") accept a separate
+ *  --effort, so split the tier suffix out of the slug: the base alone
+ *  (claude-sonnet-5-5) is what --model wants, and the tier goes to --effort
+ *  (agy rejects a bare base: "requires --effort"). Only unverified families
+ *  keep agy's exact slug whole, so an unknown suffix can never trigger an
+ *  unsupported --effort. */
 function toResolved(full: string, tier: ThinkingTier | null): ResolvedModel {
-	if (tier && full.toLowerCase().startsWith("gemini-")) {
+	if (tier && /^(gemini|claude)-/.test(full.toLowerCase())) {
 		return { model: full.replace(/-(low|medium|high)$/, ""), effort: tier };
 	}
 	return { model: full };
 }
 
+/** Resolve a tiered base id - a short-alias target ("claude-sonnet-5-5") or a
+ *  bare base slug the provider itself advertises - to the catalog variant
+ *  nearest the requested tier. A bare base alone is invalid upstream
+ *  ("requires --effort"), so the pick always rides the split in toResolved;
+ *  with no variants in the catalog, the overlay/exact entry or the raw base
+ *  passes through unchanged. */
+function resolveTieredBase(
+	base: string,
+	entries: ModelEntry[],
+	defaultThinking: ThinkingTier,
+	preferredTier: ThinkingTier | undefined,
+): ResolvedModel {
+	const needle = base.toLowerCase();
+	const variants = entries.filter((e) => e.full.toLowerCase().startsWith(`${needle}-`));
+	if (variants.length > 0) {
+		const tiers = variants.map((e) => e.tier).filter((t): t is ThinkingTier => t !== null);
+		const preferred =
+			preferredTier ??
+			(tiers.includes(defaultThinking) ? defaultThinking : FAMILY_DEFAULT_TIER.other);
+		const chosen = nearestTier(tiers, preferred);
+		const picked = variants.find((e) => e.tier === chosen) ?? variants[0];
+		return toResolved(picked.full, picked.tier);
+	}
+	const fromCatalog = entries.find((e) => e.full.toLowerCase() === needle);
+	return toResolved(fromCatalog?.full ?? base, fromCatalog?.tier ?? null);
+}
+
 /** Resolve a friendly alias / partial name to an argv-facing {model, effort?}.
  *  Returns null only when the family is unrecognized; the caller then passes
  *  the raw input straight to agy. */
@@ -195,9 +226,12 @@ export function resolveModel(
 	if (exact) return toResolved(exact.full, exact.tier);
 
 	if (STATIC_SHORT_ALIAS.has(lower)) {
-		const target = STATIC_SHORT_ALIAS.get(lower) as string;
-		const fromCatalog = entries.find((e) => e.full.toLowerCase() === target.toLowerCase());
-		return toResolved(fromCatalog?.full ?? target, fromCatalog?.tier ?? null);
+		return resolveTieredBase(
+			STATIC_SHORT_ALIAS.get(lower) as string,
+			entries,
+			defaultThinking,
+			preferredTier,
+		);
 	}
 
 	let family: Family | null = lower.includes("flash")
@@ -213,7 +247,19 @@ export function resolveModel(
 	if (!family && (/gemini/.test(lower) || lower === "" || lower === "default")) {
 		family = "flash";
 	}
-	if (!family) return null;
+	if (!family) {
+		// A bare base slug the provider itself advertises ("claude-sonnet-5-5",
+		// the id behind the antigravity/ entry in pi's picker) is invalid
+		// upstream without an effort: resolve it to the nearest tier variant
+		// exactly like the short aliases.
+		if (
+			entries.some((e) => e.full.toLowerCase().startsWith(`${lower}-`)) ||
+			entries.some((e) => e.full.toLowerCase() === lower)
+		) {
+			return resolveTieredBase(lower, entries, defaultThinking, preferredTier);
+		}
+		return null;
+	}
 
 	let candidates = entries.filter((e) => e.family === family);
 	if (candidates.length === 0) return null;
@@ -252,11 +298,18 @@ export function resolveModel(
 	return toResolved(picked.full, picked.tier);
 }
 
+/** Families dropped outright even while `agy models` still lists them (same
+ *  policy as models.ts HIDDEN_FAMILY_RE): never offered, never resolved. */
+const HIDDEN_FAMILY_RE = /^gpt-oss-/;
+
 /** Parse raw `agy models` text into tool-catalog entries (all families, plus
- *  the static sonnet/opus/gpt-oss overlay). Pure: no spawn. */
+ *  the static sonnet/opus overlay). Pure: no spawn. */
 export function toolModelsFromRaw(raw: string): ModelEntry[] {
 	return mergeCatalog(
-		raw.split("\n").map(parseModelLine).filter((e): e is ModelEntry => e !== null),
+		raw
+			.split("\n")
+			.map(parseModelLine)
+			.filter((e): e is ModelEntry => e !== null && !HIDDEN_FAMILY_RE.test(e.full)),
 	);
 }
 

package/src/driver-types.ts

@@ -90,6 +90,20 @@ export interface TurnOutcome {
 	usage?: AgyUsage;
 	finished: boolean;
 	aborted: boolean;
+	/** The model demonstrably produced output this turn: an agent_response
+	 *  or tool step was observed, or the settled response/usage is non-empty.
+	 *  Stream-json sets it on every outcome; ACP leaves it undefined.
+	 *  false + status OK is agy's silent over-cap drop signature (issue #2:
+	 *  prompts past ~25KB are discarded with SUCCESS, no error). */
+	modelOutputSeen?: boolean;
+	/** Stream-json only: a result frame arrived for this turn. Undefined on
+	 *  ACP. A deadline kill or process exit before the result frame means the
+	 *  turn never committed. */
+	sawResult?: boolean;
+	/** Stream-json only: the turn ended via the overall/inactivity deadline
+	 *  guard (not a user abort, not a process crash). With sawResult false on
+	 *  a resumed conversation this marks the conversation as poisoned. */
+	deadline?: "timeout" | "stall";
 }
 
 export interface TurnHandle {

package/src/driver.ts

@@ -67,6 +67,10 @@ interface ActiveTurn {
 	 *  transcript steps to those written after this. */
 	startedAt: number;
 	sawResult: boolean;
+	/** An agent_response or tool step arrived this turn. Distinguishes a
+	 *  real (if terse) turn from agy's silent over-cap drop, which settles
+	 *  SUCCESS with no model step at all (issue #2). */
+	sawModelStep: boolean;
 	/** Text-dedupe guard state (delta vs cumulative response_text). */
 	cumulativeText: boolean | undefined;
 	/** Open bridge parks. Each one suspends the stdout idle timer: agy is
@@ -120,6 +124,20 @@ function nowIso(): string {
 	return new Date().toISOString().slice(11, 19);
 }
 
+/** True when any usage counter carries a real value. The silent over-cap
+ *  drop reports all-zero usage (no model call happened); a turn that burned
+ *  any tokens demonstrably reached the model. */
+function hasTokenEvidence(usage: AgyUsage | undefined): boolean {
+	if (!usage) return false;
+	return (
+		(usage.input_tokens ?? 0) > 0 ||
+		(usage.output_tokens ?? 0) > 0 ||
+		(usage.thinking_tokens ?? 0) > 0 ||
+		(usage.cache_read_tokens ?? 0) > 0 ||
+		(usage.total_tokens ?? 0) > 0
+	);
+}
+
 /** True when `next` is a cumulative resend of `accumulated` (it repeats every
  *  byte already streamed) rather than a fresh delta. Exported for tests. */
 export function isCumulativeResend(accumulated: string, next: string): boolean {
@@ -287,6 +305,7 @@ export class StreamDriver implements TurnDriver {
 			outcome,
 			response: "",
 			sawResult: false,
+			sawModelStep: false,
 			cumulativeText: undefined,
 			parks: 0,
 			startedAt: Date.now(),
@@ -500,6 +519,7 @@ export class StreamDriver implements TurnDriver {
 					emit(turn, { type: "usage", usage: s.usage });
 				}
 				if (s.step_type === "agent_response") {
+					turn.sawModelStep = true;
 					const text =
 						typeof s.text_delta === "string"
 							? s.text_delta
@@ -513,6 +533,7 @@ export class StreamDriver implements TurnDriver {
 					break;
 				}
 				if (s.step_type === "tool") {
+					turn.sawModelStep = true;
 					const name = s.tool_name ?? s.tool_info?.name ?? "tool";
 					const args =
 						s.tool_info?.parameters && typeof s.tool_info.parameters === "object"
@@ -614,9 +635,22 @@ export class StreamDriver implements TurnDriver {
 		this.#state = this.#child ? "ready" : "dead";
 		for (const wake of turn.wake) wake();
 		turn.wake = [];
-		turn.resolve(outcome);
+		// Evidence fields every consumer can rely on. modelOutputSeen separates a
+		// real (if terse) turn from agy's silent over-cap drop, which settles
+		// SUCCESS with NO model step, empty response, and zero usage (issue #2).
+		const usage = outcome.usage ?? turn.usage;
+		const enriched: TurnOutcome = {
+			...outcome,
+			usage,
+			sawResult: turn.sawResult,
+			modelOutputSeen:
+				turn.sawModelStep ||
+				outcome.response.length > 0 ||
+				hasTokenEvidence(usage),
+		};
+		turn.resolve(enriched);
 		try {
-			this.#onTurnEnd?.(outcome);
+			this.#onTurnEnd?.(enriched);
 		} catch {
 			/* listener errors must not break settling */
 		}
@@ -630,7 +664,7 @@ export class StreamDriver implements TurnDriver {
 	 *  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> {
+	async #turnDeadlineGuard(turn: ActiveTurn, label: "timeout" | "stall", message: string): Promise<void> {
 		if (turn.closed) return;
 		this.#log(`${label}:${turn.id}`);
 		this.#killChild();
@@ -650,13 +684,14 @@ export class StreamDriver implements TurnDriver {
 				usage: turn.usage,
 				finished: true,
 				aborted: false,
+				deadline: label,
 			});
 			return;
 		}
-		this.#failTurn(turn, message);
+		this.#failTurn(turn, message, label);
 	}
 
-	#failTurn(turn: ActiveTurn, message: string): void {
+	#failTurn(turn: ActiveTurn, message: string, deadline?: "timeout" | "stall"): void {
 		this.#settle(turn, {
 			conversationId: turn.conversationId,
 			status: "ERROR",
@@ -665,6 +700,7 @@ export class StreamDriver implements TurnDriver {
 			usage: turn.usage,
 			finished: true,
 			aborted: false,
+			deadline,
 		});
 	}
 

package/src/models.ts

@@ -2,20 +2,21 @@
 // they appear in the /model picker as antigravity/<slug>.
 //
 // agy prints TWO columns per line: "<slug>  <display label>". --model takes
-// ONLY the slug (col 1); the label is display-only. Verified live, e.g.:
-//   gemini-3.6-flash-high     Gemini 3.6 Flash (High)
-//   gemini-3.6-flash-medium   Gemini 3.6 Flash (Medium)   (+ -low)
+// ONLY the slug (col 1); the label is display-only. Verified live 2026-10:
+//   gemini-3.8-flash-high     Gemini 3.8 Flash (High)
+//   gemini-3.8-flash-medium   Gemini 3.8 Flash (Medium)   (+ -low)
 //   gemini-3.1-pro-high       Gemini 3.1 Pro (High)        (Pro has NO medium)
-//   claude-sonnet-4-6         Claude Sonnet 4.6 (Thinking) (fixed, no tiers)
-//   gpt-oss-120b-medium       GPT-OSS 120B (Medium)        (fixed, no tiers)
+//   claude-sonnet-5-5-high    Claude Sonnet 5.5 (High)     (+ -medium, -low)
 //
-// Gemini models are collapsed to a BASE slug (gemini-3.6-flash) and exposed
-// with a thinking-effort toggle whose levels match exactly the tiers agy
-// offers that base (verified: Pro rejects medium). The picked level is sent as
-// agy --effort; a base slug is INVALID on its own, so effort is always passed.
-// Claude and GPT-OSS keep agy's exact slug with no toggle: their thinking is
-// fixed and agy rejects --effort for them. Google's Antigravity subscription
-// bills all of these through agy.
+// Gemini AND Claude models are collapsed to a BASE slug (gemini-3.8-flash,
+// claude-sonnet-5-5) and exposed with a thinking-effort toggle whose levels
+// match exactly the tiers agy offers that base (verified: Pro rejects medium;
+// Claude 5.5 accepts low/medium/high). The picked level is sent as agy
+// --effort; a bare base slug is INVALID on its own (agy: "requires --effort"),
+// so effort is always passed. Only unverified families keep agy's exact slug
+// with no toggle, so an unknown future family degrades safely; the retired
+// gpt-oss family is dropped outright (HIDDEN_FAMILY_RE). Google's Antigravity
+// subscription bills all of these through agy.
 
 import { spawn } from "node:child_process";
 import fs from "node:fs";
@@ -81,8 +82,9 @@ export function toAgyEffort(
 }
 
 /** 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). */
+ *  -high/-medium/-low suffix - a shape only unverified families should
+ *  produce now, and those stay whole. Every Claude slug carries a tier
+ *  suffix and collapses to its base. */
 const TIER_RE = /^(.+)-(high|medium|low)$/;
 
 /** agy emits clean slug ids (gemini-3.6-flash-high). Validate col1 of each
@@ -97,14 +99,21 @@ const MODEL_LINE_RE = /^[A-Za-z0-9][A-Za-z0-9._]*-[A-Za-z0-9._-]*$/;
  *  to a base slug with a thinking toggle. Any other family stays as agy's exact
  *  qualified slug (always valid on its own), so an unknown or fixed-thinking
  *  family degrades safely instead of forcing an unsupported --effort. Add a
- *  family here only after confirming base+--effort is accepted for it. */
-const EFFORT_CAPABLE_FAMILIES: readonly RegExp[] = [/^gemini-/];
+ *  family here only after confirming base+--effort is accepted for it.
+ *  Claude 5.5 verified live 2026-10: base+--effort accepted; a bare base is
+ *  rejected ("requires --effort"). */
+const EFFORT_CAPABLE_FAMILIES: readonly RegExp[] = [/^gemini-/, /^claude-/];
+
+/** Families dropped outright, even while `agy models` still lists them: the
+ *  fixed-thinking single slug loses to the cheaper effort-tiered options and
+ *  its removal upstream is already announced, so we stop offering it now. */
+const HIDDEN_FAMILY_RE = /^gpt-oss-/;
 
 export interface AgyModelEntry {
-	/** Exact agy --model string to pass: a base slug ("gemini-3.6-flash") when
-	 *  effort-driven, else agy's full qualified slug ("claude-opus-4-6-thinking"). */
+	/** Exact agy --model string to pass: a base slug ("gemini-3.8-flash") when
+	 *  effort-driven, else agy's full qualified slug (unverified family). */
 	full: string;
-	/** pi model id, e.g. "gemini-3-6-flash". */
+	/** pi model id, e.g. "gemini-3-8-flash". */
 	id: string;
 	/** Present iff this is an effort-driven base slug. Lists the tiers agy
 	 *  accepts for it; pi's thinking toggle picks among them and we always pass
@@ -284,11 +293,12 @@ export async function loadModelCatalogRaw(
 
 /** Parse raw `agy models` text into the provider's model entries.
  *
- *  Effort-driven Gemini bases (>= 2 tier variants in the catalog) collapse to
- *  one BASE-slug entry carrying the tiers they accept. Models with 0 or 1 tier
- *  variants keep agy's exact qualified slug: a single suffix (gpt-oss-120b-
- *  medium) or none (claude-sonnet-4-6) means fixed thinking, where --effort is
- *  unsupported. Insertion order of first-seen bases is preserved. */
+ *  Effort-driven bases (>= 2 tier variants in the catalog, verified
+ *  effort-capable family) collapse to one BASE-slug entry carrying the tiers
+ *  they accept. Models with 0 or 1 tier variants keep agy's exact qualified
+ *  slug: without a verified effort-capable family match, --effort is never
+ *  risked. Hidden families are dropped outright. Insertion order of
+ *  first-seen bases is preserved. */
 export function entriesFromRaw(raw: string): AgyModelEntry[] {
 	// agy prints TWO columns: "<slug>  <display label>". --model takes only the
 	// slug, so split col1 and validate THAT; the label is display-only. A
@@ -298,6 +308,7 @@ export function entriesFromRaw(raw: string): AgyModelEntry[] {
 	for (const line of raw.split("\n")) {
 		const slug = line.trim().split(/\s+/)[0] ?? "";
 		if (!slug || !MODEL_LINE_RE.test(slug)) continue;
+		if (HIDDEN_FAMILY_RE.test(slug)) continue;
 		const m = TIER_RE.exec(slug);
 		const base = m ? (m[1] as string) : slug;
 		const tier = m ? (m[2] as AgyEffort) : null;
@@ -365,8 +376,8 @@ export function toPiModel(entry: AgyModelEntry, input: Array<"text" | "image"> =
 		// sentinel that no built-in provider claims, so it can never collide.
 		baseUrl: "agy-bridge://antigravity",
 		// reasoning=true only for effort-driven bases => pi shows the toggle.
-		// Fixed models (Claude/GPT-OSS) get no toggle: their thinking can't be
-		// changed and agy rejects --effort for them.
+		// Unverified families get no toggle: --effort support is unknown, so
+		// none is ever sent.
 		reasoning: effortDriven,
 		...(effortDriven ? { thinkingLevelMap: thinkingLevelMapFor(entry.efforts!) } : {}),
 		// Input advertising comes from the caller (engine-dependent): the ACP
@@ -386,9 +397,9 @@ export function toPiModel(entry: AgyModelEntry, input: Array<"text" | "image"> =
  *  can still select a model and get a clear runtime error instead of an empty
  *  list. Update these when agy ships new Gemini versions. */
 export const FALLBACK_MODELS: AgyModelEntry[] = [
-	{ full: "gemini-3.7-flash", id: "gemini-3-7-flash", efforts: ["low", "medium", "high"] },
+	{ full: "gemini-3.8-flash", id: "gemini-3-8-flash", efforts: ["low", "medium", "high"] },
 	{ full: "gemini-3.1-pro", id: "gemini-3-1-pro", efforts: ["low", "high"] },
-	{ full: "claude-sonnet-4-6", id: "claude-sonnet-4-6" },
+	{ full: "claude-sonnet-5-5", id: "claude-sonnet-5-5", efforts: ["low", "medium", "high"] },
 ];
 
 

package/src/provider.ts

@@ -43,9 +43,22 @@ import { GATE_MARKER, mapNativeToShadow, stripMarkerFields } from "./approval-ga
 import type { ApprovalDecision, ApprovalPayload, ApprovalParkApi } from "./mcp-server.js";
 import path from "node:path";
 import { TurnDiffContext, createExecGitOps, formatInlineDiff, parseEditToolInput } from "./diff-render.js";
+import { stageSyspromptAgent } from "./sysprompt-agent.js";
 
 const DEFAULT_TIMEOUT_MIN = 10;
 
+/** Warned once per process: config.agent set while the system prompt needs
+ *  the staged carrier agent (issue #2 inline-block fallback). */
+let warnedUserAgentConflict = false;
+
+/** conversationId -> staged carrier agent name. Gate-closed turns look the
+ *  name up here so a conversation's agent field never flips: a change would
+ *  recycle the agy process mid-conversation (profile drift), and a respawn
+ *  must reload THAT conversation's own staged instructions. Content-addressed
+ *  staging (one dir per body) keeps sibling conversations from overwriting
+ *  each other's files. */
+const stagedAgentByConversation = new Map<string, string>();
+
 /** Zero-usage helper. agy doesn't expose token counts; pi's cost math gets
  *  zeros (we're not billing through this provider). */
 function zeroUsage(): Usage {
@@ -1182,6 +1195,10 @@ async function runTurnDriver(
 	}
 
 	let handle: TurnHandle;
+	// Name of the carrier agent staged for THIS turn's fresh conversation, if
+	// any. Recorded into stagedAgentByConversation once the outcome binds the
+	// conversation id, so later gate-closed turns pass the same agent.
+	let stagedAgentName: string | undefined;
 	if (isContinuation) {
 		const active = deps.driver.reentry();
 		if (!active) {
@@ -1225,12 +1242,44 @@ async function runTurnDriver(
 		// The uri is suffixed per turn so a deduping server cannot serve stale
 		// content on turn 2+.
 		const embeddedDigest = deps.engine === "acp" && digest ? digest : undefined;
-		// Fresh conversation only: agy stores the block in its own history, so
-		// re-sending it every turn would bloat each prompt and bust the cache.
-		const sysPrompt =
-			config.systemPrompt && !existing?.conversationId
-				? getCurrentSystemPrompt(context.messages) || undefined
-				: undefined;
+		// G10, fresh conversations only (bound conversations ride agy's own
+		// history; re-sending would bloat every prompt and bust the cache).
+		// stream-json delivery is a staged agent file, NOT prompt text: agy's
+		// stream-json path silently drops any turn past a ~25KB input cap and
+		// the dropped turn leaves the conversation permanently unresponsive
+		// (issue #2, probed 2026-09-30), and the block routinely crossed it.
+		// ACP keeps the inline block (JSON-RPC transport; --agent is a CLI
+		// feature). A user-configured agent always wins: never clobber it.
+		const gateOpen = config.systemPrompt && !existing?.conversationId;
+		const rawSysPrompt = gateOpen ? getCurrentSystemPrompt(context.messages) || undefined : undefined;
+		let sysPrompt = rawSysPrompt;
+		let agent = config.agent;
+		if (deps.engine !== "acp") {
+			if (rawSysPrompt && !config.agent) {
+				const stagedName = stageSyspromptAgent(
+					[SYSTEM_PROMPT_PREAMBLE, rawSysPrompt, TOOL_PRIORITY_NOTE].join("\n\n"),
+				);
+				if (stagedName) {
+					agent = stagedName;
+					sysPrompt = undefined;
+					stagedAgentName = stagedName;
+				}
+				// Staging failed: inline fallback. The silent-drop guard below
+				// keeps the resulting cap failure visible instead of quiet.
+			} else if (rawSysPrompt && config.agent && !warnedUserAgentConflict) {
+				warnedUserAgentConflict = true;
+				deps.log?.(
+					"sysprompt-agent-conflict",
+					{ agent: config.agent, effect: "system prompt ships inline in the prompt (over-cap drop risk)" },
+					"warn",
+				);
+			} else if (!rawSysPrompt && !config.agent && existing?.conversationId) {
+				// Gate closed (bound conversation): pass the carrier staged for
+				// THIS conversation, if any, so the driver profile never drifts on
+				// "agent" and a respawned process reloads its own instructions.
+				agent = stagedAgentByConversation.get(existing.conversationId);
+			}
+		}
 		const fullPrompt =
 			late.length > 0
 				? buildLateResultPrompt(late, prompt || undefined)
@@ -1242,12 +1291,12 @@ async function runTurnDriver(
 				effort,
 				mode: config.mode,
 				skipPermissions: config.skipPermissions,
-				agent: config.agent,
 				timeoutMin: config.turnTimeoutMin,
 				inactivityMin: config.inactivityTimeoutMin,
 				conversationId: existing?.conversationId ?? null,
 				prompt: fullPrompt,
 				images: images.length > 0 ? images : undefined,
+				agent,
 				contextBlock: embeddedDigest
 					? {
 							uri: `urn:pi-bridge:context-digest/${messageCount}`,
@@ -1282,6 +1331,49 @@ async function runTurnDriver(
 	}
 
 	const outcome = await handle.outcome;
+	// Issue #2 recovery paths. agy's stream-json prompt path silently drops an
+	// over-cap turn (SUCCESS, empty response, zero usage, NO model step) and a
+	// dropped turn leaves the conversation permanently unresponsive, so both
+	// failures clear the binding instead of settling a quiet empty reply —
+	// settling OK here would persist a dead conversation for every later turn
+	// (probe 2026-09-30: resume of a dropped-turn conversation never returns
+	// a result frame). stream-json only: the ACP driver leaves the evidence
+	// fields undefined.
+	const silentDrop = outcome.status === "OK" && outcome.modelOutputSeen === false;
+	const poisonedResume =
+		outcome.status === "ERROR" &&
+		outcome.deadline !== undefined &&
+		outcome.sawResult === false &&
+		Boolean(existing?.conversationId);
+	if (silentDrop || poisonedResume) {
+		if (existing?.conversationId || outcome.conversationId) {
+			store.delete(key);
+			if (outcome.conversationId) stagedAgentByConversation.delete(outcome.conversationId);
+		}
+		deps.log?.(
+			"turn-error",
+			{
+				reason: silentDrop ? "silent-overcap-drop" : "poisoned-conversation",
+				conversation: outcome.conversationId ?? null,
+			},
+			"error",
+		);
+		// A deadline with no model output is a stall/timeout, not the over-cap
+		// signature: label it by its real cause (the deadline guard's recovered-
+		// answer probe can settle OK with an empty response after the kill).
+		const dropCause = outcome.deadline
+			? "the turn hit its time limit and produced no model output"
+			: "the prompt was silently dropped (agy discards prompts past ~25KB with no error)";
+		finalize(
+			stream,
+			blocks,
+			"error",
+			silentDrop
+				? `agy returned success but produced no model output: ${dropCause}. Common cause: a very large pasted prompt. The conversation binding was cleared; retry with a smaller prompt.`
+				: "agy stopped responding on the resumed conversation (no response frame before the deadline; the conversation is dead). The binding was cleared, so the next antigravity turn starts a fresh conversation.",
+		);
+		return;
+	}
 	if (outcome.conversationId) {
 		// A different id than the stored one means the driver recreated the
 		// conversation under us (ACP session-load fallback, stream-json CLI
@@ -1293,12 +1385,14 @@ async function runTurnDriver(
 		// documented residual; recovery starts on the next turn.
 		if (existing?.conversationId && outcome.conversationId !== existing.conversationId) {
 			store.delete(key);
+			stagedAgentByConversation.delete(existing.conversationId);
 		} else if (outcome.status === "OK" && !outcome.aborted) {
 			store.set(key, {
 				conversationId: outcome.conversationId,
 				lastStepIdx: -1,
 				lastMessageCount: messageCount,
 			});
+			if (stagedAgentName) stagedAgentByConversation.set(outcome.conversationId, stagedAgentName);
 		}
 		// A failed or aborted turn on the SAME conversation keeps the pre-turn
 		// record: whether the prompt actually landed in agy's DB is not

package/src/sysprompt-agent.ts

@@ -0,0 +1,109 @@
+// G10 delivery for the stream-json engine: staged system-prompt agent.
+//
+// agy's stream-json prompt path silently drops any turn past a ~25KB input
+// cap (probed 2026-09-30, issue #2: status SUCCESS, empty response, zero
+// usage, no error — and the dropped turn leaves the conversation permanently
+// unresponsive to later input). The pi system prompt block used to ride the
+// first prompt of every fresh conversation and routinely crossed that cap,
+// killing the whole session. It now stages as an agy agent file discovered
+// under ~/.gemini/config/agents and passed via --agent: the CLI reads agent
+// files from disk, off the prompt line, so the cap never applies.
+//
+// Frontmatter keeps agy's DEFAULTS on purpose (no excludeDefaultComponents,
+// no tools list, no inheritMcp override): provider sessions need the normal
+// toolset and the bridge MCP config for G9 round-trips. Contrast the ask-tool
+// reviewer agent, which strips everything for sandboxing.
+//
+// Lifecycle: one agent dir per DISTINCT body (content-addressed by sha256);
+// two conversations with different system prompts in one process stage two
+// dirs and never overwrite each other, so a driver respawn mid-conversation
+// always reloads that conversation's own instructions. Same body -> same dir
+// (write-once; identical bytes are never rewritten). The name stays stable
+// across the turns of a conversation so the driver's profile comparison
+// never recycles on "agent" drift. The .pid marker lets sweepStaleWebAgents
+// prune orphans (same doctrine as the web delegates and the ask-tool
+// reviewer).
+
+import { createHash, randomBytes } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { sweepStaleWebAgents } from "./web-tools.js";
+
+export const SYS_AGENT_PREFIX = "pi-bridge-sys-";
+
+/** AGY_AGENTS_ROOT override for tests and sandboxes (same contract as the
+ *  ask-tool reviewer root). */
+export function syspromptAgentsRoot(): string {
+	return process.env.AGY_AGENTS_ROOT ?? path.join(os.homedir(), ".gemini", "config", "agents");
+}
+
+/** agent.md for the carrier. The body is the pi system prompt composed by the
+ *  provider (preamble + transcript system prompt + tool-priority note). */
+export function syspromptAgentMd(name: string, body: string): string {
+	return [
+		"---",
+		`name: ${name}`,
+		"description: Pi bridge system-prompt carrier: pi operating instructions plus project AGENTS.md context",
+		"mainAgent: true",
+		"model: inherit",
+		"---",
+		"",
+		body,
+		"",
+	].join("\n");
+}
+
+interface Staged {
+	root: string;
+	name: string;
+	dir: string;
+}
+
+/** Content-addressed staging cache: body sha256 -> staged dir. Two
+ *  conversations with different system prompts in one process must never
+ *  share a carrier file (a rewrite would leak one conversation's instructions
+ *  into the other's respawned agy process). */
+const stagedByHash = new Map<string, Staged>();
+
+function bodyHash(body: string): string {
+	return createHash("sha256").update(body).digest("hex").slice(0, 12);
+}
+
+/** Stage the carrier agent with `body` as its instructions. Content-addressed:
+ *  the same body reuses its dir (no rewrite), a new body gets a fresh dir.
+ *  Returns the agent name for --agent, or null when staging failed — the
+ *  caller then falls back to the legacy inline prompt block, where the
+ *  silent-drop guard keeps the cap risk visible. */
+export function stageSyspromptAgent(
+	body: string,
+	opts: { agentsRoot?: string } = {},
+): string | null {
+	try {
+		const root = opts.agentsRoot ?? syspromptAgentsRoot();
+		const hash = bodyHash(body);
+		const cached = stagedByHash.get(hash);
+		if (cached && cached.root === root) return cached.name;
+		sweepStaleWebAgents(root, Date.now(), SYS_AGENT_PREFIX);
+		fs.mkdirSync(root, { recursive: true });
+		// Nonce: two pi processes staging the same body must not fight over one
+		// dir; the pid plus nonce keeps every staging attempt self-contained.
+		const name = `${SYS_AGENT_PREFIX}${hash}-${process.pid}-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
+		const dir = path.join(root, name);
+		fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+		fs.writeFileSync(path.join(dir, ".pid"), `${process.pid}\n`, { mode: 0o600 });
+		fs.writeFileSync(path.join(dir, "agent.md"), syspromptAgentMd(name, body), {
+			mode: 0o600,
+		});
+		const entry: Staged = { root, name, dir };
+		stagedByHash.set(hash, entry);
+		return entry.name;
+	} catch {
+		return null;
+	}
+}
+
+/** Test hook: forget the staging cache without touching the filesystem. */
+export function resetSyspromptAgentForTests(): void {
+	stagedByHash.clear();
+}