Skip to content

Antigravity 1.5.7 through 1.5.11 background commands mark the turn done early and T3 drops the wakeup reply #36105

Closed

Description

@mahmoodnizamani94-png

After managed Antigravity installs migrated to the native CLI 1.5.7 in #35487, any turn that launches a background shell command and pauses to wait for it gets marked completed in T3 Code immediately, and subsequent work on wakeup hangs until the user sends another message.

With the legacy 1.4.5 ACP server agy_acp_server.par, waiting across finite background commands stayed inside the open turn because receive_steps() kept streaming updates and skipped closing unfinished background execution tools until no background shell command remained active. Issue #16442 already covers the infinite daemon case.

On CLI 1.5.7, two behaviors combine to break finite background tasks even when the thread is set to full access.

First, as soon as the model pauses to wait on a background command, 1.5.7 closes its step stream, logging Stream goroutine exited for <id>, sending completion signal in server.go, and resolves session/prompt cleanly. Because T3's Antigravity adapter sets subagentsIdleOnTurnCompletion: true and does not defer turn finalization for background commands or reopen a continuation prompt when work resumes, T3 marks the run finished right away and shows the composer as idle.

Second, when the background command finishes later and wakes the agent internally, 1.5.7 has no attached session/prompt request open. It emits zero session/update notifications back to T3, so allowed read calls run silently with nothing visible in the thread. Then, because antigravityCliSessionMode maps yolo and auto_edit to default since the CLI rejects those modes, the first edit or shell command on wakeup clears 1.5.7's internal safety check sir_flash_lite with triggered=false and blocks indefinitely waiting for an ACP tool confirmation that can only be answered inside an active session/prompt call.

In a trace captured on 0.1.10-nightly.20261113.4630 with CLI 1.5.7 and full access enabled, session/prompt succeeded right as server.go exited the stream goroutine while background tests were still running. About 70 seconds later the agent woke internally, ran an allowed read check silently, cleared sir_flash_lite on an edit_file step, and sat frozen for over 14 minutes with no ACP output until a manual user message started a new session/prompt. Roughly 0.3 seconds after that new session/prompt arrived, server.go logged Tool confirmation ... approved=true on the stalled step and resumed.

Related issues #16442 and #30082 plus open PRs #28450, #30083, and #35073 track passive UI turn holding and missing continuation turns. For CLI 1.5.7 specifically, passively holding the run open without keeping or reattaching a session/prompt request will still drop wakeup updates and leave woken edits and commands stuck on confirmation while sessions are forced into default mode.

