@estebanforge/pi-antigravity-bridge 1.3.1 → 1.3.3

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.3.3] - 2026-09-01
+
+### Added
+
+- pi system prompt injection (G10): pi's composed system prompt - operating instructions plus the global agent-dir `AGENTS.md` and ancestor `AGENTS.md`/`CLAUDE.md` files - is prepended as a delimited block to the first prompt of each NEW agy conversation. agy has no system-prompt flag, so the prompt text is the only delivery path; the block is sent once per conversation and stays byte-identical afterwards, so agy's server-side prompt cache keeps hitting (unlike the per-turn G1 digest, which stays off by default for that reason). On by default (`config.systemPrompt`, `AGY_SYSTEM_PROMPT`, `/agy system-prompt on|off`); existing conversations keep the version they started with.
+
+## [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,17 @@ 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` |
+| `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) or `off` (agy-native behavior) | `on` |
 
-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`, `AGY_SYSTEM_PROMPT`. Env wins over the file, so while `AGY_DIGEST` or `AGY_SYSTEM_PROMPT` is set, the matching `/agy digest` or `/agy system-prompt` toggle persists a value that never takes effect.
 
 ### The /agy command
 
@@ -105,13 +102,14 @@ 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 system-prompt on|off send pi's system prompt + AGENTS.md to new agy conversations (default on)
 /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 +146,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/docs/PI-BRIDGE-GAPS.md

@@ -27,7 +27,13 @@ credentials, so a secret never crosses the bridge, and a long call renders in
 pi's native UI while it runs. agy's file edits surface as git-sourced diffs in
 pi's thinking stream. A delta digest of pi-side context (compaction summaries,
 other-provider turns) is available but OFF by default (`/agy digest on`): the
-digest changes every turn and defeats agy's server-side prompt cache.
+digest changes every turn and defeats agy's server-side prompt cache. The
+reverse direction is on by default (`/agy system-prompt off` to disable):
+pi's composed system prompt - its operating instructions plus the global
+agent-dir `AGENTS.md` and ancestor `AGENTS.md`/`CLAUDE.md` files - is
+prepended as a delimited block to the first prompt of each new agy
+conversation, once, so the prompt cache keeps hitting (G10 in
+`CHANGELOG.md`).
 
 ## Open gaps
 

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,11 +300,11 @@ 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"}`,
+		`  system prompt: ${config.systemPrompt ? "on" : "off"}`,
 		"",
-		"Subcommands: /agy mode plan|accept-edits, /agy permissions on|off, /agy model flash|pro|gemini, /agy thinking low|medium|high, /agy clear",
+		"Subcommands: /agy mode plan|accept-edits, /agy permissions on|off, /agy model flash|pro|gemini, /agy thinking low|medium|high, /agy digest on|off, /agy system-prompt on|off, /agy clear",
 	].join("\n");
 }
 
@@ -313,7 +312,7 @@ function statusText(ctx: AgyCommandCtx): string {
 function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 	pi.registerCommand("agy", {
 		description:
-			"Antigravity provider: status, doctor, mode picker, clear sessions. Usage: /agy [status|doctor|mode [plan|accept-edits]|digest on|off|patch-cleanup|clear]",
+			"Antigravity provider: status, doctor, mode picker, clear sessions. Usage: /agy [status|doctor|mode [plan|accept-edits]|digest on|off|system-prompt on|off|patch-cleanup|clear]",
 		handler: async (args, cmdCtx: ExtensionCommandContext) => {
 			const ui = cmdCtx.ui;
 			const mode = cmdCtx.mode;
@@ -352,7 +351,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})` : ""}`,
@@ -409,6 +407,20 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				}
 				return;
 			}
+			if (sub === "system-prompt") {
+				if (val === "on" || val === "off") {
+					const next = saveConfig({ systemPrompt: val === "on" });
+					ui?.notify(
+						next.systemPrompt
+							? "system-prompt on. pi's system prompt (incl. global and project AGENTS.md) is prepended to the first prompt of each new agy conversation. Existing conversations keep the version they started with."
+							: "system-prompt off. agy runs on its own system prompt; pi instructions and AGENTS.md files are not sent.",
+						"info",
+					);
+				} else {
+					ui?.notify(`system-prompt: ${loadConfig().systemPrompt ? "on" : "off"}\nusage: /agy system-prompt on|off`, "info");
+				}
+				return;
+			}
 
 			if (sub === "thinking") {
 				if (val === "low" || val === "medium" || val === "high") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "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. */
@@ -66,6 +60,16 @@ export interface AgyConfig {
 	 *  sessions gain nothing: agy already keeps its own history, and bridge
 	 *  round-trips deliver tool results through the bridge, not the digest. */
 	digest: boolean;
+	/** Prepend pi's composed system prompt (pi tool guidance + the global
+	 *  agent-dir AGENTS.md and ancestor AGENTS.md/CLAUDE.md) to the FIRST
+	 *  prompt of each fresh agy conversation.
+	 *
+	 *  Default ON: agy keeps its own history, so the prefix is sent once per
+	 *  conversation and stays byte-identical afterwards - agy's server-side
+	 *  prompt cache keeps hitting. This is why it is safe here while the G1
+	 *  digest (per-turn) is not. Turn off for agy-native behavior (agy's own
+	 *  system prompt only). */
+	systemPrompt: boolean;
 }
 
 const DEFAULTS: AgyConfig = {
@@ -73,9 +77,9 @@ const DEFAULTS: AgyConfig = {
 	skipPermissions: true,
 	defaultModel: "flash",
 	defaultThinking: "medium",
-	engine: "stream-json",
 	bridgeTools: "mcp",
 	digest: false,
+	systemPrompt: true,
 };
 
 /** Load config merged over defaults. Env vars override the file when set. */
@@ -120,11 +124,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";
@@ -133,14 +132,19 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 		? ["1", "true", "on"].includes(process.env.AGY_DIGEST.toLowerCase())
 		: file.digest ?? false;
 
+	const envSys = process.env.AGY_SYSTEM_PROMPT;
+	const systemPrompt = envSys !== undefined
+		? ["1", "true", "on"].includes(envSys.toLowerCase())
+		: file.systemPrompt ?? DEFAULTS.systemPrompt;
+
 	return {
 		mode,
 		skipPermissions,
 		defaultModel,
 		defaultThinking,
-		engine,
 		bridgeTools,
 		digest,
+		systemPrompt,
 		patchCleanupNotified: file.patchCleanupNotified === true,
 	};
 }