@@ -161,12 +161,17 @@ schema alone:
   (`_meta.quota`) from the idle `state_update` that ends the turn, not from a separate error
   channel. The same `_meta` v1 attaches to `PromptResponse` is copied onto the v2 idle update.
 - Custom session updates are renamed on v2: `subagent_spawned`/`subagent_state_update` become a
-  single `_subagent_update` (gated on the AIR `nativeSubagentSessions` capability; it will rename to
-  `subagent_update` once the subagent RFD, spec PR #1992, lands), and
+  single `_subagent_update` (gated on the AIR `nativeSubagentSessions` capability; this contract is
+  retained until the adapter migrates to the standard subagent model), and
   `async_task_spawned`/`async_task_state_update` become `_async_task_spawned`/`_async_task_state_update`
   (gated on the AIR `asyncTasks` capability). Payload shapes are unchanged.
-- The SDK client treats any `idle` state update as the stop of whichever prompt is pending, not just
-  one paired 1:1 with a `session/prompt` call.
+- Foreground state is independent of prompt acceptance. `running` can precede the user-message
+  echo, including while Codex runs hooks. A successful prompt response still waits for insertion.
+- Every successful `session/resume` sends a current-state snapshot after any replay and before its
+  response. An idle snapshot is not another completed turn and repeats no usage or failure metadata.
+- Permission and elicitation requests affect aggregate foreground state: another runnable item keeps
+  the session running, and answering one wait does not resume work that remains blocked. Withdrawing
+  a request on cancellation does not resume the workflow; late answers cannot revive an ended turn.
 - A steer (`_session/steering`) shows up as a `user_message` once it actually lands in the turn.
 - On cancel, any permission or elicitation request still waiting on a client response is withdrawn
   with `$/cancel_request`, not just the underlying Codex turn.
 
@@ -8,7 +8,7 @@ import {
 import {toV2SessionUpdates} from "./AcpV2SessionUpdate";
 import {toV1RequestPermissionResponse, toV2RequestPermissionRequest} from "./AcpV2Permissions";
 import {elicitationSessionId, toV1CreateElicitationResponse, toV2CreateElicitationRequest} from "./AcpV2Elicitation";
-import {logger} from "./Logger";
+import {AcpV2ForegroundState} from "./AcpV2ForegroundState";
 
 export type AcpClientConnection = Pick<acp.AgentContext, "notify" | "request">;
 
@@ -20,44 +20,27 @@ export type AcpV2ClientConnection = Pick<acpV2.AgentContext, "notify" | "request
 export class AcpV2Connection {
     readonly client: AcpV2ClientConnection;
     private isTurnRunning: (sessionId: string) => boolean = () => true;
+    private readonly foreground = new Map<string, AcpV2ForegroundState>();
 
     constructor(client: AcpV2ClientConnection) {
         this.client = client;
     }
 
-    /**
-     * Lets the owning server report whether a turn is still running for a session, so the
-     * `requires_action`/`running` bracket below is only applied around requests that actually
-     * interrupt foreground work: a request sent while idle must not send `requires_action` (there
-     * is no foreground work to block), and a request that outlives its turn must not resurrect
-     * `running` after the turn already went `idle` on its own.
-     * Defaults to always running, so callers that never wire this up keep the old behavior.
-     */
+    /** Identifies foreground interactions; background requests do not affect session state. */
     setTurnRunningCheck(check: (sessionId: string) => boolean): void {
         this.isTurnRunning = check;
     }
 
-    /**
-     * Runs `sendRequest`, bracketed with `requires_action`/`running` `state_update`s only if a
-     * turn is running for `sessionId` at the moment the request is about to be sent. If idle,
-     * `sendRequest` runs unbracketed: sending `requires_action` while there is no foreground work
-     * to block would contradict the state's definition, and the client is already correctly idle.
-     * If busy, `requires_action` is sent first, and `running` follows in `finally` only if a turn
-     * is still running by then -- a turn that went `idle` on its own while the request was pending
-     * must not have that `idle` undone.
-     */
-    private async withStateBracket<T>(sessionId: string, sendRequest: () => Promise<T>): Promise<T> {
+    private async withUserAction<T>(
+        sessionId: string,
+        itemId: string | undefined,
+        sendRequest: () => Promise<T>,
+        signal?: AbortSignal,
+    ): Promise<T> {
         if (!this.isTurnRunning(sessionId)) {
             return sendRequest();
         }
-        await this.sendState(sessionId, {state: "requires_action"});
-        try {
-            return await sendRequest();
-        } finally {
-            if (this.isTurnRunning(sessionId)) {
-                await this.sendState(sessionId, {state: "running"});
-            }
-        }
+        return this.foregroundFor(sessionId).withUserAction(itemId, sendRequest, signal);
     }
 
     /**
@@ -72,10 +55,47 @@ export class AcpV2Connection {
 
     /** Sends a `state_update`, which only exists on v2 and so needs no rendering. */
     async updateState(sessionId: string, state: acpV2.StateUpdate): Promise<void> {
-        await this.client.notify(acpV2.methods.client.session.update, {
-            sessionId,
-            update: {sessionUpdate: "state_update", ...state},
-        });
+        await this.foregroundFor(sessionId).update(state);
+    }
+
+    startForegroundWork(sessionId: string): Promise<void> {
+        return this.foregroundFor(sessionId).start();
+    }
+
+    snapshotForegroundState(sessionId: string): Promise<void> {
+        return this.foregroundFor(sessionId).snapshot();
+    }
+
+    startForegroundItem(sessionId: string, itemId: string): Promise<void> {
+        return this.foregroundFor(sessionId).startItem(itemId);
+    }
+
+    completeForegroundItem(sessionId: string, itemId: string): Promise<void> {
+        return this.foregroundFor(sessionId).completeItem(itemId);
+    }
+
+    restoreForegroundState(sessionId: string, running: boolean): void {
+        this.foregroundFor(sessionId, running);
+    }
+
+    forgetSession(sessionId: string): void {
+        this.foreground.get(sessionId)?.dispose();
+        this.foreground.delete(sessionId);
+    }
+
+    private foregroundFor(sessionId: string, running = false): AcpV2ForegroundState {
+        let foreground = this.foreground.get(sessionId);
+        if (!foreground) {
+            foreground = new AcpV2ForegroundState(
+                state => this.client.notify(acpV2.methods.client.session.update, {
+                    sessionId,
+                    update: {sessionUpdate: "state_update", ...state},
+                }),
+                running,
+            );
+            this.foreground.set(sessionId, foreground);
+        }
+        return foreground;
     }
 
     /**
@@ -103,43 +123,22 @@ export class AcpV2Connection {
         });
     }
 
-    /** `updateState`, with send failures caught and logged instead of propagated. */
-    private async sendState(sessionId: string, state: acpV2.StateUpdate): Promise<void> {
-        try {
-            await this.updateState(sessionId, state);
-        } catch (error) {
-            logger.error(`Failed to send the '${state.state}' state for session ${sessionId}`, error);
-        }
-    }
-
-    /**
-     * Sends `session/request_permission`, rendered in the v2 wire shape by
-     * `toV2RequestPermissionRequest`. Per the spec, brackets the request with `requires_action`/
-     * `running` `state_update`s -- but only while a turn is actually running (see
-     * `withStateBracket`); a permission request while idle (e.g. an out-of-turn MCP elicitation's
-     * fallback) is sent with no state update at all.
-     */
+    /** Sends permission requests without mistaking one pending request for a blocked session. */
     async requestPermission(
         request: acp.RequestPermissionRequest,
         options?: acp.SendRequestOptions,
     ): Promise<acp.RequestPermissionResponse> {
-        return this.withStateBracket(request.sessionId, async () => {
+        return this.withUserAction(request.sessionId, request.toolCall.toolCallId, async () => {
             const response = await this.client.request(
                 acpV2.methods.client.session.requestPermission,
                 toV2RequestPermissionRequest(request),
                 options,
             );
             return toV1RequestPermissionResponse(response);
-        });
+        }, options?.cancellationSignal);
     }
 
-    /**
-     * Sends `elicitation/create` (wire-identical request/response between versions, per
-     * `AcpV2Elicitation`). Brackets it with `requires_action`/`running` `state_update`s like
-     * `requestPermission()` (see `withStateBracket`), but only when the elicitation is
-     * session-scoped: a request-scoped elicitation (e.g. device-code login, sent before any
-     * session exists) has no session to attach a state update to, so it is sent unbracketed.
-     */
+    /** Request-scoped login elicitations and idle background elicitations never change state. */
     async createElicitation(
         request: acp.CreateElicitationRequest,
         options?: acp.SendRequestOptions,
@@ -156,7 +155,8 @@ export class AcpV2Connection {
         if (sessionId === undefined) {
             return sendRequest();
         }
-        return this.withStateBracket(sessionId, sendRequest);
+        const toolCallId = "toolCallId" in request && typeof request.toolCallId === "string" ? request.toolCallId : undefined;
+        return this.withUserAction(sessionId, toolCallId, sendRequest, options?.cancellationSignal);
     }
 
     /** Sends `elicitation/complete`, wire-identical between versions. */
 
@@ -0,0 +1,104 @@
+import type * as acpV2 from "@agentclientprotocol/sdk/experimental/v2/unstable";
+import {logger} from "./Logger";
+
+type Activity = "idle" | "running" | "requires_action";
+
+/** Session state and its wire order are independent of prompt acceptance and individual requests. */
+export class AcpV2ForegroundState {
+    private activity: Activity;
+    private readonly items = new Set<string>();
+    private readonly actions = new Map<symbol, string | undefined>();
+    private sending: Promise<void> = Promise.resolve();
+
+    constructor(
+        private readonly notify: (state: acpV2.StateUpdate) => Promise<void>,
+        running = false,
+    ) {
+        this.activity = running ? "running" : "idle";
+    }
+
+    async update(state: acpV2.StateUpdate): Promise<void> {
+        if (state.state === "idle") {
+            this.items.clear();
+            this.actions.clear();
+            if (this.activity === "idle") return this.sending;
+            this.activity = "idle";
+        } else if (state.state === "running" || state.state === "requires_action") {
+            if (this.activity === state.state) return this.sending;
+            this.activity = state.state;
+        }
+        await this.publish(state);
+    }
+
+    /** A newly accepted runtime turn or local command is evidence of foreground work. */
+    async start(): Promise<void> {
+        if (this.activity === "idle" || this.actions.size === 0) await this.update({state: "running"});
+    }
+
+    /** Snapshots never repeat completion usage or failure metadata. */
+    snapshot(): Promise<void> {
+        switch (this.activity) {
+            case "idle":
+                return this.publish({state: "idle"});
+            case "running":
+                return this.publish({state: "running"});
+            case "requires_action":
+                return this.publish({state: "requires_action"});
+        }
+    }
+
+    async startItem(itemId: string): Promise<void> {
+        if (this.activity === "idle") return;
+        this.items.add(itemId);
+        await this.reportActionState();
+    }
+
+    async completeItem(itemId: string): Promise<void> {
+        this.items.delete(itemId);
+        if (this.activity !== "idle" && this.actions.size > 0) await this.reportActionState();
+    }
+
+    async withUserAction<T>(itemId: string | undefined, request: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+        if (signal?.aborted) return request();
+        const action = Symbol();
+        this.actions.set(action, itemId);
+        // The caller only registers actions that belong to active foreground work.
+        if (this.activity === "idle") this.activity = "running";
+        try {
+            await this.reportActionStateSafely();
+            return await request();
+        } finally {
+            // An idle boundary invalidates old waits, even if a new turn has already started.
+            if (this.actions.delete(action) && !signal?.aborted) await this.reportActionStateSafely();
+        }
+    }
+
+    dispose(): void {
+        this.activity = "idle";
+        this.items.clear();
+        this.actions.clear();
+    }
+
+    private reportActionState(): Promise<void> {
+        const blockedItems = new Set(this.actions.values());
+        const runnable = [...this.items].some(itemId => !blockedItems.has(itemId));
+        if (runnable) return this.update({state: "running"});
+        if (this.actions.size > 0) return this.update({state: "requires_action"});
+        // An answer alone does not establish that foreground progress has resumed.
+        return this.sending;
+    }
+
+    private async reportActionStateSafely(): Promise<void> {
+        try {
+            await this.reportActionState();
+        } catch (error) {
+            logger.error("Failed to report foreground user-action state", error);
+        }
+    }
+
+    private publish(state: acpV2.StateUpdate): Promise<void> {
+        const sent = this.sending.then(() => this.notify(state));
+        this.sending = sent.catch(() => {});
+        return sent;
+    }
+}
@@ -116,10 +116,8 @@ export function toV2SessionUpdate(update: AcpSessionUpdate): acpV2.SessionUpdate
                 ...(content !== undefined ? {content: content && content.map(toV2ToolCallContent)} : {}),
             };
         }
-        // Subagent RFD (spec PR #1992, unmerged) uses a single upsert-style update. Sent under a
-        // `_`-prefixed tag because the RFD's `subagent_update` isn't in the v2 unstable schema yet;
-        // rename to `subagent_update` once it lands there. The AIR `nativeSubagentSessions` gate
-        // already ran upstream (whatever created this update), so no gate check is needed here.
+        // Preserve AIR's existing subagent contract. The standard schema uses different fields
+        // and work states; that migration is separate. The AIR capability gate already ran upstream.
         case "subagent_spawned": {
             const {subagentSessionId, name, task, _meta} = update;
             return {
 
@@ -701,6 +701,7 @@ export class CodexAcpClient {
             models: codexModels,
             // Codex sends no thread/settings/updated on a resume. The response holds the mode.
             collaborationMode: response.collaborationMode ?? this.getCollaborationMode(response.thread.id),
+            threadStatus: response.thread.status,
             modelProvider: response.modelProvider,
             currentServiceTier: response.serviceTier as ServiceTier ?? null,
             additionalDirectories,