@estebanforge/pi-antigravity-bridge 1.7.6 → 1.7.7

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.7.7] - 2026-09-30
+
+### Fixed
+
+- **A recreated agy conversation no longer starves the context digest.** When `session/load` failed, the ACP engine silently fell back to a fresh conversation (`session-load-failed-creating-fresh`), but the end-of-turn write-back kept advancing the stored watermark, so the new conversation never received the backlog: the digest delivered only the current prompt for the rest of the session, and the G10 system-prompt gate stayed closed too, because the surviving record always carried a conversation id. The write-back now compares the outcome's conversation id against the one stored before the turn and drops the record on a mismatch: the next turn re-delivers the full digest backlog and re-arms the system prompt, on both engines, with no protocol change. `SessionStore` gained a per-key `delete()` whose removal persists exactly once (the removal set prunes after a durable write, so a later persist can never destroy a record another process wrote in the meantime), preserving the multi-process merge invariant.
+- **Failed and aborted turns no longer advance the digest watermark.** The write-back recorded `lastMessageCount` on any turn that reported a conversation id, ERROR and aborts included. Whether the prompt actually landed in the conversation's history is not observable from the provider, and advancing on that ambiguity starves the digest of the missed turn (the same failure class as the recreation bug above). The watermark now advances only on a clean, non-aborted turn; failed, aborted, and unknown outcomes leave the pre-turn record untouched, so the next digest re-delivers the missed turn bounded by the existing `maxChars` cap (default 8000) instead of losing it. With the digest off (the default) neither fix changes observable behavior.
+- **Regression coverage pins both behaviors at the provider layer.** Eight new tests: record drop, backlog re-delivery, and system-prompt re-arm across the id swap; unchanged watermark across failed, aborted, and unknown outcomes on the same conversation; and the session-store delete and multi-process semantics, including a reclaimed key surviving an unrelated persist from another process. 1329 tests, tsc clean.
+
+Thanks @fishfuuu for the report (#1).
+
 ## [1.7.6] - 2026-09-28
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.7.6",
+  "version": "1.7.7",
   "description": "Gemini provider for Pi on the Antigravity ACP server (official Google ACP) or the stream-json agy CLI. antigravity/* models in Pi's /model picker, no-patch MCP bridge: agy runs Pi's tools. ToS safe to use.",
   "keywords": [
     "pi-package",

package/src/provider.ts

@@ -1283,11 +1283,28 @@ async function runTurnDriver(
 
 	const outcome = await handle.outcome;
 	if (outcome.conversationId) {
-		store.set(key, {
-			conversationId: outcome.conversationId,
-			lastStepIdx: -1,
-			lastMessageCount: messageCount,
-		});
+		// A different id than the stored one means the driver recreated the
+		// conversation under us (ACP session-load fallback, stream-json CLI
+		// dropping a stale --conversation). The recreated conversation has seen
+		// NOTHING, so the record's watermark would starve the digest forever and
+		// its bound id would keep the sysPrompt gate closed. Drop the record:
+		// the next turn resumes from watermark 0 with the gate re-armed (issue
+		// #1). The recreation turn itself is past the gate, so it is the
+		// documented residual; recovery starts on the next turn.
+		if (existing?.conversationId && outcome.conversationId !== existing.conversationId) {
+			store.delete(key);
+		} else if (outcome.status === "OK" && !outcome.aborted) {
+			store.set(key, {
+				conversationId: outcome.conversationId,
+				lastStepIdx: -1,
+				lastMessageCount: messageCount,
+			});
+		}
+		// A failed or aborted turn on the SAME conversation keeps the pre-turn
+		// record: whether the prompt actually landed in agy's DB is not
+		// observable from here. Keeping the watermark re-delivers the missed
+		// turn in the next digest (bounded by the digest cap); advancing it
+		// would starve the conversation of context it may never have received.
 	}
 	if (outcome.aborted) {
 		finalize(stream, blocks, "aborted", "Operation aborted");

package/src/sessions.ts

@@ -68,6 +68,7 @@ export class SessionStore {
 	private readonly path: string;
 	private cache: StoreMap = {};
 	private readonly dirty = new Set<string>();
+	private readonly removed = new Set<string>();
 	private writeChain: Promise<void> = Promise.resolve();
 
 	constructor(storePath: string = STORE_PATH) {
@@ -100,6 +101,7 @@ export class SessionStore {
 	set(key: string, session: AgySession): void {
 		this.cache[key] = session;
 		this.dirty.add(key);
+		this.removed.delete(key);
 		// Serialize through a chain so concurrent sets don't interleave renames.
 		this.writeChain = this.writeChain
 			.then(() => this.persist())
@@ -108,6 +110,22 @@ export class SessionStore {
 			});
 	}
 
+	/** Drop one session binding and persist the deletion. Used when the driver
+	 *  recreated the conversation under us: the record's watermark claims
+	 *  history the new conversation never saw, and its bound id keeps the
+	 *  sysPrompt gate closed. Dropping resets the watermark to 0 AND re-arms
+	 *  the gate on the next turn (issue #1). The write is queued. */
+	delete(key: string): void {
+		delete this.cache[key];
+		this.dirty.delete(key);
+		this.removed.add(key);
+		this.writeChain = this.writeChain
+			.then(() => this.persist())
+			.catch(() => {
+				/* swallow; next write retries */
+			});
+	}
+
 	private async persist(): Promise<void> {
 		const dir = path.dirname(this.path);
 		await fs.promises.mkdir(dir, { recursive: true });
@@ -126,6 +144,9 @@ export class SessionStore {
 		for (const key of this.dirty) {
 			merged[key] = this.cache[key];
 		}
+		for (const key of this.removed) {
+			delete merged[key];
+		}
 
 		const tmp = `${this.path}.${process.pid}.tmp`;
 		await fs.promises.writeFile(tmp, JSON.stringify(merged, null, 2) + "\n", {
@@ -133,6 +154,10 @@ export class SessionStore {
 		});
 		await fs.promises.rename(tmp, this.path);
 		this.dirty.clear();
+		// Mirror dirty: once the deletion is durable, stop re-asserting it. A
+		// later unrelated persist must not destroy a record another process
+		// wrote for that key after our delete landed.
+		this.removed.clear();
 	}
 
 	/** Wipe all session bindings (forces fresh agy conversations on every
@@ -140,6 +165,7 @@ export class SessionStore {
 	clear(): void {
 		this.cache = {};
 		this.dirty.clear();
+		this.removed.clear();
 		this.writeChain = this.writeChain
 			.then(async () => {
 				const tmp = `${this.path}.${process.pid}.tmp`;