Activity

  1. Fonsi479 commented on Nov 14, 2026

    @Fonsi479

    Additional confirmation on Antigravity CLI 1.5.8 (custom binary, agy acp), with T3 Code 0.1.9 stable on macOS arm64. The T3 checkout is a localization-only downstream based on upstream 24e77473ecf4; the same missing background-work hooks are also present in the current upstream Antigravity adapter.

    The distinction between the command stopping and the ACP stream stopping matters here: the command was still running after T3 had completed the run.

    Sanitized observations

    Times below are UTC on 2026-11-14, from one conversation's provider log, read-only T3 database inspection, and OS process inspection:

    Time Observation
    06:15:52 A finite test command is reported as an in-progress execute tool.
    06:16:13.642 The native log says Stream goroutine exited for <conversation>, sending completion signal. T3 records session/prompt as successful and completes both the run and the unfinished command item, without an exit code or command output. The provider thread is idle with pendingBackgroundTasks: [].
    06:20:24 The Python test process is still alive, with an elapsed time of 4m22s. This is not evidence that the test passed or that the process was making progress.
    06:21:32 onward The native conversation database contains further steps that are absent from the T3 timeline. A subsequent native command waits for confirmation.
    06:30:26.815 A manual follow-up starts another session/prompt.
    06:30:26.843–.850 T3 finally receives the original test's output (exit code 1), and the native log records approval of the previously stalled command.

    I also tested the suggestion of reattaching with an empty prompt in a separate, newly created session, without a model request. CLI 1.5.8 rejects:

    {"method":"session/prompt","params":{"sessionId":"<probe-session>","prompt":[]}}

    with:

    {"code":-32602,"message":"Empty prompt"}

    Adapter-side mitigation tested locally

    I tested the existing background-work approach, consistent with #35073:

    extractBackgroundTaskId: (toolCall) =>
      toolCall.kind === "execute" ? toolCall.toolCallId : undefined,
    deferFinalizeForBackgroundWork: true,
    enablePostSettleContinuation: true,

    The shared adapter must also exclude subagents from deferred-settlement blocking when subagentsIdleOnTurnCompletion === true; otherwise Antigravity's successfully launched native subagents keep the turn open forever.

    A spawned ACP mock through the real Antigravity flavor verifies:

    • an in-progress command is not fabricated as completed when the prompt returns;
    • delayed success and failure update the command correctly;
    • delayed assistant output offers a continuation and is ingested without submitting the original prompt again;
    • an explicit Stop does not allow subsequent frames to wake the stopped run;
    • a native subagent batch does not deadlock command settlement.

    Local validation: 154 tests passed across the Antigravity adapter/protocol and shared ACP adapter suites; check:changed passed formatting, lint, knip, GraphQL validation and typechecking of 14 packages; the server/web bundle build passed.

    This is only a mitigation for the T3-side state/late-frame handling. It does not establish an end-to-end fix for CLI 1.5.8 when no notifications are emitted after the native stream closes. The patched adapter was tested with scripted ACP events, not a live patched-provider run. The installed app was left unchanged. A complete fix still needs a supported way to keep or reattach the native event stream without requiring a user nudge or replaying a state-changing command.

  2. Fonsi479 commented on Nov 14, 2026

    @Fonsi479

    Follow-up with a live CLI 1.5.8 reproduction, captured on 2026-11-14. This also confirms the limitation noted in my earlier comment: holding T3's run open does not restore a native stream that has already closed.

    Environment: macOS arm64 host; T3 Code desktop host with an iPhone client; external official agy acp 1.5.8; model selection gemini-pro-orchestrator (Gemini 4 Carbon). The installed ASAR identifies itself as 0.1.9-zh.2, commit 620970e8a23f, a downstream build based on stable 0.1.9. I verified the installed bundle contains extractBackgroundTaskId for execute tools, deferFinalizeForBackgroundWork: true, and enablePostSettleContinuation: true. This is not a clean-current-upstream reproduction.

    Timeline from the same conversation

    All times below are UTC; identifiers and private paths are omitted.

    Time Evidence
    08:22:28.854 T3 provider log: session/prompt started.
    08:40–08:41 T3 received the assistant warning The stream was interrupted. Please continue the task you were working on. The task subsequently continued; the entire 56-minute request was not idle.
    09:18:07 A finite Swift test followed by a release build started as a native background command. T3 projected the execute item as running.
    09:18:38.840 T3 provider log: session/prompt succeeded. The last T3 assistant message said it was waiting for the test/build result.
    09:19:39 The native Antigravity transcript records the background command finishing with exit code 0, and a system completion notice.
    09:19:39 onward The native transcript records the model proceeding to a batch of file edits. These subsequent steps do not appear in T3's timeline. The native log gets through a safety evaluation on an edit, but the corresponding confirmation/completion is absent in the inspected tail.
    After 09:35 Read-only T3 DB inspection still shows the original provider turn status: running, completedAt: null, and that command item status: running with its last update at 09:18:10.718. The user sees an ongoing thinking/working state with no continuation.

    Expected / actual

    Once the finite command finishes, T3 should receive its terminal result and the subsequent continuation, including the permission exchange required by the native CLI. Instead, the native transcript advances while the T3 state remains frozen.

    This supports the same stream-lifecycle problem reported here on 1.5.7, now on 1.5.8. In particular, a passive deferred-settlement mitigation leaves a stale running item when the CLI emits no further ACP updates after session/prompt resolves. A successful session/prompt response alone is insufficient evidence that native work has settled.

    Reproduction outline: use this provider/model for a coding task that runs a finite command with WaitMsBeforeAsync, let the model end its current reply while waiting, and compare the native background completion/transcript against T3's projected command and turn. The failure was observed in a real work session; no new synthetic inference test or repair was performed for this follow-up. Raw transcripts are not attached because they contain private workspace information.

  3. mahmoodnizamani94-png commented on Nov 14, 2026

    @mahmoodnizamani94-png
    Author

    We hit this exact 1.5.8 failure on Linux across 0.1.9 and 0.1.10-nightly and traced the surrounding session failures to four concrete places in session setup, shared version state, keyring env vars, and the inactivity timer.

    In packages/provider-acp/src/server/AcpSessionRuntime.ts, AcpSessionRuntime.setMode calls setConfigOption(modeConfigOption?.id ?? "mode", modeId) without { allowUnlistedValue: true }. On agy 1.5.8 acp builds where configOptions only lists agent, ask, and plan under mode, passing "yolo" in full access fails client-side validation inside validateConfigOptionValue before T3 sends any session/set_config_option RPC. Right above setModel in that same file, setConfigOption already accepts { allowUnlistedValue: true }, and applyAntigravityAcpModelSelection in apps/server/src/provider/acp/AntigravityAcpSupport.ts already passes it so the binary validates unlisted values itself.

    Having 0.1.9 and 0.1.10-nightly on the same machine also breaks ~/.t3/tools/antigravity-acp in both directions. Once 0.1.10-nightly writes 1.5.8 with harness: null into active.json and release.json, 0.1.9 fails in AntigravityInstallation.completedRelease and AntigravityInstallation.resolve in apps/server/src/provider/AntigravityInstallation.ts with Could not read the Antigravity installation because 0.1.9 only accepts agy_acp_server.par paired with localharness_external and spawns ["acp"] without --gemini-dir or --app-data-dir. Going back the other way, once 1.5.8 touches conversations/<sessionId>.db, it writes context_summary into executor_metadata, and loading that conversation on 1.4.5 fails right away with pre-invocation hook "context_summary" not registered.

    Two Linux runtime details explain the false sign-outs and mid-turn kills that show up alongside this. antigravityEnvironment in apps/server/src/provider/antigravityAuthSupport.ts passes GNOME_KEYRING_CONTROL and DBUS_SESSION_BUS_ADDRESS into agy, so Electron safeStorage stores OAuth tokens in GNOME Keyring instead of ~/.gemini/oauth_creds.json where standalone 1.4.5 .par expects them. And the 15-minute promptInactivityTimeout in AcpAdapterV2.watchPromptInactivity in packages/provider-acp/src/server/adapter.ts checks Clock.currentTimeMillis backed by wall-clock Date.now(). Across S3 laptop sleep, Date.now() jumps 17 minutes while performance.now() only advances 2 minutes of awake time, so retireInactivePrompt fires the second the machine wakes up and kills live turns.

  4. davisonio commented on Nov 15, 2026

    @davisonio
    Contributor

    Still reproduces on Antigravity CLI 1.5.9 (T3 Code 0.1.10-nightly.20261115.4723, macOS arm64), and it's visible without T3 in the loop. With a bare ACP client (initialize, authenticate, session/new, session/set_mode yolo (rejected with "Unknown mode: yolo", so the session stayed in default mode), session/set_config_option for the model, then one session/prompt, permission auto-approved, Gemini 3.8 Flash low), I asked the model to run_command sleep 40; echo CAPTURE_DONE with WaitMsBeforeAsync: 500 and end its turn:

    • tool_call for the command arrives as in_progress (then pending, the permission request, then in_progress again).
    • session/prompt resolves with stopReason: end_turn about 3 s after the command started. The command is still running and gets no further tool_call_update.
    • About 40 s after the command started, the native transcript records the task-finished system message and the model's reply. The client received no messages of any kind (stdout or stderr) in a 100 s listen window after end_turn.

    In this run, after end_turn the CLI didn't report the background task's completion or the wake-up turn over ACP. Client-side changes can stop T3 from marking the command completed (#16442), but showing the wake-up would need the CLI to send it, or T3 to read it from the native transcript on disk.

  5. ryush00 commented on Nov 15, 2026

    @ryush00
    Contributor

    Adding a live CLI 1.5.9 trace from a real Full access session (0.1.10-nightly.20261115.4736, macOS arm64, gemini-4-carbon) where the post-wakeup turn invokes run_command (complementing @davisonio's 1.5.9 repro where the woken turn only emitted text), plus one CLI flag detail from the 1.5.9 binary that may help with the confirmation half of the fix.

    1. Live 1.5.9 wakeup tool-confirmation stall (timestamps in UTC)

    Correlating transcript.jsonl, acp-server-*.log, and T3's events.<threadId>.log (IDs and private paths sanitized):

    Time (UTC) Source Observation
    20:11:54 transcript.jsonl run_command exceeds WaitMsBeforeAsync and moves to background task <conv-id>/task-298.
    20:12:21 transcript.jsonl Planner replies that it will finish after the build completes and stops calling tools.
    20:12:29.145 acp-server.log / T3 log server.go:1323] Stream goroutine exited for <conv-id>, sending completion signal. T3 records session/prompt succeeded at 20:12:29.147 and marks the run completed at 20:12:29.168.
    20:14:57.580 transcript.jsonl / acp-server.log task-298 finishes; internal <SYSTEM_MESSAGE> wakes the planner (step 302). monitoring.go:409 logs [jetski_mode_default policy_guardian sonar_skip_tags]. Planner calls run_command (step 303/304). Zero ACP frames are emitted to T3.
    20:15:11.143 – 20:15:16.726 acp-server.log agy_tool_safety (triggered=true) → sir_flash_lite (triggered=true) → severe_internal_risks_agy finishes with triggered=false (benign authorized step). Execution then stalls completely—no Tool confirmation is logged while no session/prompt is active.
    20:15:33.524 acp-server.log / T3 log Manual user follow-up sends a new session/prompt → server.go:988] ACP Request received: session/prompt → server.go:1260] Starting conversation update stream for <conv-id>.
    20:15:33.536 (+12 ms) acp-server.log server.go:2738] Tool confirmation for conversation <conv-id> step 304 (type=*gemini_coder_go_proto.Step_Generic approved=true) fires immediately and the stalled command runs to completion.

    In a second Full access session on the same build, a background CI check (task-529) woke the planner at 18:24:11Z (step 531–532), and the woken run_command stayed frozen for 1h 07m until a manual user prompt arrived at 19:31:05Z.

    2. Note on 1.5.9 CLI flags vs. stream lifecycle

    Inspecting antigravity acp --help on the managed 1.5.9 binary shows an explicit flag on the acp subcommand:

    --dangerously-skip-permissions    Auto-approve all tool permission requests
    

    (Per the embedded 1.5.x release notes in the binary, --dangerously-skip-permissions auto-approves tool permissions without prompting while still enforcing the system command denylist and keeping /plan artifact review gated.)

    That still leaves the two halves distinct on 1.5.x:

    1. Unblocking woken tool calls: full-access sessions forced into default via antigravityCliSessionMode block at Tool confirmation whenever no session/prompt is open (whereas auto can use native automatic review when advertised, cf. fix(antigravity): offer Auto permission mode when agy ACP advertises it #37092, or full-access could spawn agy acp with --dangerously-skip-permissions and recycle the runtime if policy drops below full-access).
    2. Surfacing woken work to T3: Because Starting conversation update stream for <id> in server.go only attaches for the lifetime of an active session/prompt, 1.5.9 still emits zero session/update notifications after end_turn—so T3 would still need to watch/reconcile post-prompt steps from conversations/<sessionId>.db / transcript.jsonl (similar to AntigravityTurnOutcome / AntigravityChildWork) or trigger a continuation prompt once background tasks settle.
  6. KevinXC5 commented on Nov 16, 2026

    @KevinXC5

    Confirming this still reproduces on today's latest Nightly build with CLI 1.5.9.

    • Environment: macOS arm64, T3 Code 0.1.10-nightly.20261116.4761, agy 1.5.9 (full-access mode).
    • Bundle check: Inspecting the installed app.asar (apps/server/dist/server-uc3wLehn.mjs), makeAntigravityAdapterV2 passes continuationRequests to makeAcpAdapterV2, but makeAntigravityAcpAdapterFlavor still does not set enablePostSettleContinuation: true or deferFinalizeForBackgroundWork: true / extractBackgroundTaskId.

    Sanitized Timeline (UTC)

    Time (UTC) Source Observation
    02:39:59.093 T3 provider log session/prompt started; agent launches a background test command (WaitMsBeforeAsync: 10000) and replies that it is waiting for completion.
    02:40:16.883 T3 provider log / UI session/prompt resolves (succeeded) and T3 marks the run completed, dropping out of Working state.
    02:44:58 Native transcript.jsonl Background task exits and wakes the agent with <SYSTEM_MESSAGE>; the woken turn emits text and starts a find command at 02:45:07 (normally ~0.009s).
    02:40:16 – 02:47:05 T3 server.trace.ndjson Zero antigravityAuthSupport.splitStdoutLines / handleStdoutLine spans and zero thread events; the woken find command stays blocked.
    02:47:05.400 – .415 T3 trace & provider log User sends a follow-up message, starting a new session/prompt.
    02:47:05.445 – .547 T3 server.trace.ndjson & projection 45ms after the new session/prompt, splitStdoutLines receives the buffered output; the 02:44:58 wakeup text, the stalled find completion (Completed At: 02:47:05), and the original background command's command_execution item all flush into the new run (ordinal: 2).
  7. samwang0041-star commented on Nov 16, 2026

    @samwang0041-star

    Confirming this exact 1.5.9 stream-lifecycle and wakeup behavior also affects Antigravity's built-in /swarm workflow (related to #30082 and #36475, which was closed as a duplicate of #30082), and noting one /swarm-specific gap relevant to #30083 / #37489.

    • Environment: macOS arm64, T3 Code 0.1.10-nightly.20261116.4774 (16695c812fff), managed Antigravity ACP Server 1.5.9, model gemini-pro-orchestrator, full-access runtime mode.

    Sanitized Timeline (UTC, 2026-11-16)

    Time (UTC) Source Observation
    12:00:04.887 T3 provider log session/prompt started for /swarm <task>. Coordinator added 4 internal swarm members (2 workers, 1 verifier, monitor) and ended turn 1 (12:11:34.599).
    12:15:17.413 T3 provider log User follow-up started session/prompt (run 2).
    12:16:26.966 T3 thread items Coordinator called swarm_wait{mentions_only: false, since: 4} (whose native schema states it immediately ends the turn to park).
    12:16:26.969 acp-server.log server.go:1323] Stream goroutine exited for <conv-id>, sending completion signal.
    12:16:26.970 T3 provider log / UI session/prompt resolved succeeded; T3 finalized the run as completed at 12:16:26.991 and dropped out of Working state.
    12:16:27 – 12:44:25 acp-server.log vs T3 28 minutes of zero ACP events / UI updates in T3 Code (no working indicator, no board progress, no completion notification). Internally, workers posted board items #5–#8, monitor ticked every ~3 minutes (12:34:45, 12:37:43, 12:40:46, 12:43:48), and at 12:30:06 (sir_flash_lite log) a worker posted that write_file/edit_file and command permissions hit timeouts despite the parent T3 thread being full-access.
    12:44:25.238 T3 provider log Only after a manual user follow-up opened a new session/prompt did the coordinator call read_board and surface #5–#8 (including the worker's Permission prompt timeout on run_command and edit_file).

    Why /swarm is an additional edge case beyond #30083 and #37489

    1. Swarm tools are not matched by Run start_subagent / Run invoke_subagent or run_command: /swarm launches internal swarm worker conversations via Antigravity's built-in swarm / swarm_wait / post_message / read_board tools (and open_board), so neither ANTIGRAVITY_SUBAGENT_TITLES nor background run_command tracking (including fix(antigravity): wait for background command and subagent results #37489) keeps the turn aware that a swarm is still active after swarm_wait closes session/prompt.
    2. No post-settle session/update notifications on 1.5.9: As confirmed in earlier comments here, once server.go exits the stream goroutine after swarm_wait, 1.5.9 emits zero session/update frames for internal board posts or coordinator wakeups, so enablePostSettleContinuation: true alone (fix(server): harden Antigravity continuation and checkpoint recovery #30083) would not have an ACP update to wake on.
    3. Internal worker permission timeouts even in full-access: Because swarm workers run in internal non-root conversations with no active session/prompt approval bridge to T3 (and sessions are forced to default mode), worker edits/commands silently time out on permission prompts instead of surfacing to the user or auto-approving.
  8. furkansandal commented on Nov 16, 2026

    @furkansandal

    Confirming this still reproduces on today's latest Nightly build with CLI 1.5.9.

  9. R-Goc commented on Nov 16, 2026

    @R-Goc

    Confirming this also reproduces on Windows with the nightly build and CLI 1.5.9.

  10. KevinXC5 commented on Nov 17, 2026

    @KevinXC5

    Update: re-tested today with Antigravity CLI 1.5.10 + T3 Code 0.1.11-nightly.20261117.4814 (macOS arm64, full-access mode).

    agy 1.5.10 explicitly fixed the CLI side:

    Fixed agy acp holding back what the agent did after a turn ended: when a background task or subagent finishes and wakes the agent, its replies, tool calls, and permission requests now reach the editor right away instead of at your next prompt...

    With agy 1.5.10, the CLI does now flush post-end_turn stdout updates immediately when the background command wakes the agent, but T3 Code still silently drops them because AntigravityAdapterV2 has neither t3_background_wait (#37489) nor post-settle continuation enabled (#37485 / #30083).

    Sanitized Timeline (UTC)

    Time (UTC) Source Observation
    07:46:16.819 T3 provider log session/prompt started; agent launches a ~15s background Python command and ends its turn.
    07:46:55.471 – .489 T3 provider log & trace session/prompt resolves (succeeded), closing out the run in EventSink.write.
    07:46:59.667 Background task log Background command exits 0, triggering the wakeup inside agy 1.5.10.
    07:46:59.688 T3 server.trace.ndjson antigravityAuthSupport.splitStdoutLines / handleStdoutLine fires (1 pair).
    07:47:12.084 – 07:47:16.737 T3 server.trace.ndjson 19 additional splitStdoutLines / handleStdoutLine span pairs arrive over ~4.6s as agy 1.5.10 streams the woken reply, with zero EventSink.write or ProviderEventIngestor spans (UI remains idle).
    07:48:00.253 T3 provider log User sends the next message, starting a new session/prompt.

    (Also checked t3_background_wait manually on 0.1.10-nightly.20261116.4800 earlier today: rejected with OrchestratorMcpFailure / invalid_request: "This provider cannot mark background work as awaited."; AntigravityAdapterV2.ts in 4814 is unchanged in this regard.)

    So the CLI-side blocker is now resolved in agy 1.5.10; the remaining gap is purely on the T3 Code adapter side (waiting on #37489 / #37485).

  11. ReyYang commented on Nov 17, 2026

    @ReyYang

    Adding a follow-up data point on T3 Code (Beta) 0.1.10 with Antigravity ACP Server / agy CLI 1.5.10. Consistent with @KevinXC5's note above about 1.5.10 flushing post-end_turn traffic immediately, 1.5.10 no longer hangs silently on wakeup — instead, T3 Server fails the wakeup session/request_permission RPC immediately in < 1 ms.

    Environment

    • T3 Code: Beta 0.1.10
    • OS: macOS 27.2.1 (arm64)
    • Provider: Antigravity (Antigravity ACP Server / agy CLI 1.5.10)
    • Thread runtimeMode: full-access

    Background & Reproduction

    1. In <project>, <long-running-command> ran via run_command (WaitMsBeforeAsync: 10000), exceeded 10s, and transitioned into a background task.
    2. The model posted a short waiting message and ended its turn. antigravity-acp resolved session/prompt with succeeded, and T3 UI immediately marked the run as completed (t3_background_wait is also documented as Claude/OpenCode only).
    3. When the background task completed, <SYSTEM_MESSAGE> automatically woke Antigravity, which then invoked the follow-up run_command.

    Difference vs. OP (1.5.7–1.5.9 hang)

    Unlike the OP where woken tool calls stall indefinitely waiting for confirmation, on 0.1.10 + agy 1.5.10 the wakeup session/request_permission call hits T3 Server and immediately throws in < 1 ms (0.8 ms / 0.5 ms in server.trace.ndjson):

    Error: ACP request handler failed for method 'session/request_permission'
        at session/request_permission
        at effect-acp/AcpClient.make
        at AcpSessionRuntime.make
        at makeAntigravityAcpRuntime
        at AntigravityDriver.makeRuntime
        at AntigravityAdapterV2.makeRuntime
    
    • On the ACP server side (permissions.go:84 / server.go:2795), the RPC returns JSON-RPC -32603 (Tool confirmation ... approved=false).
    • Antigravity receives user denied permission to run command, terminates the step/session with ERROR, and neither the post-wakeup output nor the failure is synced back to the T3 thread UI (reproduced twice consecutively in the same session).

    This session/request_permission failure path closely resembles #23552, occurring here under Antigravity CLI 1.5.10 + full-access background command wakeups.

  12. MDaubs commented on Nov 17, 2026

    @MDaubs

    Confirming this on Linux x64 with T3 Code 0.1.10 + managed Antigravity ACP Server 1.5.10 (and also observing the 1.5.9 variant on a separate macOS backend).

    Environment

    • Server: T3 Code 0.1.10 (systemd user service on Linux x64, kernel 6.8.0-149-generic, Node v26.13.1)
    • Client: T3 Code 0.1.10 on macOS (connected to remote Linux server)
    • Triage CLI: 0.1.10
    • Provider: Managed Antigravity ACP Server 1.5.10 (gemini-4-carbon, thought_level: high)

    Sanitized Timeline (UTC, 2026-11-17)

    Time (UTC) Source Observation
    13:42:20.000 statev2.sqlite Run ordinal: 1 starts.
    13:57:17.499 acp-server.log Long-running Python command is approved (step 77, approved=true), exceeds WaitMsBeforeAsync, and moves to a background task.
    13:59:02.623 statev2.sqlite Planner posts a message stating it is waiting for the background task to finish and ends its turn (end_turn). T3 immediately marks the run completed instead of waiting.
    14:10:16.043 – 14:12:25.277 acp-server.log Background task finishes (~13 min runtime) and wakes the planner internally. Over ~2 minutes, the woken agent executes 6 streamGenerateContent calls and writes a follow-up Python script to its scratch directory (write_file passes sir_flash_lite at 14:11:59.629) — none of which surfaces in T3 because the run is already marked completed and makeAntigravityAcpAdapterFlavor (apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts) omits enablePostSettleContinuation, deferFinalizeForBackgroundWork, and extractBackgroundTaskId.
    14:12:26.427 acp-server.log Woken agent attempts to execute the follow-up Python script (step 98). agy 1.5.10 sends session/request_permission while no session/prompt is active in T3: permissions.go:84] session/request_permission RPC failed: JSON-RPC error: ACP request handler failed for method 'session/request_permission' (code -32603) → server.go:2795] Tool confirmation for conversation <conv-id> step 98 (... approved=false).

    Workaround confirmed

    Sending a manual follow-up prompt in the thread opens a new session/prompt and allows the agent to resume from its saved native session state.

    Investigated with Gemini 4 Carbon in Antigravity CLI via t3 triage.

  13. changed the title [-]Antigravity CLI 1.5.7 ends turns on background waits and stalls wakeups in forced default mode[/-] [+]Antigravity 1.5.10 background commands mark the turn done early and T3 drops the wakeup reply[/+] on Nov 18, 2026
  14. mahmoodnizamani94-png commented on Nov 18, 2026

    @mahmoodnizamani94-png
    Author

    Retested this on managed Antigravity 1.5.10 with a minimal prompt so there is an easy repro without waiting on a real test suite.

    Ask the agent in Full access to run sleep 15 && echo "Task finished" in the background, wait for it without polling, and tell me when it finishes.

    Nine seconds after sleep 15 starts, T3 flips the run to done and resets the composer while the sleep is still running. At fifteen seconds the sleep exits with code 0 and the agent writes the finished output to its local transcript right away, yet T3 stays idle and never shows the wakeup reply until you send another prompt. Since 1.5.10 already flushes post-turn updates from the CLI, the remaining drop is on the T3 adapter side.

  15. furkansandal commented on Nov 18, 2026

    @furkansandal

    +++

  16. Rylaa commented on Nov 18, 2026

    @Rylaa

    +++

  17. joseehilton147 commented on Nov 18, 2026

    @joseehilton147

    Same failure here on Windows x64, with agy 1.5.9 and 1.5.10 (T3 nightly). Adding a few specifics not pinned down yet, and a workaround that works on current builds.

    The 1.5.9 hang is structural in the CLI. runPromptTurn closes StreamConversationUpdates in a defer once the prompt settles, and resolveToolPermission only runs inside that stream while a session/prompt is active. The woken run_command (observed 4-64 s after end_turn) therefore sits in WAITING_FOR_CONFIRMATION with nothing to answer it, which matches the traces above where the stalled confirmation fires milliseconds after the next user prompt. Full access does not skip the confirmation: the CLI rejects yolo outright (modes.go), so the T3-side mode mapping always lands in a confirmation mode.

    On 1.5.10 the wakeup fails fast on the T3 side instead of hanging: the post-end_turn session/request_permission is rejected by the adapter with No active ACP turn (JSON-RPC -32603, packages/provider-acp/src/server/adapter.ts). The CLI-side flush works; the remaining blocker for the permission half is the adapter's admission check for detached requests.

    Workaround that works today: instead of letting the agent end its turn and wait passively, have it poll the task itself — call manage_task (status) in the same turn until the task reports DONE. The session/prompt stays open, the wakeup lands inside the active turn, and no detached permission request is sent. One tool call per poll, which is fine for finite tasks and not a fix for long daemons.

    Mapping to the open PRs, no ask implied: #37485 covers the detached permission half — it offers a continuation before a detached permission request is admitted and keeps the turn open while the request waits, which is exactly the No active ACP turn failure above; #37489 covers the wait itself (t3_background_wait plus reattaching a prompt after end_turn); #35073 keeps the turn open while a command is still running; #30083 is the built-in adapter's post-settle continuation.

    Diagnostic assembled from local agy logs, transcripts, and adapter source, with GLM (Z.ai) assistance.

  18. Mchicao commented on Nov 19, 2026

    @Mchicao

    Confirming this still reproduces on Windows x64 with T3 Code 0.1.11-nightly.20261118.4890 and agy 1.5.11, along with two new findings from live traces and a review of open PR #37489.

    1. Live agy 1.5.11 trace (two halves of the failure)

    • T3 side (false completion): A finite run_command (IsDaemon unset, WaitMsBeforeAsync: 5000) moved to background (step_type: 132, protobuf field 148.1 = <sessionId>/task-<idx>) and remained in_progress over ACP. When the model ended its turn to wait, agy 1.5.11 resolved session/prompt cleanly (23:48:56.964Z). Because AntigravityAdapterV2 does not configure isBackgroundCommandTool / extractBackgroundTaskId, finalizeTurn → terminalizeOpenForegroundTools (packages/provider-acp/src/server/adapter.ts) marked the still-running command completed 72 ms later with no output or exit code and closed the run.
    • agy 1.5.11 side (dropped wakeup + no replay on next prompt): 22 seconds later (23:49:19Z), the command exited 0 (steps.status = 3 in antigravity-acp/conversations/<sessionId>.db), Antigravity woke the model internally, executed a read step, and wrote its full final reply (23:49:28Z) with zero ACP events in T3's provider event log. Crucially, when a follow-up user message started a new session/prompt 19 minutes later, agy 1.5.11 did not flush or replay either the completed command output or the wakeup reply.
    • Live control check while prompt stays open: Running a 6.5 s command with WaitMsBeforeAsync: 5000 (so it backgrounds at 5 s and exits naturally 1.5 s later while session/prompt stays attached) confirmed that agy 1.5.11 does emit tool_call_update (status: completed + full stdout) immediately on natural exit when session/prompt is open.

    2. Detached-completion spin-loop risk in PR #37489

    Reviewing PR #37489 against the non-replay behavior observed on agy 1.5.11:

    • isAntigravityForegroundCommandOpen only inspects ACP toolCall.status, and AntigravityChildWork.readAntigravityTaskIds only maps IDs—nothing reads the steps.status column in conversations/<sessionId>.db (empirically verified on agy 1.5.11: 2 = RUNNING, 3 = DONE, 6 = CANCELED, 7 = ERROR with error_details).
    • If a backgrounded command finishes in the gap between session/prompt oxc stack #1 returning end_turn and the continuation session/prompt Add open-in-editor feature with Cmd+O shortcut #2 attaching, agy 1.5.11 does not replay tool_call_update(completed) for that step. context.tools stays inProgress permanently:
      • Without t3_background_wait: runPromptLoop fires continuation #0 immediately (no wait before continuations >= 1) and then loops up to maxContinuations (24) turns (~10 s apart) before finalizeTurn still fabricates a bare completed.
      • With t3_background_wait: awaitBackgroundTasks blocks up to waitSlice (4 min) per continuation waiting on an ACP status update that never arrives.
    • Separately, isAntigravityForegroundCommandOpen also keeps completed subagent launches open until an explicit waiting: false release, which can trigger the same loop if the model omits the release call.

    Checking native steps.status (single indexed SELECT status FROM steps WHERE idx = ?) before re-prompting—waiting on native settlement first and issuing at most one bounded continuation when native reached a terminal status while detached—avoids the spin loop and lets T3 settle the tool accurately instead of fabricating a bare completed.

    Investigated and reviewed jointly by Gemini 4 Neon and Claude Opus 5.5.

  19. changed the title [-]Antigravity 1.5.10 background commands mark the turn done early and T3 drops the wakeup reply[/-] [+]Antigravity 1.5.7 through 1.5.11 background commands mark the turn done early and T3 drops the wakeup reply[/+] on Nov 19, 2026
  20. mahmoodnizamani94-png commented on Nov 19, 2026

    @mahmoodnizamani94-png
    Author

    @juliusmarminge @Yash-Singh1 thirteen people have reproduced this across Linux, macOS, and Windows from 1.5.7 up through 1.5.11, and there is still not a single maintainer reply or review on the open fixes.

    Meanwhile #38740 just merged today and deletes old managed Antigravity versions on startup and update. Pinning the old 1.4.5 server was the only way to run a test suite or background command without T3 marking the turn done early and dropping the reply. Now managed installs wipe that fallback while #35073, #36585, #37485, and #37489 sit unreviewed.

    Can someone on the team take a look at this or review the open PRs before everyone's working 1.4.5 binary gets pruned?

    come on

  21. dimsedra commented on Nov 19, 2026

    @dimsedra

    I am running into this exact same issue on Linux with T3 Code 0.1.11-nightly.20261118.4890 and agy acp 1.5.11 (Gemini 4 Hydrogen High).

    When I ask the agent to run something that moves to the background, like a unit test suite or a background subagent, the agent says it is waiting for the task to finish and stops talking. Right away, T3 marks the turn as done and puts the chat input back to idle.

    When the background work actually finishes, nothing happens in T3. Unlike using agy directly in my terminal where the main agent wakes back up on its own and shows the result, in T3 the thread just sits there. I have to keep typing things like "done yet?" or "any update?" just to force a new turn so the agent can wake up and tell me what happened.

    Also shared this experience on the related issues: #38478, #38535, #30082, and #16442.

  22. t3dotgg commented on Nov 19, 2026

    @t3dotgg
    Member

    Note

    🤖 Claude Fable 5.2 responding on behalf of Theo

    Fixed by #38864 (merge commit 12be92d). Output that agy sends after its prompt ends now starts a continuation run, and a permission request that arrives with no turn waits for that run. Before the fix it failed with ACP agent requested input without an active turn. Verified with real agy 1.5.11 through a dev server: the thread continued by itself in one run after the background command finished, and the html_render page showed. I did not test 1.5.7 to 1.5.10.

  23. t3dotgg commented on Nov 19, 2026

    @t3dotgg
    Member

    Note

    🤖 Claude Fable 5.2 responding on behalf of Theo

    Follow-up: #38916 (merge commit f9b9bc7) fixes the other half of this issue. The run no longer ends when agy ends its prompt with a command still running. It stays open until the command finishes, and the reply lands in the same run. Verified with real agy 1.5.11 through a dev server.

  24. Realauster commented on Nov 19, 2026

    @Realauster

    The fix from #38864 / #38916 works for the built-in Antigravity provider, but the generic ACP registry provider (Settings → Local ACP, running the same agy acp binary) still has the original bug.

    Repro (2026-11-19, Linux, agy 1.5.12, same prompt in two threads):

    Start sleep 25; echo STALL-TEST-DONE as a BACKGROUND task, wait for it the normal way, and reply with its output line.

    Provider Result
    Built-in Antigravity (gemini-3.8-flash, full-access) ✅ The turn stays open and the reply is STALL-TEST-DONE-A
    Local ACP / acpRegistry (same agy acp binary, gemini-3.8-flash, auto) ❌ The model says "I have launched the background task and will wait", the turn is marked completed, and the output and wakeup reply never appear

    Same thing with longer jobs (a benchmark started with manage_task, and invoke_subagent running a subagent): the thread stops at "Waiting on …" until the user sends another message.

    #38916 only changes AntigravityAdapterV2 / provider/acp/AntigravityProtocol.ts, so the generic ACP registry adapter never got the "keep the turn open while background work runs" handling.

    Why it matters: Local ACP is the current workaround for Antigravity Auto mode until #35540 lands, so people on that workaround hit this bug.

  25. ethan-blue commented on Nov 22, 2026

    @ethan-blue

    Confirmed that this still reproduces reliably (6 out of 6 incidents on 2026-11-21 / 2026-11-22) on T3 Code (Beta) 0.1.11.0 when paired with agy CLI 1.5.9 on Windows (x64), even though server.asar already includes the #38864 / #38916 flags (enablePostSettleContinuation: true, deferFinalizeForBackgroundWork: true, wakeOnDetachedRequest: true).

    In the fix note above, #38864 was verified against agy 1.5.11 ("I did not test 1.5.7 to 1.5.10"). This looks like the exact 1.5.7–1.5.10 gap still failing on 1.5.9 when agy is installed as a standalone/custom binary rather than a newer managed >= 1.5.11 binary.

    Environment

    • OS: Windows (x64)
    • App: T3 Code (Beta) 0.1.11.0
    • Antigravity ACP CLI: 1.5.9 (agentInfo.version: "1.5.9")
    • AntigravityAdapterV2 flags present in server.asar:
      • enablePostSettleContinuation: true
      • deferFinalizeForBackgroundWork: true
      • wakeOnDetachedRequest: true
      • subagentsIdleOnTurnCompletion: true

    What happened (6/6 identical deadlocks)

    1. A turn launches either a subagent or a run_command that moves into the background (WaitMsBeforeAsync exceeded), and ends its model output waiting for completion wakeup.
    2. agy 1.5.9 immediately exits its stream (server.go:1323] Stream goroutine exited for <session-id>, sending completion signal) and T3 Code marks session/prompt status: succeeded.
    3. Later (seconds to ~20 min), the background task / subagent completes and triggers an internal <SYSTEM_MESSAGE> wakeup inside agy:
      • Zero session/update or session/request_permission frames appear in T3 Code's provider event log during the hang, so wakeOnDetachedRequest never fires.
      • Non-shell read tools (read_file) succeed silently, then the first run_command clears safety checks (agy_tool_safety / sir_flash_lite triggered=false) and deadlocks waiting for Tool confirmation (observed hangs: 11 min, 24 min, 27 min, 2h 54m, 7h 06m, 7h 54m) while quota polling (fetchAvailableModels / loadCodeAssist) keeps running every 6 minutes.
    4. Sending any manual user message opens a new session/prompt -> server.go:1260] Starting conversation update stream, and within 8 ms – 253 ms, server.go:2738] Tool confirmation for conversation <session-id> step <N> (type=*gemini_coder_go_proto.Step_Generic approved=true) fires and unblocks the command immediately.

    Across the full acp-server log, 325 / 325 Tool confirmation approvals occurred strictly while conversation update stream was active (0 / 325 outside an active stream).

    Sanitized Log Excerpts (UTC+8)

    Case A (git status on wakeup):

    I1122 09:40:11.896324 server.go:1323] Stream goroutine exited for <session-id>, sending completion signal
    ... (background task completes at 09:40:27; wakeup calls run_command) ...
    I1122 09:40:30.903309 runner.go:898] Monitor agy_tool_safety FINISHED: triggered=false, reason="allowed_subcommand", duration=26.9µs
    ... (hangs 24m with zero ACP events until manual prompt) ...
    I1122 10:04:16.778632 server.go:988] ACP Request received: session/prompt
    I1122 10:04:16.778632 server.go:1260] Starting conversation update stream for <session-id>
    I1122 10:04:16.952721 server.go:2738] Tool confirmation for conversation <session-id> step 651 (type=*gemini_coder_go_proto.Step_Generic approved=true)
    

    Case B (test/UI capture command on wakeup):

    I1122 10:26:40.017356 server.go:1323] Stream goroutine exited for <session-id>, sending completion signal
    ... (background task completes at 10:27:03; wakeup calls run_command) ...
    I1122 10:27:12.471478 runner.go:898] Monitor sir_flash_lite FINISHED: triggered=false, ...
    ... (hangs 2h 54m with zero ACP events until manual prompt) ...
    I1122 13:21:10.004307 server.go:988] ACP Request received: session/prompt
    I1122 13:21:10.004307 server.go:1260] Starting conversation update stream for <session-id>
    I1122 13:21:10.257949 server.go:2738] Tool confirmation for conversation <session-id> step 835 (type=*gemini_coder_go_proto.Step_Generic approved=true)
    

    Takeaway

    Because agy <= 1.5.10 (1.5.9 here) emits neither session/update nor session/request_permission outside an active conversation update stream when waking asynchronously, post-settle continuation cannot observe the wakeup. Enforcing/warning on agy < 1.5.11 (or holding/reopening session/prompt when antigravityCommandOutlivesPrompt / subagent work is pending) would prevent users on 1.5.9 from hitting multi-hour silent deadlocks.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions