@estebanforge/pi-antigravity-bridge 1.3.1 → 1.3.3

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";
@@ -85,6 +84,43 @@ const COMPACTION_MARKER = "compacted into the following summary";
 const DIGEST_PREAMBLE =
 	"[The following is context from the broader pi session that this Antigravity turn was not directly spawned for: compaction summaries and turns handled by other providers or pi's own tools. Your own prior turns are already in your conversation history. Use this for continuity only.]";
 
+// --- pi system prompt (G10) ----------------------------------------------------
+//
+// pi composes context.systemPrompt every turn: its own operating instructions
+// plus every AGENTS.md/CLAUDE.md it loaded (global agent dir first, then
+// ancestors). The provider used to drop it, so agy models never saw the user's
+// machine-level or project-level instructions. agy has no system-prompt flag
+// (verified against `agy --help`), so the only delivery path is the prompt
+// text. We prepend it as a delimited block on the FIRST prompt of a fresh
+// conversation only: agy keeps its own history, the block stays byte-identical
+// afterwards, and agy's server-side prompt cache keeps hitting.
+
+export const SYSTEM_PROMPT_PREAMBLE =
+	"[The following is the system prompt of the pi session that spawned this conversation: operating instructions plus project context (AGENTS.md files). Apply it for this whole conversation. Tool guidance may reference pi-side tools; use your own tools or the pi tool bridge for those actions.]";
+
+export const SYSTEM_PROMPT_END = "[END SYSTEM PROMPT]";
+
+/** Assemble the full agy prompt: system prompt block, pi-side digest, user
+ *  prompt. Empty parts are dropped. Pure; exported for unit testing.
+ *  Pass systemPrompt only on a fresh conversation (see runTurnDriver). */
+export function buildFullPrompt(
+	systemPrompt: string | undefined,
+	digest: string,
+	prompt: string,
+): string {
+	const parts: string[] = [];
+	if (systemPrompt) {
+		parts.push(`${SYSTEM_PROMPT_PREAMBLE}\n\n${systemPrompt}\n\n${SYSTEM_PROMPT_END}`);
+	}
+	if (digest) {
+		parts.push(`${DIGEST_PREAMBLE}\n\n${digest}`);
+	}
+	if (prompt) {
+		parts.push(prompt);
+	}
+	return parts.join("\n\n---\n\n");
+}
+
 /** Flatten any message content shape (string or content-block array) to text.
  *  Drops images, thinking, and tool-call blocks. */
 function blocksToText(content: unknown): string {
@@ -245,11 +281,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
@@ -627,7 +660,11 @@ async function runTurnDriver(
 		const effort = entry?.efforts?.length ? toAgyEffort(options?.reasoning, entry.efforts) : undefined;
 		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;
+		// 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 ? context.systemPrompt : undefined;
+		const fullPrompt = buildFullPrompt(sysPrompt, digest, prompt);
 		try {
 			handle = await deps.driver.run({
 				cwd,
@@ -692,13 +729,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 +742,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. */

package/src/poller.ts

@@ -1,202 +0,0 @@
-// Read-only poller over an agy conversation SQLite DB.
-//
-// Opens ~/.gemini/antigravity-cli/conversations/<uuid>.db read-only and reads
-// newly-appended rows from the `steps` table on each poll. Uses node:sqlite
-// (built into Node >= 22.5; this machine is 26.5.0) so there is no native
-// dependency to ship. The caller drives a 250ms poll loop.
-//
-// Coalescing: agy's writer commits through its own connection, so we use
-// SQLite's `PRAGMA data_version` to skip the SELECT when nothing has changed
-// since the last poll (agy-acp pattern). data_version bumps on every commit
-// by another connection  -  cheap and exact.
-
-import fs from "node:fs";
-import { DatabaseSync } from "node:sqlite";
-import { toUint8 } from "./protobuf.js";
-
-/** A raw step row as read from the DB. payload is the undecoded step_payload
- *  BLOB; callers pass it to the protobuf extractor. */
-export interface Step {
-	idx: number;
-	stepType: number;
-	status: number;
-	payload: Uint8Array;
-}
-
-const SELECT_STEPS =
-	"SELECT idx, step_type, status, step_payload FROM steps WHERE idx > ? ORDER BY idx";
-const SELECT_STEP_AT =
-	"SELECT idx, step_type, status, step_payload FROM steps WHERE idx = ?";
-
-const HAS_STEPS =
-	"SELECT COUNT(*) > 0 AS present FROM sqlite_master WHERE type='table' AND name='steps'";
-
-/** Open the DB read-only. Returns null when the file doesn't exist yet or
- *  lacks a steps table (agy hasn't created/flushed it). Throws are swallowed
- *  so a transient lock or half-written file is retried on the next poll. */
-function openReadOnly(dbPath: string): DatabaseSync | null {
-	if (!fs.existsSync(dbPath)) return null;
-	try {
-		const db = new DatabaseSync(dbPath, { readOnly: true });
-		const row = db.prepare(HAS_STEPS).get() as { present?: number } | undefined;
-		if (!row?.present) {
-			db.close();
-			return null;
-		}
-		return db;
-	} catch {
-		return null;
-	}
-}
-
-/** A reusable read handle on one conversation's steps table.
- *
- * Keeps one DB connection + prepared statement open for the life of a turn,
- * so the poll loop isn't re-opening the file each tick. `poll()` returns only
- * rows newer than the last one seen, advancing an internal cursor.
- *
- * A row whose payload fails to materialize (torn read while agy is mid-write)
- * is dropped, not thrown  -  its idx is NOT advanced past, so it's retried on
- * the next poll once the write settles. (agy-acp database.ts pattern.) */
-export class ConversationPoller {
-
-	private db: DatabaseSync | null = null;
-	private selectStmt: ReturnType<DatabaseSync["prepare"]> | null = null;
-	private selectAtStmt: ReturnType<DatabaseSync["prepare"]> | null = null;
-	private dataVersionStmt: ReturnType<DatabaseSync["prepare"]> | null = null;
-	private lastDataVersion: number | null = null;
-	private _lastIdx: number;
-
-	constructor(
-		private readonly dbPath: string,
-		baseStepIdx = -1,
-	) {
-		this._lastIdx = baseStepIdx;
-		this.db = openReadOnly(dbPath);
-		if (this.db) {
-			this.selectStmt = this.db.prepare(SELECT_STEPS);
-			this.selectAtStmt = this.db.prepare(SELECT_STEP_AT);
-			this.dataVersionStmt = this.db.prepare("PRAGMA data_version");
-		}
-	}
-
-	/** True if the DB was openable at construction. False means agy hasn't
-	 *  created/flushed it yet  -  call tryOpen() on later polls. */
-	get isOpen(): boolean {
-		return this.db !== null;
-	}
-
-	/** The highest idx seen (or the base passed at construction). Persist this
-	 *  across turns so a resumed conversation only streams new steps. */
-	get lastIdx(): number {
-		return this._lastIdx;
-	}
-
-	/** Retry opening the DB if it wasn't ready at construction. Returns the
-	 *  new open state. Idempotent. */
-	tryOpen(): boolean {
-		if (this.db) return true;
-		this.db = openReadOnly(this.dbPath);
-		if (this.db) {
-			this.selectStmt = this.db.prepare(SELECT_STEPS);
-			this.selectAtStmt = this.db.prepare(SELECT_STEP_AT);
-			this.dataVersionStmt = this.db.prepare("PRAGMA data_version");
-			return true;
-		}
-		return false;
-	}
-
-	/** Returns true when another connection has committed since the last poll.
-	 *  When false, readNewSteps() and poll() are guaranteed to return [] and can
-	 *  be skipped. Call ONCE per tick: it advances the data_version cursor, so a
-	 *  second call in the same tick sees no change. Exposed so the runner can
-	 *  gate its in-place step re-read (readStepAt) behind the same check and
-	 *  avoid a redundant SELECT every idle tick while agy is thinking. */
-	hasChanged(): boolean {
-		if (!this.db || !this.dataVersionStmt) return true; // force a read on first poll
-		const row = this.dataVersionStmt.get() as { data_version?: number } | undefined;
-		const v = row?.data_version ?? 0;
-		if (this.lastDataVersion === null) {
-			this.lastDataVersion = v;
-			return true;
-		}
-		if (v === this.lastDataVersion) return false;
-		this.lastDataVersion = v;
-		return true;
-	}
-
-	/** Read new steps since the last call WITHOUT re-checking data_version.
-	 *  The caller gates this behind hasChanged() so the SELECT only fires when a
-	 *  commit actually landed. Returns [] when the DB isn't open or has no new
-	 *  rows. Advances the cursor past every successfully-read row. */
-	readNewSteps(): Step[] {
-		if (!this.db || !this.selectStmt) return [];
-		const rows = this.selectStmt.all(this._lastIdx) as Array<{
-			idx: number;
-			step_type: number;
-			status: number;
-			step_payload: unknown;
-		}>;
-		const out: Step[] = [];
-		let advanced = this._lastIdx;
-		for (const r of rows) {
-			try {
-				out.push({
-					idx: r.idx,
-					stepType: r.step_type,
-					status: r.status,
-					payload: toUint8(r.step_payload),
-				});
-				advanced = r.idx;
-			} catch {
-				// Torn read: drop this row, do not advance. Retried next poll.
-				break;
-			}
-		}
-		this._lastIdx = Math.max(this._lastIdx, advanced);
-		return out;
-	}
-
-	/** Convenience: hasChanged() + readNewSteps() in one call. Kept for the
-	 *  decode-db diagnostic and any caller that doesn't need the separate
-	 *  in-place re-read. */
-	poll(): Step[] {
-		return this.hasChanged() ? this.readNewSteps() : [];
-	}
-
-	/** Read a single step by idx without advancing the cursor. Used to re-check
-	 *  the last text/thinking step: agy extends the step it is currently writing
-	 *  in place (same idx, growing text), and poll() only returns idx > lastIdx. */
-	readStepAt(idx: number): Step | null {
-		if (!this.db || !this.selectAtStmt) return null;
-		let row;
-		try {
-			row = this.selectAtStmt.get(idx) as
-				| { idx: number; step_type: number; status: number; step_payload: unknown }
-				| undefined;
-		} catch {
-			return null;
-		}
-		if (!row) return null;
-		try {
-			return {
-				idx: row.idx,
-				stepType: row.step_type,
-				status: row.status,
-				payload: toUint8(row.step_payload),
-			};
-		} catch {
-			return null;
-		}
-	}
-
-	/** Release the DB handle. Safe to call multiple times. */
-	close(): void {
-		try {
-			this.db?.close();
-		} catch {
-			// already closed
-		}
-		this.db = null;
-	}
-}

package/src/protobuf.ts

@@ -1,184 +0,0 @@
-// Hand-rolled protobuf decoder for agy's `step_payload` blobs.
-//
-// agy writes per-conversation SQLite DBs at ~/.gemini/antigravity-cli/
-// conversations/<uuid>.db. The `steps.step_payload` column is a protobuf blob
-// with NO published schema. Field numbers below are load-bearing
-// reverse-engineered facts (cross-checked against the shindgew/agy-acp and
-// shubzkothekar/antigravity-acp decoders, plus real DB inspection on this
-// machine, agy v1.1.7).
-//
-// We hand-roll the varint walker instead of pulling @bufbuild/protobuf or
-// generating from .proto. The openab/agy-acp Rust port proves ~94 lines is
-// enough for text + tool name extraction. Unknown fields are skipped per
-// protobuf wire-format rules, so a future agy that adds fields won't break us.
-//
-// Layout we care about:
-//   step_payload:
-//     field 20 (submessage) = agentText   { 1: text }
-//     field  5 (submessage) = toolRun     { 4: toolCall { 2|9: name, 3: inputJson } }
-//     field 30 (submessage) = titleUpdate { 4: title }
-// (fuller map in decodeStepPayload  -  only the ones we stream to pi.)
-
-export type ByteSource = Uint8Array | ArrayBufferLike;
-
-/** Read a base-128 varint starting at offset `i`. Returns [value, nextOffset].
- *
- *  NOTE on precision: accumulation uses bitwise OR and shift, which are
- *  32-bit operations in JS. Values needing 5+ continuation bytes (>32 bits)
- *  are truncated, not decoded correctly. This is acceptable here because agy
- *  field numbers and payload lengths are always small (well under 2^32). The
- *  10-byte cap is a DoS guard (stop a corrupt blob spinning forever), not a
- *  correctness guarantee for the full 64-bit varint range. */
-export function readVarint(buf: Uint8Array, i: number): [number, number] {
-	let result = 0;
-	let shift = 0;
-	let offset = i;
-	// protobuf caps varints at 10 bytes (64-bit). Cap the loop so a corrupt
-	// blob can't spin forever.
-	for (let count = 0; count < 10; count++) {
-		if (offset >= buf.length) {
-			throw new RangeError(`varint at ${i} ran past end of buffer`);
-		}
-		const byte = buf[offset++];
-		result |= (byte & 0x7f) << shift;
-		if ((byte & 0x80) === 0) return [result >>> 0, offset];
-		shift += 7;
-	}
-	throw new RangeError(`varint at ${i} exceeded 10 bytes`);
-}
-
-/** A (fieldNumber, wireType, valueSlice) triple produced by walking one field.
- *  For length-delimited fields (wire 2), `bytes` is the field payload.
- *  For varints (wire 0), `varint` holds the value. */
-export interface Field {
-	field: number;
-	wire: number;
-	bytes: Uint8Array | null; // wire 2 payload (view into the source buffer)
-	varint: number | null; // wire 0 value
-}
-
-/** Walk every top-level field in a protobuf message. Returns the fields in
- *  order. Packed/repeated fields are not collapsed  -  callers see each
- *  occurrence. Unknown fields are included so the walker is reusable. */
-export function walkFields(buf: Uint8Array): Field[] {
-	const out: Field[] = [];
-	let i = 0;
-	while (i < buf.length) {
-		const [tag, afterTag] = readVarint(buf, i);
-		i = afterTag;
-		const field = tag >>> 3;
-		const wire = tag & 0x07;
-		if (wire === 0) {
-			// varint
-			const [val, after] = readVarint(buf, i);
-			i = after;
-			out.push({ field, wire, bytes: null, varint: val });
-		} else if (wire === 2) {
-			// length-delimited
-			const [len, afterLen] = readVarint(buf, i);
-			i = afterLen;
-			if (i + len > buf.length) {
-				throw new RangeError(`field ${field}: length ${len} runs past buffer end`);
-			}
-			// subarray is a VIEW into the same backing buffer (no copy). Safe here
-			// because the view is decoded and discarded within this poll; do NOT
-			// retain `Field.bytes` past the current call  -  the source buffer may
-			// be reused or collected differently than a retained slice expects.
-			out.push({ field, wire, bytes: buf.subarray(i, i + len), varint: null });
-			i += len;
-		} else if (wire === 5) {
-			// fixed32
-			out.push({ field, wire, bytes: null, varint: null });
-			i += 4;
-		} else if (wire === 1) {
-			// fixed64
-			out.push({ field, wire, bytes: null, varint: null });
-			i += 8;
-		} else {
-			// wire 3/4 (start/end group) are deprecated and agy never emits them.
-			// Throw rather than silently drop every field after this point  -  a
-			// corrupt byte that looks like a group delimiter should fail loudly so
-			// the caller (pollOnce) can drop the step and retry on the next poll.
-			throw new RangeError(`unexpected wire type ${wire} at field ${field}`);
-		}
-	}
-	return out;
-}
-
-/** Find the first length-delimited field with the given number, or null.
- *  Equivalent to agy-acp's readSubmessage + readMessage dispatch for one field. */
-export function getField(buf: Uint8Array, target: number): Uint8Array | null {
-	for (const f of walkFields(buf)) {
-		if (f.field === target && f.wire === 2 && f.bytes) return f.bytes;
-	}
-	return null;
-}
-
-/** Decode a UTF-8 slice to a string. Tolerant: invalid bytes become U+FFFD. */
-const utf8 = new TextDecoder("utf-8", { fatal: false });
-export function utf8String(bytes: Uint8Array): string {
-	return utf8.decode(bytes);
-}
-
-export interface AgentText {
-	text: string;
-}
-
-export interface ToolCallInfo {
-	/** Primary tool name (field 2 of toolCall). */
-	name: string;
-	/** Raw input JSON string (field 3 of toolCall), unparsed. */
-	inputJson: string;
-}
-
-/** Extract agent text from a step_payload: field 20 -> field 1.
- *  Returns null if the payload has no agentText field. */
-export function extractAgentText(payload: Uint8Array): AgentText | null {
-	const agentText = getField(payload, 20);
-	if (!agentText) return null;
-	const text = getField(agentText, 1);
-	if (!text) return null;
-	return { text: utf8String(text) };
-}
-
-/** Extract tool-call info from a step_payload: field 5 (toolRun) -> field 4
- *  (toolCall) -> fields 2/9 (name) and 3 (inputJson). Returns null if the
- *  payload has no toolRun.toolCall. */
-export function extractToolCall(payload: Uint8Array): ToolCallInfo | null {
-	const toolRun = getField(payload, 5);
-	if (!toolRun) return null;
-	const toolCall = getField(toolRun, 4);
-	if (!toolCall) return null;
-	// Name lives at field 2 (namePrimary) or field 9 (nameSecondary).
-	let name = "";
-	let inputJson = "";
-	for (const f of walkFields(toolCall)) {
-		if (f.field === 2 && f.bytes) name ||= utf8String(f.bytes);
-		else if (f.field === 9 && f.bytes && !name) name = utf8String(f.bytes);
-		else if (f.field === 3 && f.bytes) inputJson ||= utf8String(f.bytes);
-	}
-	if (!name && !inputJson) return null;
-	return { name, inputJson };
-}
-
-/** Extract the title from a step_payload: field 30 (titleUpdate) -> field 4.
- *  Returns null when absent. */
-export function extractTitle(payload: Uint8Array): string | null {
-	const titleUpdate = getField(payload, 30);
-	if (!titleUpdate) return null;
-	const title = getField(titleUpdate, 4);
-	return title ? utf8String(title) : null;
-}
-
-/** Decode a Buffer/Uint8Array-shaped column value to a clean Uint8Array.
- *  node:sqlite returns Uint8Array for BLOB; better-sqlite3 returns Buffer. */
-export function toUint8(v: unknown): Uint8Array {
-	if (v instanceof Uint8Array) return v;
-	// Buffer is a Uint8Array subclass; instanceof covers it but be defensive.
-	if (ArrayBuffer.isView(v)) {
-		const view = v as Uint8Array;
-		return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
-	}
-	if (v == null) return new Uint8Array(0);
-	return new Uint8Array(0);
-}