From 85594f4bc2955b7f7adba5f5f8b97290bda935dc Mon Sep 17 00:00:00 2001 From: hqhq1025 <1506751656@qq.com> Date: Sun, 22 Nov 2026 01:38:47 +0800 Subject: [PATCH 1/3] fix(server): pass --dangerously-skip-permissions for unrestricted Antigravity Full access --- .../Adapters/AntigravityAdapterV2.test.ts | 10 ++- .../Adapters/AntigravityAdapterV2.ts | 15 +++- .../Drivers/AntigravityDriver.test.ts | 89 +++++++++++++++++-- .../src/provider/Drivers/AntigravityDriver.ts | 6 +- .../acp/AntigravityAcpSupport.test.ts | 45 ++++++++++ .../src/provider/acp/AntigravityAcpSupport.ts | 31 ++++++- .../provider/antigravityAuthSupport.test.ts | 17 ++++ .../src/provider/antigravityAuthSupport.ts | 2 + packages/provider-acp/src/server/adapter.ts | 41 ++++++++- 9 files changed, 238 insertions(+), 18 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts index fca472c6c433e..6451b347d3ef1 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts @@ -2308,12 +2308,14 @@ describe("AntigravityAdapterV2 runtime mode ceiling", () => { new URL("../../../scripts/acp-mock-agent.ts", import.meta.url), ); let runtime: AcpSessionRuntime.AcpSessionRuntime["Service"] | undefined; + const launchModes: Array = []; const instanceId = ProviderInstanceId.make("antigravity-plan-exit-test"); const adapter = yield* makeAntigravityAdapterV2({ instanceId, selfInvocation: yield* resolveSelfInvocation(), - makeRuntime: (input) => - makeAntigravityAcpRuntime({ + makeRuntime: (input) => { + launchModes.push(input.runtimePolicy?.runtimeMode); + return makeAntigravityAcpRuntime({ ...input, childProcessSpawner, spawn: { @@ -2329,7 +2331,8 @@ describe("AntigravityAdapterV2 runtime mode ceiling", () => { runtime = made; }), ), - ), + ); + }, withProcess: (_stop, task) => task, defaultModel: Effect.undefined, }); @@ -2376,6 +2379,7 @@ describe("AntigravityAdapterV2 runtime mode ceiling", () => { Stream.runHead, ); assert.equal((yield* runtime!.getModeState)?.currentModeId, "default"); + assert.deepEqual(launchModes, ["full-access", "approval-required"]); }).pipe(Effect.provide(layerSession), Effect.scoped), ); }); diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts index 3f629c813b615..c227d2444ebae 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts @@ -24,10 +24,12 @@ import { antigravityPermissionDisposition, antigravityPermissionMode, antigravityRuntimeModeForSessionMode, + antigravitySkipsPermissions, antigravitySteersWithPrompt, applyAntigravityAcpModelSelection, buildAntigravityPrompt, type AntigravityAcpRuntimeInput, + type AntigravityLaunchPermissionPolicy, } from "../../provider/acp/AntigravityAcpSupport.ts"; import { ANTIGRAVITY_SUBAGENT_BATCH_TITLE, @@ -63,7 +65,9 @@ const AntigravityProviderCapabilitiesV2 = { sessions: { ...AcpProviderCapabilitiesV2.sessions, supportsModelSwitchInSession: true, - supportsRuntimeModeSwitchInSession: true, + // Unrestricted Full access passes `--dangerously-skip-permissions` at launch, so switching + // across permission modes respawns `agy acp` and resumes the session via `session/resume`. + supportsRuntimeModeSwitchInSession: false, }, tools: { ...AcpProviderCapabilitiesV2.tools, @@ -75,11 +79,14 @@ const AntigravityProviderCapabilitiesV2 = { }, } satisfies OrchestrationV2ProviderCapabilities; -/** Thread variables reach the driver here; `makeAntigravityAcpRuntime` never reads them. */ +/** Thread variables and launch-time permission policy reach the driver here; `makeAntigravityAcpRuntime` never reads them. */ export type AntigravityAdapterV2RuntimeInput = Omit< AntigravityAcpRuntimeInput, "spawn" | "childProcessSpawner" -> & { readonly processEnvironment?: NodeJS.ProcessEnv }; +> & { + readonly processEnvironment?: NodeJS.ProcessEnv; + readonly runtimePolicy?: AntigravityLaunchPermissionPolicy; +}; export interface AntigravityAdapterV2Options { readonly instanceId: ProviderInstanceId; @@ -265,6 +272,8 @@ export function makeAntigravityAcpAdapterFlavor( }), sessionModeForPolicy: (policy) => antigravityPermissionMode(policy.runtimeMode), runtimeModeForSessionMode: antigravityRuntimeModeForSessionMode, + requiresRuntimeRestartForPolicy: (launchedPolicy, nextPolicy) => + antigravitySkipsPermissions(launchedPolicy) !== antigravitySkipsPermissions(nextPolicy), clientFileSystem: { readTextFile: (request, cwd) => readAntigravityClientTextFile({ diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts index 3c0135f419c66..9a86c9f2b0176 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts @@ -420,22 +420,42 @@ it.layer(layerTest)("AntigravityDriver", (it) => { }, ]); - // The agy CLI rejects `yolo` and `auto_edit`; it stays in `default` and T3 answers its requests. + // Unrestricted Full access passes `--dangerously-skip-permissions` so detached subagents do + // not time out on unforwarded prompts; restricted Full access and Auto-accept edits omit it. h.controls.selected = yield* h.makeExecutable("runtime cli", { initialMode: "auto_edit" }); - for (const runtimeMode of ["full-access", "auto-accept-edits"] as const) { + for (const scenario of [ + { + name: "full-access", + policy: { runtimeMode: "full-access" as const }, + skipPermissions: true, + }, + { + name: "full-access-restricted", + policy: { runtimeMode: "full-access" as const, approvalPolicy: "on-request" }, + skipPermissions: false, + }, + { + name: "auto-accept-edits", + policy: { runtimeMode: "auto-accept-edits" as const }, + skipPermissions: false, + }, + ]) { const requestsBefore = (yield* h.readRequests).length; - const cliThreadId = ThreadId.make(`thread-antigravity-cli-${runtimeMode}`); + const cliThreadId = ThreadId.make(`thread-antigravity-cli-${scenario.name}`); const cliPolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ - runtimeMode, + ...scenario.policy, interactionMode: "default", cwd: workspace, }); const cliSession = yield* h.instance.orchestrationAdapter.openSession({ threadId: cliThreadId, - providerSessionId: ProviderSessionId.make(`provider-session-cli-${runtimeMode}`), + providerSessionId: ProviderSessionId.make(`provider-session-cli-${scenario.name}`), modelSelection, runtimePolicy: cliPolicy, }); + expect( + cliSession.providerSession.capabilities.sessions.supportsRuntimeModeSwitchInSession, + ).toBe(false); yield* cliSession.ensureThread({ threadId: cliThreadId, modelSelection, @@ -447,6 +467,7 @@ it.layer(layerTest)("AntigravityDriver", (it) => { h.profileDirectory, "--app-data-dir", "antigravity-acp", + ...(scenario.skipPermissions ? ["--dangerously-skip-permissions"] : []), ]); expect( (yield* h.readRequests) @@ -462,6 +483,64 @@ it.layer(layerTest)("AntigravityDriver", (it) => { }), ); + it.effect.skipIf(windowsHost)( + "respawns without --dangerously-skip-permissions when a Full access session downgrades before a turn", + () => + Effect.gen(function* () { + const h = yield* makeHarness(); + const threadId = ThreadId.make("thread-antigravity-downgrade"); + const modelSelection = { instanceId: h.instance.instanceId, model: "gemini-test-low" }; + + yield* Effect.scoped( + Effect.gen(function* () { + const workspace = yield* h.fs.makeTempDirectoryScoped({ prefix: "t3-ag-downgrade-" }); + const fullAccessPolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ + runtimeMode: "full-access", + interactionMode: "default", + cwd: workspace, + }); + const supervisedPolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ + runtimeMode: "approval-required", + interactionMode: "default", + cwd: workspace, + }); + const session = yield* h.instance.orchestrationAdapter.openSession({ + threadId, + providerSessionId: ProviderSessionId.make("provider-session-antigravity-downgrade"), + modelSelection, + runtimePolicy: fullAccessPolicy, + }); + const providerThread = yield* session.ensureThread({ + threadId, + modelSelection, + runtimePolicy: fullAccessPolicy, + }); + yield* session.resumeThread({ + providerThread, + modelSelection, + runtimePolicy: supervisedPolicy, + }); + }), + ); + + const agentLaunches = h.launches.filter( + (launch) => launch.command === h.first.executablePath, + ); + expect(agentLaunches.map((launch) => launch.args)).toEqual([ + [ + "acp", + "--gemini-dir", + h.profileDirectory, + "--app-data-dir", + "antigravity-acp", + "--dangerously-skip-permissions", + ], + ["acp", "--gemini-dir", h.profileDirectory, "--app-data-dir", "antigravity-acp"], + ]); + yield* h.assertClosed; + }), + ); + it.effect.skipIf(windowsHost)( "gives a thread session its own T3 thread and MCP fallback environment", () => diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.ts b/apps/server/src/provider/Drivers/AntigravityDriver.ts index 3d426785813c3..9d39f69516bb0 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.ts @@ -49,6 +49,7 @@ import { import { antigravityModelOptions, antigravitySessionMode, + antigravitySkipsPermissions, antigravityThinkingConfig, makeAntigravityAcpRuntime, type AntigravityAcpRuntimeInput, @@ -207,6 +208,7 @@ export const AntigravityDriver: ProviderDriver< const prepareSpawn = Effect.fn("AntigravityDriver.prepareSpawn")(function* ( cwd: string, baseEnv: NodeJS.ProcessEnv, + options?: { readonly skipPermissions?: boolean }, ): Effect.fn.Return< { readonly executable: AntigravityInstallation.AntigravityExecutable; @@ -287,6 +289,7 @@ export const AntigravityDriver: ProviderDriver< baseEnv, auth, runtimeTempDirectory, + ...(options?.skipPermissions === true ? { skipPermissions: true } : {}), }), }; }); @@ -300,12 +303,13 @@ export const AntigravityDriver: ProviderDriver< > { // `buildAntigravityAcpSpawnInput` sets `extendEnv: false`, so thread variables only reach the // agent's shell through `baseEnv`. - const { processEnvironment: threadEnvironment, ...runtimeInput } = input; + const { processEnvironment: threadEnvironment, runtimePolicy, ...runtimeInput } = input; const { executable, spawn } = yield* prepareSpawn( runtimeInput.cwd, threadEnvironment === undefined ? processEnvironment : { ...processEnvironment, ...threadEnvironment }, + { skipPermissions: antigravitySkipsPermissions(runtimePolicy) }, ); const runtime = yield* makeAntigravityAcpRuntime({ ...runtimeInput, diff --git a/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts b/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts index 05f12ec278fd9..308da0ca2961d 100644 --- a/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts +++ b/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts @@ -19,6 +19,7 @@ import { antigravityPermissionDisposition, antigravitySessionMeta, antigravitySessionMode, + antigravitySkipsPermissions, buildAntigravityPrompt, } from "./AntigravityAcpSupport.ts"; @@ -89,6 +90,50 @@ describe("Antigravity release gates", () => { ); }); +describe("antigravitySkipsPermissions", () => { + it.each([ + { label: "undefined policy", policy: undefined, expected: false }, + { + label: "unrestricted full-access", + policy: { runtimeMode: "full-access" as const }, + expected: true, + }, + { + label: "full-access with matching maxRuntimeMode", + policy: { runtimeMode: "full-access" as const, maxRuntimeMode: "full-access" as const }, + expected: true, + }, + { + label: "full-access with narrower maxRuntimeMode", + policy: { runtimeMode: "full-access" as const, maxRuntimeMode: "auto" as const }, + expected: false, + }, + { + label: "full-access with explicit approvalPolicy", + policy: { runtimeMode: "full-access" as const, approvalPolicy: "on-request" }, + expected: false, + }, + { + label: "full-access with explicit sandboxPolicy", + policy: { runtimeMode: "full-access" as const, sandboxPolicy: { type: "readOnly" } }, + expected: false, + }, + { label: "auto", policy: { runtimeMode: "auto" as const }, expected: false }, + { + label: "auto-accept-edits", + policy: { runtimeMode: "auto-accept-edits" as const }, + expected: false, + }, + { + label: "approval-required", + policy: { runtimeMode: "approval-required" as const }, + expected: false, + }, + ])("returns $expected for $label", ({ policy, expected }) => { + expect(antigravitySkipsPermissions(policy)).toBe(expected); + }); +}); + describe("Antigravity Auto", () => { it.each([ { offered: ["default", "accept-edits", "auto", "plan"], expected: "auto" }, diff --git a/apps/server/src/provider/acp/AntigravityAcpSupport.ts b/apps/server/src/provider/acp/AntigravityAcpSupport.ts index 7434e23b5eda9..467b4d55a33b3 100644 --- a/apps/server/src/provider/acp/AntigravityAcpSupport.ts +++ b/apps/server/src/provider/acp/AntigravityAcpSupport.ts @@ -1,6 +1,7 @@ import { ANTIGRAVITY_DEFAULT_MODEL, type AntigravityAuthMethod, + isRuntimeModeAbove, PROVIDER_SEND_TURN_MAX_FILE_BYTES, PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, type ProviderSendTurnInput, @@ -164,10 +165,36 @@ export function antigravityPermissionMode(runtimeMode: RuntimeMode): string { } } +export interface AntigravityLaunchPermissionPolicy { + readonly runtimeMode: RuntimeMode; + readonly approvalPolicy?: unknown; + readonly sandboxPolicy?: unknown; + readonly maxRuntimeMode?: RuntimeMode | undefined; +} + +/** + * Unrestricted Full access passes `--dangerously-skip-permissions` so `agy acp` detached + * subagents (`invoke_subagent`) do not time out waiting on unforwarded permission prompts. + * Any explicit approval policy, sandbox policy, or narrower runtime-mode ceiling disables it. + */ +export function antigravitySkipsPermissions( + policy: AntigravityLaunchPermissionPolicy | undefined, +): boolean { + return ( + policy !== undefined && + policy.runtimeMode === "full-access" && + policy.approvalPolicy === undefined && + policy.sandboxPolicy === undefined && + (policy.maxRuntimeMode === undefined || + !isRuntimeModeAbove("full-access", policy.maxRuntimeMode)) + ); +} + /** * The agy CLI rejects `yolo` and `auto_edit`, and sessions without native Auto reject `auto`. - * Those stay in `default`, where it asks before acting and T3 answers from the live runtime - * policy, so permission changes apply on the next turn without a restart. + * Those stay in `default`: unrestricted Full access passes `--dangerously-skip-permissions` at + * launch, while restricted Full access and Auto-accept edits let T3 answer requests from the + * live runtime policy. */ export function antigravitySessionMode( modeId: string, diff --git a/apps/server/src/provider/antigravityAuthSupport.test.ts b/apps/server/src/provider/antigravityAuthSupport.test.ts index ca759ef80a72f..4815662d4e078 100644 --- a/apps/server/src/provider/antigravityAuthSupport.test.ts +++ b/apps/server/src/provider/antigravityAuthSupport.test.ts @@ -109,6 +109,23 @@ describe("Antigravity process environment", () => { TMPDIR: profile.tempDirectory, }, }); + + expect( + buildAntigravityAcpSpawnInput({ + installation: { executablePath: "/usr/bin/agy" }, + profile, + cwd: "/project", + baseEnv, + skipPermissions: true, + }).args, + ).toEqual([ + "acp", + "--gemini-dir", + profile.geminiHome, + "--app-data-dir", + "antigravity-acp", + "--dangerously-skip-permissions", + ]); }); it("passes only the configured method's credential and keeps the GCP pair out of the environment", () => { diff --git a/apps/server/src/provider/antigravityAuthSupport.ts b/apps/server/src/provider/antigravityAuthSupport.ts index 8edd875839773..5e8a94526f2a5 100644 --- a/apps/server/src/provider/antigravityAuthSupport.ts +++ b/apps/server/src/provider/antigravityAuthSupport.ts @@ -550,6 +550,7 @@ export function buildAntigravityAcpSpawnInput(input: { readonly baseEnv?: NodeJS.ProcessEnv; readonly auth?: AntigravityAuthConfig; readonly runtimeTempDirectory?: string; + readonly skipPermissions?: boolean; }): AcpSessionRuntime.AcpSpawnInput { return { command: input.installation.executablePath, @@ -560,6 +561,7 @@ export function buildAntigravityAcpSpawnInput(input: { "--app-data-dir", // The CLI joins this beneath gemini-dir, including when the value is absolute. "antigravity-acp", + ...(input.skipPermissions === true ? ["--dangerously-skip-permissions"] : []), ], cwd: input.cwd, env: antigravityEnvironment( diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index a712d40629e60..35480023996b1 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -499,6 +499,14 @@ export interface AcpAdapterV2Flavor { * A picked mode this does not place within the thread's runtime mode is not applied. */ readonly runtimeModeForSessionMode?: (modeId: string) => RuntimeMode | undefined; + /** + * Returns true when changing from the policy that launched the current ACP process to + * `nextPolicy` requires restarting the process (e.g., process-level permission flags). + */ + readonly requiresRuntimeRestartForPolicy?: ( + launchedPolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy, + nextPolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy, + ) => boolean; readonly clientFileSystem?: { readonly readTextFile: ( request: EffectAcpSchema.ReadTextFileRequest, @@ -2235,6 +2243,8 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( const clientPolicyGrants = makeAcpClientPolicyGrants(); let latestRuntimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy = input.runtimePolicy; + let launchedRuntimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy = + input.runtimePolicy; const events = yield* Queue.unbounded(); const activeTurn = yield* Ref.make(null); // Keyed by the agent's steer id; an injection can arrive before its send returns. @@ -2819,11 +2829,11 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( handleRuntimeTerminationAtGeneration(runtimeGeneration), ): AcpAdapterV2RuntimeInput => { return { - cwd: input.runtimePolicy.cwd ?? process.cwd(), - runtimePolicy: input.runtimePolicy, - ...(input.runtimePolicy.workspace === undefined + cwd: latestRuntimePolicy.cwd ?? input.runtimePolicy.cwd ?? process.cwd(), + runtimePolicy: latestRuntimePolicy, + ...(latestRuntimePolicy.workspace === undefined ? {} - : { extraRoots: input.runtimePolicy.workspace.extraRoots }), + : { extraRoots: latestRuntimePolicy.workspace.extraRoots }), mcpServers: mcpContext.servers, acpMcpServers: mcpContext.acpServers, httpMcpServers: mcpContext.httpServers, @@ -7739,6 +7749,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( const mcpContext = yield* readMcpContext(threadId); runtimeMcpBridge = yield* makeRuntimeMcpBridge(mcpContext, runtimeScope); const runtimeGeneration = yield* Ref.get(runtimeCallbackGeneration); + const spawnPolicy = latestRuntimePolicy; openAgentRequests = new Set(); runtime = yield* flavor .makeRuntime( @@ -7751,6 +7762,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( Effect.provideService(AgentScope, agentScope), Effect.provideService(AgentScopeThreadId, threadId ?? undefined), ); + launchedRuntimePolicy = spawnPolicy; }); const startAcpRuntime = Effect.fnUntraced(function* ( @@ -7815,6 +7827,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( stagedSessionUpdates.push(notification); }); let replacementMcpBridge: AcpMcpOverAcpBridge | undefined; + const replacementPolicy = latestRuntimePolicy; const startup = Effect.gen(function* () { const mcpContext = yield* readMcpContext(threadId); replacementMcpBridge = yield* makeRuntimeMcpBridge(mcpContext, replacementScope); @@ -7884,6 +7897,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( } yield* quarantineNativeTransportAtGeneration(previousGeneration); runtime = replacementExit.value.replacementRuntime; + launchedRuntimePolicy = replacementPolicy; runtimeScope = replacementScope; runtimeMcpBridge = replacementMcpBridge; openAgentRequests = replacementAgentRequests; @@ -9294,6 +9308,14 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( useProviderThreadIdentity(turnInput.providerThread); // load/resume can invoke client methods; install the incoming policy before activation. latestRuntimePolicy = turnInput.runtimePolicy; + if ( + flavor.requiresRuntimeRestartForPolicy?.( + launchedRuntimePolicy, + turnInput.runtimePolicy, + ) === true + ) { + yield* Ref.set(runtimeRestartRequired, true); + } const requestedSessionId = yield* nativeThreadId(driver, turnInput.providerThread); const restartAfterInterrupt = yield* restartRuntimeAfterTeardownIfRequired( turnInput.threadId, @@ -9991,6 +10013,17 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( const restorePreviousItemIdentity = Effect.sync(() => { itemIdentityVersion = previousItemIdentityVersion; }); + if (threadInput.runtimePolicy !== undefined) { + latestRuntimePolicy = threadInput.runtimePolicy; + if ( + flavor.requiresRuntimeRestartForPolicy?.( + launchedRuntimePolicy, + threadInput.runtimePolicy, + ) === true + ) { + yield* Ref.set(runtimeRestartRequired, true); + } + } const restartAfterInterrupt = yield* restartRuntimeAfterTeardownIfRequired( threadInput.providerThread.appThreadId, ).pipe(Effect.tapError(() => restorePreviousItemIdentity)); From 39183aaa0c5ad789e8f89783640912568eed5ba7 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Sat, 21 Nov 2026 17:47:44 +0000 Subject: [PATCH 2/3] test(server): trim Antigravity skip-permissions tests to the regressions they catch Co-Authored-By: Claude Opus 5.5 --- .../provider/Drivers/AntigravityDriver.test.ts | 3 --- .../provider/acp/AntigravityAcpSupport.test.ts | 10 ---------- .../src/provider/antigravityAuthSupport.test.ts | 17 ----------------- 3 files changed, 30 deletions(-) diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts index 9a86c9f2b0176..f1ed4e3e70894 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts @@ -453,9 +453,6 @@ it.layer(layerTest)("AntigravityDriver", (it) => { modelSelection, runtimePolicy: cliPolicy, }); - expect( - cliSession.providerSession.capabilities.sessions.supportsRuntimeModeSwitchInSession, - ).toBe(false); yield* cliSession.ensureThread({ threadId: cliThreadId, modelSelection, diff --git a/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts b/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts index 308da0ca2961d..b7d41c3e0b5a1 100644 --- a/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts +++ b/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts @@ -119,16 +119,6 @@ describe("antigravitySkipsPermissions", () => { expected: false, }, { label: "auto", policy: { runtimeMode: "auto" as const }, expected: false }, - { - label: "auto-accept-edits", - policy: { runtimeMode: "auto-accept-edits" as const }, - expected: false, - }, - { - label: "approval-required", - policy: { runtimeMode: "approval-required" as const }, - expected: false, - }, ])("returns $expected for $label", ({ policy, expected }) => { expect(antigravitySkipsPermissions(policy)).toBe(expected); }); diff --git a/apps/server/src/provider/antigravityAuthSupport.test.ts b/apps/server/src/provider/antigravityAuthSupport.test.ts index 4815662d4e078..ca759ef80a72f 100644 --- a/apps/server/src/provider/antigravityAuthSupport.test.ts +++ b/apps/server/src/provider/antigravityAuthSupport.test.ts @@ -109,23 +109,6 @@ describe("Antigravity process environment", () => { TMPDIR: profile.tempDirectory, }, }); - - expect( - buildAntigravityAcpSpawnInput({ - installation: { executablePath: "/usr/bin/agy" }, - profile, - cwd: "/project", - baseEnv, - skipPermissions: true, - }).args, - ).toEqual([ - "acp", - "--gemini-dir", - profile.geminiHome, - "--app-data-dir", - "antigravity-acp", - "--dangerously-skip-permissions", - ]); }); it("passes only the configured method's credential and keeps the GCP pair out of the environment", () => { From 59a51229cd6f07c8a55c62c83bf2a9fb0a46b22d Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Sat, 21 Nov 2026 17:56:39 +0000 Subject: [PATCH 3/3] fix(server): ACP runtime restarts drop the old process's background tasks A restart replaced the runtime but kept runningBackgroundTaskIds and detachedBackgroundCommands, so tasks the dead process started stayed pending forever and blocked continuation and thread replacement. Reset them as commitReplacementSession does. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/AcpAdapterV2.test.ts | 43 ++++++++++++++++++- packages/provider-acp/src/server/adapter.ts | 7 +++ 2 files changed, 48 insertions(+), 2 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts index d79257944c8e9..61c775cfa668e 100644 --- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts @@ -11533,7 +11533,10 @@ describe("AcpAdapterV2", () => { ); // A dev server started as a background shell never exits, so it must not hold the root turn. - const startGrokBackgroundShellTurn = Effect.fnUntraced(function* (name: string) { + const startGrokBackgroundShellTurn = Effect.fnUntraced(function* ( + name: string, + requiresRuntimeRestartForPolicy?: AcpAdapterV2Flavor["requiresRuntimeRestartForPolicy"], + ) { const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; const path = yield* Path.Path; const selfInvocation = yield* resolveSelfInvocation(); @@ -11578,6 +11581,9 @@ describe("AcpAdapterV2", () => { extractBackgroundTaskId: grokFlavor.extractBackgroundTaskId!, isBackgroundCommandTool: grokFlavor.isBackgroundCommandTool!, isPersistentBackgroundTool: grokFlavor.isPersistentBackgroundTool!, + ...(requiresRuntimeRestartForPolicy === undefined + ? {} + : { requiresRuntimeRestartForPolicy }), registerExtensions: ({ runtime, applyBackgroundTaskMutation }) => registerXAiBackgroundTaskTracking(runtime, applyBackgroundTaskMutation), makeRuntime: makeMockRuntime({ @@ -11602,6 +11608,7 @@ describe("AcpAdapterV2", () => { }), }), }, + continuationRequests: { offer: () => Effect.void }, }); const threadId = ThreadId.make(`thread-acp-${name}`); const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ @@ -11706,7 +11713,17 @@ describe("AcpAdapterV2", () => { rows.push(event.turnItem); } }); - return { update, complete, startDevServer, settle, takeRows, runId: turnInput.runId }; + return { + update, + complete, + startDevServer, + settle, + takeRows, + runId: turnInput.runId, + runtime, + providerThread, + modelSelection, + }; }); it.effect("completes a settled Grok turn while a background shell keeps running", () => @@ -11721,6 +11738,28 @@ describe("AcpAdapterV2", () => { }).pipe(Effect.provide(layerTest), Effect.scoped), ); + it.effect("a policy restart drops background tasks the old process was running", () => + Effect.gen(function* () { + const harness = yield* startGrokBackgroundShellTurn( + "grok-dev-server-policy-restart", + (launched, next) => launched.runtimeMode !== next.runtimeMode, + ); + yield* harness.startDevServer; + yield* harness.settle; + assert.isTrue(yield* harness.runtime.hasPendingBackgroundWork!); + yield* harness.runtime.resumeThread({ + providerThread: harness.providerThread, + modelSelection: harness.modelSelection, + runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ + runtimeMode: "approval-required", + interactionMode: "default", + cwd: process.cwd(), + }), + }); + assert.isFalse(yield* harness.runtime.hasPendingBackgroundWork!); + }).pipe(Effect.provide(layerTest), Effect.scoped), + ); + it.effect("keeps a streaming Grok background shell running on its run after settling", () => Effect.gen(function* () { const harness = yield* startGrokBackgroundShellTurn("grok-dev-server-progress"); diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index 35480023996b1..253c82ce75945 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -9048,6 +9048,13 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( yield* Ref.set(compactionMarkers, new Map()); yield* Ref.set(completedCompactionIds, new Set()); yield* Ref.set(snapshot, emptySnapshotState()); + // The old process's tasks cannot report a terminal update to the new one. + yield* continuationPermit.withPermit( + Effect.gen(function* () { + yield* Ref.set(runningBackgroundTaskIds, new Set()); + yield* Ref.set(detachedBackgroundCommands, new Map()); + }), + ); return true; });