From 4994f6c5bf1f5300f3c7c1940adf23c8aeac5324 Mon Sep 17 00:00:00 2001 From: LVC-Chakresh Date: Sun, 22 Nov 2026 18:40:41 +0530 Subject: [PATCH] fix(antigravity): bound silent post-settle background command holds A run_command that outlives session/prompt holds the turn open. If its terminal update never reaches T3, the thread stays in Working forever with an empty pending list. Add an optional postSettleBackgroundHoldTimeout to the ACP flavor and opt Antigravity into a 30-minute bound, after which the settled turn finalizes instead of hanging. --- .../Adapters/AntigravityAdapterV2.test.ts | 34 +++++++++++++++++++ .../Adapters/AntigravityAdapterV2.ts | 4 +++ packages/provider-acp/src/server/adapter.ts | 34 +++++++++++++++++++ 3 files changed, 72 insertions(+) diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts index fca472c6c433e..a3dbe41b0ccd1 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts @@ -1349,6 +1349,40 @@ describe("AntigravityAdapterV2 work after the prompt ends", () => { }).pipe(Effect.provide(layerSession)), ); + // A command whose terminal update never arrives would hold the run in Working forever with + // an empty pending list and a finished reply above Stop. + it.effect("settles a silent background command after the post-settle hold timeout", () => + Effect.gen(function* () { + const { command, offers, startTurn, until, throughPromptSettled } = + yield* openSessionWithRunningCommand({ WaitMsBeforeAsync: 10000 }); + yield* startTurn(1, false); + const prompt = yield* throughPromptSettled; + + // A running tool keeps the inactivity watchdog re-armed, so 20 silent minutes do not + // settle this run on their own. + yield* TestClock.adjust("20 minutes"); + yield* TestClock.adjust("11 minutes"); + const run = yield* until((event) => event.type === "turn.terminal"); + const terminal = run.at(-1); + assert.equal( + terminal?.type === "turn.terminal" && terminal.status, + "completed", + "the bounded hold finalizes the turn instead of leaving it running forever", + ); + assert.equal(terminal?.type === "turn.terminal" && terminal.failure, null); + assert.lengthOf(offers, 0, "a silent command produces no wake on its own"); + const commandItem = [...prompt, ...run].findLast( + (event) => + event.type === "turn_item.updated" && + event.turnItem.nativeItemRef?.nativeId === command.toolCallId, + ); + assert.isTrue( + commandItem?.type === "turn_item.updated" && commandItem.turnItem.status === "completed", + "the silent command is no longer left as live activity on a settled run", + ); + }).pipe(Effect.provide(layerSession)), + ); + // Command 2 finishes during reply 1; agy dequeues command 2 after reply 1's usage_update and // needs >3 s before streaming reply 2. Wait for reply 2 (bounded by the 2-minute quiet limit), // but still finalize at 3 s when both commands were batched into reply 1. diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts index 3f629c813b615..7c0c2fd65ab0c 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts @@ -244,6 +244,10 @@ export function makeAntigravityAcpAdapterFlavor( wakeOnDetachedRequest: true, replyEndsWithUsageUpdate: true, toolOutlivesPrompt: antigravityToolOutlivesPrompt, + // agy sometimes loses the terminal update or wake for a background command. Do not hold + // the turn in Working forever on a silent command; a 30-minute bound still leaves long + // runs room, and the command remains visible as pending background work after settlement. + postSettleBackgroundHoldTimeout: "30 minutes", // session/cancel ends the agent's running commands, so only Stop sends it once the prompt // has ended. A message sent while a command runs leaves the command alone. preserveRuntimeOnSettledInterrupt: true, diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index 21fe311588906..ec878856f0920 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -637,6 +637,11 @@ export interface AcpAdapterV2Flavor { * tool ends. With `deferFinalizeForBackgroundWork`, the turn stays open until then. */ readonly toolOutlivesPrompt?: (toolCall: AcpToolCallState) => boolean; + /** + * Bound a settled turn held open only by an outliving tool; finalize after this quiet period + * so a command that never reports back cannot leave the thread in Working forever. + */ + readonly postSettleBackgroundHoldTimeout?: Duration.Input; readonly isProviderWakeNotification?: ( notification: EffectAcpSchema.SessionNotification, ) => boolean; @@ -8835,6 +8840,33 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( yield* options.testHooks?.onDeferredFinalizeScheduled?.(debounce) ?? Effect.void; }); + /** + * Bound a settled turn held only by an outliving tool that never reports back, so the + * run cannot stay in Working forever with no visible background work. + */ + const schedulePostSettleHoldExpiry = Effect.fn("AcpAdapterV2.schedulePostSettleHoldExpiry")( + function* (context: ActiveAcpTurn) { + const timeout = flavor.postSettleBackgroundHoldTimeout; + if (timeout === undefined) return; + if (!context.promptSettled || context.finalized) return; + if (!hasDeferredBackgroundWork(context)) return; + yield* Effect.gen(function* () { + yield* Effect.sleep(timeout); + if (context.finalized || !context.promptSettled) return; + if (!hasDeferredBackgroundWork(context)) return; + // Only an outliving tool gets bounded here. Queued wakes, hydration and detached + // subagents still have their own settlement paths. + const heldCommand = [...context.tools.values()].some( + (tool) => + toolStatus(tool.status) === "running" && + flavor.toolOutlivesPrompt?.(tool) === true, + ); + if (!heldCommand) return; + yield* finalizeTurn(context, context.promptSettledStatus ?? "completed"); + }).pipe(Effect.forkIn(sessionScope), Effect.asVoid); + }, + ); + const promptInactivityPaused = Effect.fn("AcpAdapterV2.promptInactivityPaused")(function* ( context: ActiveAcpTurn, ) { @@ -9265,6 +9297,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( if (context.finalized) return; if (deferredBackgroundWork || pendingReply) { yield* closeTextStreams(context); + if (deferredBackgroundWork) yield* schedulePostSettleHoldExpiry(context); if (pendingReply) { context.replyOpen = true; yield* scheduleDeferredFinalize(context); @@ -9665,6 +9698,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( return; } if (!context.finalized) { + yield* schedulePostSettleHoldExpiry(context); if (hasDeferredBackgroundWork(context)) { yield* rearmDeferredFinalize(context); } else {