@estebanforge/pi-antigravity-bridge 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.3.2] - 2026-09-01
+
+### Removed
+
+- The `legacy-sqlite` fallback engine: `src/runner.ts`, `src/poller.ts`, `src/protobuf.ts`, the `run-agy` and `decode-db` scripts, and the `engine` config key / `AGY_ENGINE` env var. agy 1.1.18 changed step-row storage to a two-phase write (a placeholder row first, grown in place later); the polling engine read each row once as an empty placeholder and never re-read it, so turns completed with the full reply in the database and zero text in pi (issue #1). The engine decoded an undocumented storage format, so every agy storage change risked repeating that failure silently. The stream-json engine shares none of that code path; verified live against agy 1.1.18-era storage (1.1.23 installed). A stale `engine` value in an existing `config.json` is ignored.
+  Reported by @imatimba in #1. Thanks for the exact repro and the root-cause analysis; the report drove this removal.
+
+### Changed
+
+- `scripts/test-provider.ts` wires the stream-json driver explicitly (it exercised the legacy path implicitly before).
+- `tests/provider-streaming.test.ts` covers effort mapping against a fake driver. The legacy event-mapping tests died with the engine; stream-json event coverage lives in `tests/stream-roundtrip.test.ts`.
+
 ## [1.3.1] - 2026-08-31
 
 ### Changed

package/README.md

@@ -8,7 +8,7 @@ If you also have [`@estebanforge/pi-ask-antigravity`](https://github.com/Esteban
 
 ## What it does
 
-You pick a Gemini model in pi's `/model` picker. pi routes each turn through this provider. The default `stream-json` engine runs one persistent agy process in your workspace, feeds it each turn, parses its stream-json events, and streams the agent text back into pi token by token. Token usage is live. A `legacy-sqlite` fallback engine (spawn `agy -p`, poll its SQLite conversation DB, decode its protobuf steps) still exists; see [Engine and bridge surface](#engine-and-bridge-surface).
+You pick a Gemini model in pi's `/model` picker. pi routes each turn through this provider. A single persistent `agy` process runs in your workspace; pi feeds it each turn, parses its stream-json events, and streams the agent text back into pi token by token. Token usage is live.
 
 Multi-turn works. The provider binds a pi session to an agy conversation id (persisted under `~/.pi/agent/antigravity-bridge/sessions.json`) and resumes it on the next turn via `--conversation <id>`. agy keeps its own history, so only the latest user message is sent each turn.
 
@@ -20,7 +20,7 @@ Residual limits (with or without the bridge):
 
 - agy's own edits still land directly on disk; pi's inline diff review does not engage for them.
 - agy commands run without per-action approval, same as every other tool in pi. See [Permissions](#permissions) below.
-- No cost accounting: cost stays zero because agy runs on your subscription quota. Token usage is live on the `stream-json` engine; the `legacy-sqlite` fallback reports usage as zero.
+- No cost accounting: cost stays zero because agy runs on your subscription quota. Token usage is live.
 
 ## MCP tool bridge (agy uses pi's tools)
 
@@ -36,7 +36,7 @@ The bridge starts a localhost MCP server inside pi's process. `tools/list` retur
 
 **Security.** The MCP server binds to `127.0.0.1` only and requires a per-session shared-secret header (`x-bridge-token`) that agy sends from the bridge config; browsers cannot set custom headers on a simple cross-origin POST, so this blocks web CSRF against the loopback server. Request bodies are size-capped. This is intended for single-user developer machines: any local process running as the same user can read the token from the per-pid config and call the exposed tools, so do not run it on a shared host where you do not trust other same-user processes.
 
-### Native cards, wrapper replay, and skills (stream-json engine)
+### Native cards, wrapper replay, and skills
 
 Read-only agy steps (view_file, list_dir, grep_search, find_by_name) re-run as
 real pi builtins (`read`, `ls`, `grep`, `find`) when those builtins are active,
@@ -48,9 +48,8 @@ anything with side effects.
 
 When the bridge is on, agy also gets one `activate_skill` tool whose enum is
 your pi Agent Skills catalog; calling it returns the SKILL.md body. The bridge
-answers it directly, no pi round-trip. `/agy doctor` prints engine state,
-driver counters, bridge port, and the last lifecycle events without spending
-tokens.
+answers it directly, no pi round-trip. `/agy doctor` prints driver counters,
+bridge port, and the last lifecycle events without spending tokens.
 
 ## Install
 
@@ -64,8 +63,6 @@ pi install npm:@estebanforge/pi-antigravity-bridge
 
 Requires the **`agy` CLI** installed and authenticated. If you don't have it, follow Google's [official install guide](https://antigravity.google/docs/cli/install) for your platform, then run `agy` once to complete Google OAuth. The extension resolves `agy` on `$PATH`, or via the `AGY_BIN` environment variable.
 
-Also requires Node 22.5 or newer (uses the built-in `node:sqlite`).
-
 ## Usage
 
 Pick a model and talk to pi as usual:
@@ -86,17 +83,16 @@ Model ids are slugified from the `agy models` output (`Gemini 3.6 Flash (Medium)
 
 If `agy models` fails at load (binary missing, auth not done, network stall), a fallback catalog still populates the picker so you get a clear runtime error instead of an empty list.
 
-### Engine and bridge surface
+### Bridge surface
 
-`config.json` selects the turn engine and the bridge surface:
+`config.json` selects the bridge surface:
 
 | Key | Values | Default |
 | --- | --- | --- |
-| `engine` | `stream-json` (persistent agy process, toolUse round-trips, live usage) or `legacy-sqlite` (spawn `agy -p`, poll its SQLite) | `stream-json` |
 | `bridgeTools` | `none` (bridge off), `mcp` (pi-mcp-adapter tools), `all` (every non-builtin tool, incl. other `Ask*` delegations) | `mcp` |
 | `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` |
 
-Env overrides: `AGY_ENGINE`, `AGY_BRIDGE_TOOLS`, `AGY_DIGEST`. The `legacy-sqlite` engine is kept as a fallback and is scheduled for removal once the stream-json engine has burned in.
+Env overrides: `AGY_BRIDGE_TOOLS`, `AGY_DIGEST`.
 
 ### The /agy command
 
@@ -105,13 +101,13 @@ Env overrides: `AGY_ENGINE`, `AGY_BRIDGE_TOOLS`, `AGY_DIGEST`. The `legacy-sqlit
 ```
 /agy                      status, or open the mode/permissions/model/thinking picker (TUI)
 /agy status               print current mode, permissions, model + session counts
-/agy doctor               engine state, driver counters, bridge port, last lifecycle events
+/agy doctor               bridge state, driver counters, bridge port, last lifecycle events
 /agy mode plan            review-only: agy plans but writes nothing
 /agy mode accept-edits    agy applies edits directly (default)
 /agy permissions on|off   auto-approve / prompt for tool calls (see warning)
 /agy model flash|pro|gemini   default model alias for the AskAntigravity tool
 /agy thinking low|medium|high default thinking tier for the AskAntigravity tool
-/agy digest on|off        inject pi-side context into agy prompts (default off; see engine table)
+/agy digest on|off        inject pi-side context into agy prompts (default off; see table above)
 /agy patch-cleanup        restore the original pi files if an older version patched them
 /agy clear                drop all session bindings (force fresh conversations)
 ```
@@ -148,7 +144,7 @@ Build, test, and debug instructions live in [docs/DEVELOPMENT.md](docs/DEVELOPME
 
 Google's [Antigravity ToS](https://antigravity.google/terms) (Section 6) prohibits accessing the service "in connection with products not provided by us", and names as its example using tools like Hermes/OpenClaw with Antigravity OAuth. That targets reusing your credentials in a non-Google harness that calls Google's backend directly.
 
-This extension does not do that. It spawns the official, unmodified `agy` binary as a subprocess; `agy` performs its own OAuth and makes its own calls to Google. This code never sees, extracts, or reuses your token, and never contacts Antigravity's backend. It only reads what `agy` itself produces locally: its stream-json output on the default engine, its SQLite conversation DB on the fallback engine. From Google's server-side view there is no signal that distinguishes "agy launched by pi" from "agy launched by a terminal, an IDE task runner, or cron": same signed binary, same authenticated calls.
+This extension does not do that. It spawns the official, unmodified `agy` binary as a subprocess; `agy` performs its own OAuth and makes its own calls to Google. This code never sees, extracts, or reuses your token, and never contacts Antigravity's backend. It only reads what `agy` itself produces locally: its stream-json output. From Google's server-side view there is no signal that distinguishes "agy launched by pi" from "agy launched by a terminal, an IDE task runner, or cron": same signed binary, same authenticated calls.
 
 Google's reported enforcement to date (the February 2026 suspensions) targeted token-reuse tools, not spawning the official CLI.
 

package/docs/ARCHITECTURE.md

@@ -2,14 +2,11 @@
 
 How the provider works internally. For build/test/debug workflow see [DEVELOPMENT.md](./DEVELOPMENT.md).
 
-## Engines
+## Turn engine
 
-The provider runs one of two turn engines (`config.engine`, default `stream-json`):
+The provider runs one turn engine: a long-lived `agy --input-format stream-json --output-format stream-json` process per provider. Turns are fed over stdin; agy emits NDJSON events on stdout; the driver parses them and streams text into pi token by token. Conversation binding comes from the `init` event, tool steps arrive as typed events (no protobuf decoding), and token usage is live.
 
-- **`stream-json` (default):** one long-lived `agy --input-format stream-json --output-format stream-json` process per provider. Turns are fed over stdin; agy emits NDJSON events on stdout; the driver parses them and streams text into pi token by token. Conversation binding comes from the `init` event, tool steps arrive as typed events (no protobuf decoding), and token usage is live.
-- **`legacy-sqlite` (fallback):** the pre-1.3.0 engine - spawn `agy -p`, poll its SQLite conversation DB on a 250 ms interval, decode the protobuf step payloads. Kept as a fallback and scheduled for removal once `stream-json` has burned in (`AGY_ENGINE=legacy-sqlite` selects it).
-
-Shared by both engines: session binding (`sessions.json`), runtime config, the `AskAntigravity` tool, the MCP tool bridge surface, and the G1 context digest (off by default - see below).
+Shared infrastructure: session binding (`sessions.json`), runtime config, the `AskAntigravity` tool, the MCP tool bridge surface, and the G1 context digest (off by default - see below).
 
 ## Module map
 
@@ -21,21 +18,18 @@ src/stream-events.ts  agy NDJSON event parser (init / step_update / result) + us
 src/native-tools.ts   maps agy read-only tool steps to real pi builtins (read/ls/grep/find) for native re-execution
 src/skills.ts         activate_skill bridge: exposes the pi Agent Skills catalog to agy, answered by the bridge directly
 src/patch-cleanup.ts  detects a leftover invokeTool patch from pre-1.3.0 installs; /agy patch-cleanup restores the backup
-src/runner.ts         legacy engine: spawn agy -p, concurrent poll loop, abort/timeout, emit events
-src/poller.ts         legacy engine: read-only node:sqlite handle over one conversation DB
-src/protobuf.ts       legacy engine: hand-rolled varint walker + extractors (field 20.1 = text)
-src/discovery.ts      legacy engine: snapshot/diff + pid fd-scan to bind the conversation id agy -p never prints
+src/discovery.ts      conversation-id binding for the AskAntigravity one-shot tool (agy -p never prints its conversation id)
 src/models.ts         agy models -> pi Model projection (full catalog, per-model effort)
 src/sessions.ts       atomic JSON store: pi session -> agy conversation + watermark
-src/config.ts         persisted runtime config (engine, bridgeTools, digest, mode, permissions, model/thinking defaults)
+src/config.ts         persisted runtime config (bridgeTools, digest, mode, permissions, model/thinking defaults)
 src/ask-tool.ts       the AskAntigravity one-shot delegation tool (model/thinking defaults)
 src/mcp-server.ts     MCP tool bridge server: ferries tools/list + tools/call; calls park in the provider round-trip
 src/diff-render.ts    render agy's file edits as git diffs in pi's thinking stream
 ```
 
-No generated protobuf code, no native SQLite dependency (`node:sqlite` covers the legacy engine's reads).
+No generated protobuf code, no SQLite dependency.
 
-## Stream-json engine (default)
+## Stream-json engine
 
 ### Process and events
 
@@ -61,31 +55,6 @@ Display follows the same split: agy read-only steps (`view_file`, `list_dir`, `g
 
 By default the prompt agy receives is only the latest user message: agy keeps its own history. When `config.digest` is on (`AGY_DIGEST`, `/agy digest on`), the provider prepends a DELTA digest of pi-side context agy was not spawned for - compaction summaries, other-provider turns, pi-tool results. Off by default because the digest changes every turn and defeats agy's server-side prompt cache (~25-30k tokens re-billed per turn). Enable it for mixed-provider sessions where agy must see pi-side context; pure antigravity sessions gain nothing, and bridge round-trips deliver tool results through the bridge, not the digest.
 
-## Legacy-sqlite engine internals
-
-The sections below describe the `legacy-sqlite` fallback only (`AGY_ENGINE=legacy-sqlite`). The stream-json engine shares none of this code path.
-
-### The decode pipeline
-
-agy writes each step to a SQLite row with a protobuf blob in `step_payload`. The text we want lives at field 20, submessage field 1. Tool calls live at field 5, submessage field 4, with the name at field 2 or 9 and the raw input JSON at field 3. These field numbers are reverse-engineered facts (cross-checked against the shindgew/agy-acp and shubzkothekar/antigravity-acp decoders, then verified against real databases on agy 1.1.7). They are load-bearing. Unknown fields are skipped per protobuf wire rules, so a future agy that adds fields will not break decoding.
-
-### Step types
-
-| step_type | meaning |
-| --- | --- |
-| 15 | agent text (payload field 20 -> field 1) |
-| 14 | thinking |
-| 23 | title update (payload field 30 -> field 4) |
-| 5, 7, 8, 9, 17, 21, 33, 101, 132, 138 | tool run (payload field 5 -> field 4 -> name@2/9, input@3) |
-
-Status 3 = complete; anything else = in-flight.
-
-### Polling
-
-The runner spawns `agy -p`, then polls its conversation DB on a 250ms interval concurrent with the running process (this is what makes the provider actually stream, not replay at exit). Each tick issues a single `PRAGMA data_version` check; while agy is thinking and has not committed, that check is false and no row SELECT runs at all (neither the new-row read nor the in-place re-read of the step agy is currently extending). Only when a commit lands do both reads fire in one pass. Three trailing polls at 100ms after agy exits catch the last flush; on abort these are skipped so cancellation is prompt.
-
-### Conversation id discovery
-
-agy `-p` does not print the conversation id. On a fresh run the runner snapshots the `*.db` stems in the conversations dir before spawn, then diffs after. Exactly one new file = ours; zero new = refuse to bind (surfaced as an error rather than a guess).
+### Removed: the legacy-sqlite engine (1.3.2)
 
-When **more than one** new file appears (a concurrent agy or subagent started in parallel), the runner passes its spawned pid to `newConversationId`, which scans the process tree's open file descriptors (`/proc/<pid>/fd` on Linux) to find the single candidate `.db` our own agy is writing to. This is the authoritative disambiguator: mtime cannot separate two *active* concurrent runs, and the user-message payload (`step_type 98`) is undocumented and deeply nested, so content-matching would risk a silent misbind. When the pid is unavailable, the platform is not Linux, the process has already exited (the AskAntigravity tool binds post-exit), or the scan itself is ambiguous, discovery fails safe to null rather than guessing.
+The pre-1.3.0 engine (spawn `agy -p`, poll the SQLite conversation DB, decode protobuf step payloads) was removed in 1.3.2. agy 1.1.18 changed the step-row storage to a two-phase write (a metadata-only placeholder row that grows in place), which the polling decoder read once as an empty placeholder and never re-read: turns completed with the full reply in the database and zero text streamed to pi (issue #1, reported by @imatimba). The engine reverse-engineered an undocumented storage format, so every agy storage change risked repeating that silent failure. The stream-json engine shares none of that code path and is unaffected by storage-format changes. `AGY_ENGINE` and the `engine` config key are gone; a stale value in an existing `config.json` is ignored.

package/docs/DEVELOPMENT.md

@@ -14,22 +14,9 @@ The integration scripts below spawn a real `agy` process and need a logged-in ac
 
 ## Standalone scripts
 
-These exercise the pipeline without pi. Useful for isolating where a bug lives (decoder? poller? provider? pi loader?).
+These exercise the pipeline without pi. Useful for isolating where a bug lives (driver? provider? pi loader?).
 
 ```bash
-# Decode any conversation DB and print agent text + tool calls.
-# Accepts a UUID (resolved against ~/.gemini/antigravity-cli/conversations/)
-# or an absolute path. Fastest way to check the protobuf decoder against
-# real data. No agy spawn, no network.
-npm run decode-db -- <uuid-or-path>
-
-# Spawn agy and stream decoded events to stdout with timestamps. Proves the
-# concurrent poll loop actually streams (events arrive during the run, not
-# only at exit). Use this to reproduce a hang or a missing-event bug.
-npm run run-agy -- "Say hello"
-npm run run-agy -- --model "Gemini 3.6 Flash (Medium)" --mode plan "Review src/protobuf.ts"
-npm run run-agy -- --conversation <uuid> "follow up"   # resume a turn
-
 # Drive the provider's streamSimple directly (no pi TUI) and assert the
 # full event lifecycle: start -> text_start -> text_delta -> text_end ->
 # done. The closest thing to a pi turn without pi.
@@ -53,21 +40,19 @@ AGY_LIVE=1 node --experimental-strip-types scripts/smoke-stream-json.mjs
 
 Most "stuck" reports trace to one of:
 
-1. **agy blocked on a permission prompt.** `accept-edits` auto-approves file edits but NOT shell commands. Any `run_command` prompts `y/n`, which hangs forever in non-interactive mode (both engines). The provider passes `--dangerously-skip-permissions` by default to avoid this. If you turned it off (`/agy permissions off`), that is why. See the README Permissions section.
+1. **agy blocked on a permission prompt.** `accept-edits` auto-approves file edits but NOT shell commands. Any `run_command` prompts `y/n`, which hangs forever in non-interactive mode. The provider passes `--dangerously-skip-permissions` by default to avoid this. If you turned it off (`/agy permissions off`), that is why. See the README Permissions section.
 2. **agy never started.** Check `AGY_BIN` is on PATH (or set explicitly). The spawner swallows spawn ENOENT into the result's stderr, surfaced by the provider as an error event.
-3. **Conversation id never bound.** On `stream-json` the `init` event carries the id. On `legacy-sqlite` the snapshot/diff discovery refuses to bind if more than one new `.db` appears (ambiguous). `npm run decode-db` against the suspected DB confirms agy wrote steps.
+3. **Conversation id never bound.** On `stream-json` the `init` event carries the id, so a missing binding means the turn never produced a result event. `/agy doctor` prints the last lifecycle events.
 4. **Print-mode environmental hang.** `pi -p` can hang with zero output in some containers (upstream [google-antigravity/antigravity-cli#318](https://github.com/google-antigravity/antigravity-cli/issues/318)). It affects built-in providers too, not this extension. Validate the turn with `scripts/test-provider.ts` instead.
 
 ## Regression tests worth knowing
 
 - `tests/stream-roundtrip.test.ts` - the stream-json engine pieces: NDJSON parser, native re-exec mapping, and the no-patch toolUse round-trip store.
-- `tests/provider-streaming.test.ts` - drives streamSimple with an injected fake runner (no agy) and asserts the exact event sequence: text/thinking close-on-switch, tool labels through the thinking block, empty-turn fallback.
+- `tests/provider-streaming.test.ts` - drives streamSimple with an injected fake driver (no agy) and asserts how pi's reasoning level maps onto the agy `--effort` tier (forward, clamp, omit).
 - `tests/provider-digest.test.ts` - the G1 context digest builder: injects pi-side context without replaying agy's own history.
 - `tests/patch-cleanup.test.ts` - legacy-patch detection and restore, real fs via tmpdirs, no mocks.
-- `tests/runner-streaming.test.ts` - (legacy engine) a fake agy writes rows on a delay; asserts events arrive DURING the run (not all at exit) and that abort returns promptly. Guards the "provider did not actually stream" class of bug.
-- `tests/protobuf.test.ts` - (legacy engine) pure decoder math (varint, field walking, nested submessages).
 - `tests/mcp-server.test.ts` - the MCP tool bridge end-to-end against a real (port 0) server: capability gate, per-pid config lifecycle, shared-secret token gate, 1 MB body cap, protocol-version clamp. The provider owns the tool catalog and the round-trip; the server only ferries list/call.
 
 ## Module map
 
-See [ARCHITECTURE.md](./ARCHITECTURE.md) for the module map and the engine internals (stream-json events, no-patch round-trip, legacy decode/polling).
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for the module map and the engine internals (stream-json events, no-patch round-trip).

package/extensions/index.ts

@@ -2,9 +2,8 @@
 //
 // Registers Gemini (via the agy CLI) as a pi model provider so it shows up in
 // the /model picker as antigravity/gemini-*. When selected, pi routes each turn
-// through streamSimple, which spawns `agy -p`, polls the conversation SQLite DB
-// agy writes, decodes the protobuf step payloads, and streams the agent text
-// back into pi's TUI.
+// through streamSimple, which feeds the persistent stream-json driver process
+// and streams the agent text back into pi's TUI.
 //
 // Architectural wall (cannot be worked around - see PLAN.md):
 //   agy runs its OWN closed tool loop against --add-dir. pi's read/write/edit/
@@ -301,7 +300,6 @@ function statusText(ctx: AgyCommandCtx): string {
 		`  tool thinking: ${config.defaultThinking}`,
 		`  sessions:      ${ctx.store.size} bound`,
 		`  config:        ${CONFIG_PATH}`,
-		`  engine:        ${config.engine}`,
 		`  bridge tools:  ${config.bridgeTools}`,
 		`  digest:        ${config.digest ? "on" : "off"}`,
 		"",
@@ -352,7 +350,6 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				const port = ctx.getMcpPort();
 				const lines = [
 					"Antigravity doctor (no tokens spent)",
-					`  engine:        ${config.engine}`,
 					`  bridge:        ${config.bridgeTools}${port ? ` (port ${port})` : " (not running)"}`,
 					`  driver:        ${snap.state}${snap.pid ? ` pid=${snap.pid}` : ""}${snap.conversationId ? ` conv=${snap.conversationId.slice(0, 8)}` : ""}`,
 					`  driver stats:  spawns=${snap.stats.spawns} turns=${snap.stats.turns} reused=${snap.stats.reused} recycles=${snap.stats.recycles}${snap.stats.lastRecycleReason ? ` (last: ${snap.stats.lastRecycleReason})` : ""}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Streaming Gemini provider for pi, built on the agy CLI. Registers antigravity/* models in pi's /model picker; drives agy through its stream-json protocol (persistent process, tool round-trips, live usage).",
   "keywords": [
     "pi-package",
@@ -30,8 +30,6 @@
     "build": "tsc --noEmit",
     "test": "vitest run",
     "prepublishOnly": "npm run build && npm test",
-    "run-agy": "tsx scripts/run-agy.ts",
-    "decode-db": "tsx scripts/decode-db.ts",
     "smoke:pi": "bash scripts/smoke-in-pi.sh"
   },
   "files": [

package/src/config.ts

@@ -24,7 +24,6 @@ const CONFIG_PATH = path.join(
 
 export type AgyMode = "accept-edits" | "plan";
 export type ThinkingTier = "low" | "medium" | "high";
-export type AgyEngine = "stream-json" | "legacy-sqlite";
 export type BridgeTools = "none" | "mcp" | "all";
 
 export interface AgyConfig {
@@ -39,11 +38,6 @@ export interface AgyConfig {
 	defaultModel: string;
 	/** AskAntigravity tool: default thinking tier when the alias names none. */
 	defaultThinking: ThinkingTier;
-	/** Turn engine. "stream-json" (default): one persistent agy process fed
-	 *  NDJSON user events; enables live toolUse round-trips, native usage, and
-	 *  conversation binding from the init event. "legacy-sqlite": the old
-	 *  spawn-`agy -p`-and-poll-SQLite path, kept as a fallback for one release. */
-	engine: AgyEngine;
 	/** Set after the one-time notice about a leftover legacy invokeTool patch
 	 *  on the installed pi. The notice never repeats; /agy patch-cleanup is
 	 *  always available. */
@@ -73,7 +67,6 @@ const DEFAULTS: AgyConfig = {
 	skipPermissions: true,
 	defaultModel: "flash",
 	defaultThinking: "medium",
-	engine: "stream-json",
 	bridgeTools: "mcp",
 	digest: false,
 };
@@ -120,11 +113,6 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 	const defaultThinking: ThinkingTier =
 		thinkRaw === "low" || thinkRaw === "high" ? thinkRaw : "medium";
 
-	const engine: AgyEngine =
-		process.env.AGY_ENGINE === "legacy-sqlite" || file.engine === "legacy-sqlite"
-			? "legacy-sqlite"
-			: "stream-json";
-
 	const bridgeRaw = (process.env.AGY_BRIDGE_TOOLS ?? file.bridgeTools ?? DEFAULTS.bridgeTools).toLowerCase();
 	const bridgeTools: BridgeTools =
 		bridgeRaw === "none" || bridgeRaw === "all" ? bridgeRaw : "mcp";
@@ -138,7 +126,6 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 		skipPermissions,
 		defaultModel,
 		defaultThinking,
-		engine,
 		bridgeTools,
 		digest,
 		patchCleanupNotified: file.patchCleanupNotified === true,

package/src/provider.ts

@@ -29,7 +29,6 @@ import {
 	type Usage,
 } from "@earendil-works/pi-ai";
 import type { Api } from "@earendil-works/pi-ai";
-import { runAgyTurn, type AgyEvent, type AgyRunOptions } from "./runner.js";
 import { AgyDriver, type DriverActivity, type TurnHandle } from "./driver.js";
 import { toPiUsage } from "./stream-events.js";
 import { mapAgyToolToNative } from "./native-tools.js";
@@ -245,11 +244,8 @@ export interface BlockState {
 export interface StreamSimpleDeps {
 	entries: AgyModelEntry[];
 	store: SessionStore;
-	/** Override the agy turn runner (tests inject a scripted event source).
-	 *  Defaults to the real runAgyTurn. Legacy engine only. */
-	runAgyTurn?: typeof runAgyTurn;
-	/** Persistent stream-json engine. When set (and config.engine selects it),
-	 *  turns run on the driver and bridge calls park as toolUse round-trips. */
+	/** Persistent stream-json driver. Turns run on the driver and bridge
+	 *  calls park as toolUse round-trips. Required with roundTrips. */
 	driver?: AgyDriver;
 	roundTrips?: ToolRoundTrips;
 	/** Replay store for the display-only antigravity wrapper tool. Required
@@ -692,13 +688,12 @@ async function runTurnDriver(
 export function createStreamSimple(
 	deps: StreamSimpleDeps,
 ): (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream {
-	const { entries, store, runAgyTurn: runFn = runAgyTurn, driver, roundTrips } = deps;
+	const { entries, store, driver, roundTrips } = deps;
 
 	return function streamSimple(model, context, options) {
 		const stream = createAssistantMessageEventStream();
 		// Fire the async turn; return the stream synchronously per pi's contract.
-		const config = loadConfig();
-		if (driver && roundTrips && config.engine === "stream-json") {
+		if (driver && roundTrips) {
 			void runTurnDriver(stream, model, context, options, entries, store, {
 				driver,
 				roundTrips,
@@ -706,183 +701,16 @@ export function createStreamSimple(
 				nativeActive: deps.nativeActive,
 			});
 		} else {
-			void runTurn(stream, model, context, options, entries, store, runFn);
+			// Miswired extension: no driver means no engine. Fail the turn visibly
+			// instead of silently producing an empty assistant message.
+			const partial = newAssistant(model);
+			const blocks: BlockState = { partial, textIdx: null, thinkingIdx: null, started: false };
+			finalize(stream, blocks, "error", "antigravity driver not configured");
 		}
 		return stream;
 	};
 }
 
-async function runTurn(
-	stream: AssistantMessageEventStream,
-	model: Model<Api>,
-	context: Context,
-	options: SimpleStreamOptions | undefined,
-	entries: AgyModelEntry[],
-	store: SessionStore,
-	runFn: typeof runAgyTurn,
-): Promise<void> {
-	const partial = newAssistant(model);
-	const blocks: BlockState = { partial, textIdx: null, thinkingIdx: null, started: false };
-
-	// Direct emit helpers. agy streams deltas that may not align to line
-	// boundaries; pi's TUI renders partial lines fine, so we append and push
-	// each delta straight through (no filtering, no buffering).
-	const appendTextDelta = (delta: string): void => {
-		appendText(stream, blocks, delta);
-	};
-	const appendThinkingDelta = (delta: string): void => {
-		appendThinking(stream, blocks, delta);
-	};
-
-	// Signal the turn has begun IMMEDIATELY. pi's native Working indicator is
-	// driven by the stream's start event (isStreaming). Without this, agy's
-	// initial thinking seconds (before it emits any step) show nothing and the
-	// UI looks frozen. Lazy start (on first content) was the old behavior.
-	ensureStarted(stream, blocks);
-
-	const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
-	const key = sessionKey(options, cwd);
-	const existing = store.get(key);
-	const messageCount = context.messages.length;
-
-	const prompt = extractUserPrompt(context);
-	if (!prompt) {
-		finalize(stream, blocks, "error", "No user message to send to agy.");
-		return;
-	}
-
-	// Runtime config (mode, permissions, digest). Loaded fresh each turn so
-	// /agy toggles take effect immediately without a reload.
-	const config = loadConfig();
-
-	// G1: inject a delta digest of pi-side context agy was not spawned for
-	// (compaction summaries, other-provider turns), gated on config.digest:
-	// the digest changes every turn and defeats agy's prompt cache. agy keeps
-	// its own history; see docs/PI-BRIDGE-GAPS.md (G1).
-	const watermark = existing?.lastMessageCount ?? 0;
-	const digest = config.digest ? buildContextDigest(context.messages, watermark) : "";
-	const fullPrompt = digest ? `${DIGEST_PREAMBLE}\n\n${digest}\n\n---\n\n${prompt}` : prompt;
-
-	// Resolve the pi model id to its catalog entry. On a miss, fall through to
-	// the id itself  -  agy will likely reject, but the error reaches the user
-	// instead of a silent no-op.
-	const entry = entries.find((e) => e.id === model.id) ?? null;
-	const agyModel = entry?.full ?? model.id;
-
-
-	// Effort-driven bases always need --effort (a base slug is invalid on its
-	// own); fixed models never get it (agy rejects --effort for them). For an
-	// effort-driven base we clamp pi's level to the tiers agy offers it.
-	const effort = entry?.efforts?.length ? toAgyEffort(options?.reasoning, entry.efforts) : undefined;
-
-	const runOpts: AgyRunOptions = {
-		cwd,
-		model: agyModel,
-		mode: config.mode,
-		skipPermissions: config.skipPermissions,
-		effort,
-		prompt: fullPrompt,
-		conversationId: existing?.conversationId ?? null,
-		baseStepIdx: existing?.lastStepIdx ?? -1,
-		timeoutMin: DEFAULT_TIMEOUT_MIN,
-		signal: options?.signal,
-	};
-
-	// G8: per-turn diff context for agy's file edits (write_to_file et al.).
-	// Turn-scoped so concurrent turns never share OLD-content caches.
-	const diffCtx = new TurnDiffContext(createExecGitOps());
-
-	const onEvent = (event: AgyEvent) => {
-		switch (event.kind) {
-			case "text":
-				appendTextDelta(event.text);
-				break;
-			case "thinking":
-				appendThinkingDelta(event.text);
-				break;
-			case "tool": {
-				// G8: if agy wrote a file, surface a git-sourced diff; else the plain
-				// tool label. Always shown (agy's own tool loop, surfaced for visibility).
-				const edit = parseEditToolInput(event.inputJson ?? "");
-				if (edit) {
-					const absFile = path.isAbsolute(edit.file) ? edit.file : path.resolve(cwd, edit.file);
-					const outcome = diffCtx.diffEdit(absFile, edit.content);
-					const label = edit.description ?? path.basename(absFile);
-					appendThinkingDelta(`[agy edit: ${label}]\n`);
-					if (outcome.text) appendThinkingDelta(`${outcome.text}\n`);
-				} else {
-					appendThinkingDelta(`[agy tool: ${event.name}]\n`);
-				}
-				break;
-			}
-			case "title":
-				// Conversation title metadata  -  not streamed to the user.
-				break;
-		}
-	};
-
-	let result;
-	try {
-		result = await runFn(runOpts, onEvent);
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		finalize(stream, blocks, "error", `agy failed to start: ${msg}`);
-		return;
-	}
-
-	// Persist for the next turn (resume). Only bind when we actually discovered
-	// an id  -  a discovery miss shouldn't clobber a prior good binding.
-	// Persist for the next turn (resume). Only bind when we actually discovered
-	// an id  -  a discovery miss shouldn't clobber a prior good binding. The
-	// lastMessageCount watermark advances on a successful bind even if the turn
-	// later aborted or timed out: the prompt (digest included) was handed to
-	// agy at spawn, so its DB has seen that context. Guarding this on
-	// exitCode===0 would re-inject stale deltas after retryable failures.
-	if (result.conversationId) {
-		store.set(key, {
-			conversationId: result.conversationId,
-			lastStepIdx: result.lastIdx,
-			lastMessageCount: messageCount,
-		});
-	}
-
-	if (result.aborted) {
-		finalize(stream, blocks, "aborted", "Operation aborted");
-		return;
-	}
-	if (result.timedOut) {
-		const note = `agy exceeded the ${runOpts.timeoutMin}m timeout`;
-		finalize(stream, blocks, "error", note);
-		return;
-	}
-	if (result.exitCode !== 0) {
-		const detail = result.stderr.trim() || `agy exited with status ${result.exitCode}`;
-		finalize(stream, blocks, "error", detail);
-		return;
-	}
-
-	// Discovery miss: agy exited cleanly but we never bound a conversation id
-	// this turn (ambiguous snapshot, DB not created in time, or a prior session
-	// whose id failed CONV_ID_RE and silently fell through to fresh discovery).
-	// Guard on whether we bound THIS turn, not on whether a prior session
-	// existed - otherwise a corrupt existing entry re-opens the silent-empty-
-	// success hole the first review closed.
-	if (!result.conversationId) {
-		const detail =
-			"agy exited cleanly but its conversation database could not be bound. " +
-			"The run may have partially applied edits with no visible output.";
-		finalize(stream, blocks, "error", detail);
-		return;
-	}
-
-	// Success. If no text ever streamed (agy did only tool work, or returned
-	// empty), emit an empty text block so pi has a well-formed assistant turn.
-	if (blocks.textIdx === null && blocks.thinkingIdx === null) {
-		ensureTextOpen(stream, blocks);
-	}
-	finalize(stream, blocks, "stop");
-}
-
 /** Signal the start of the assistant turn exactly once. `start` is
  *  turn-level (analogous to Anthropic's message_start), not per-block  -  the
  *  per-block signals are text_start / thinking_start. */