gestalt-mobile 0.41.1 → 0.41.3

package/dist/client/index.html

@@ -16,7 +16,7 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-G2PznC5F.js"></script>
+    <script type="module" crossorigin src="/assets/index-BRly-q56.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D57mr3B1.css">
   </head>
   <body>

package/dist/server/server/composition.contracts.js

@@ -12,14 +12,14 @@ import { join } from 'node:path';
 import { describe, expect, it, onTestFinished, vi } from 'vitest';
 import WebSocket from 'ws';
 import { composeRelayApp } from './composition.js';
-import { AUTOPILOT_CONTINUATION_PROMPT } from './features/autopilot/application/policy.js';
+import { autopilotExecutorLaunchPrompt } from './features/autopilot/application/policy.js';
 import { CodexJsonRpcError } from './platform/codex/json-rpc-client.js';
 import { SqliteAuthorizationStore } from './platform/auth/sqlite-authorization-store.js';
 import { authorizationSessionId, authorizedDeviceId, localOwnerId, webAuthnCredentialId, } from './features/auth/domain/identifiers.js';
 import { deviceNickname } from './features/auth/domain/device-nickname.js';
 import { workspaceId } from './platform/catalog/workspace-id.js';
 import { planStatusDirectoryPath, planStatusFilePath, } from './platform/plans/filesystem-plan-status-source.js';
-import { toOrgPlanAttentionToolResponse } from '../shared/contracts/org-plan-attention.js';
+import { toOrgPlanAttentionAcknowledgement, toOrgPlanAttentionToolResponse, } from '../shared/contracts/org-plan-attention.js';
 import { toOrgPlanCheckpointToolResponse } from '../shared/contracts/org-plan-checkpoint.js';
 import { applyProjectionEvent, createChatProjection, } from '../client/features/chat/chat-projection.js';
 function fakeAppServer(calls) {
@@ -153,6 +153,25 @@ const autopilotPlanText = (childState = 'TODO') => `#+TITLE: Autopilot fixture
 const completedAutopilotPlanText = () => autopilotPlanText('DONE')
     .replace('* WIP [#A] Parent', '* DONE [#A] Parent')
     .replace(':REVIEW_STATUS: UNREVIEWED', ':REVIEW_STATUS: REVIEWED');
+const acceptedL1WithNextTodoPlanText = () => `${completedAutopilotPlanText()}
+* TODO [#B] Next parent
+:PROPERTIES:
+:ID: next-parent
+:SKILLS: $gestalt:org-plan
+:REVIEW_STATUS: UNREVIEWED
+:END:
+- Effort :: Small
+- Goal :: Continue on the next root turn.
+- Notes :: Must remain pending at the accepted-L1 boundary.
+** TODO [#B] Next child
+:PROPERTIES:
+:ID: next-child
+:END:
+- Why :: Verify boundary separation.
+- Change :: Start only after durable handoff.
+- Tests :: Exercise the next continuation.
+- Done when :: The next L1 starts exactly once.
+`;
 async function installAutopilotPlan(app, sessionId, workspacePath, name, childState = 'TODO', reason = 'supervision-start') {
     const planPath = join(workspacePath, `${name}.org`);
     await writeFile(planPath, autopilotPlanText(childState));
@@ -478,7 +497,12 @@ describe('production composition', () => {
                 input: [
                     {
                         type: 'text',
-                        text: `${AUTOPILOT_CONTINUATION_PROMPT} Launch task_name l1 for canonical L1; retain the canonical label in status and review output.`,
+                        text: autopilotExecutorLaunchPrompt({
+                            canonicalTaskName: 'l1',
+                            canonicalPosition: 'L1',
+                            generation: 1,
+                            taskName: 'l1',
+                        }),
                         text_elements: [],
                     },
                 ],
@@ -958,6 +982,83 @@ describe('production composition', () => {
             expect(checkpoint.count).toBe(1);
             await fixture.app.close();
         });
+        it('records and idempotently replays accepted L1 after REVIEWED advances to the next TODO L1', async () => {
+            const timers = [];
+            const fixture = await createProductionAutopilotFixture({
+                autopilotSchedule: (callback) => {
+                    const timer = { callback, cancelled: false, fired: false };
+                    timers.push(timer);
+                    return () => {
+                        timer.cancelled = true;
+                    };
+                },
+            });
+            const initial = timers.find((timer) => !timer.cancelled && !timer.fired);
+            initial.fired = true;
+            initial.callback();
+            await vi.waitFor(() => expect(fixture.handles.flatMap((candidate) => candidate.requests.filter((request) => request.method === 'turn/start'))).toHaveLength(1));
+            const handle = fixture.handles.find((candidate) => candidate.request);
+            const session = (await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json();
+            const threadId = session.threadId;
+            const turnId = session.activeTurnId;
+            await writeFile(join(fixture.workspacePath, 'autopilot.org'), acceptedL1WithNextTodoPlanText());
+            await expect
+                .poll(async () => (await fixture.app.inject(`/api/sessions/${fixture.sessionId}/plan`)).json()
+                .currentStepId)
+                .toBe('next-parent');
+            handle.deferResponseSettlement = true;
+            const checkpointCall = (id) => ({
+                id,
+                method: 'item/tool/call',
+                params: {
+                    threadId,
+                    turnId,
+                    tool: 'gestalt_org_plan_checkpoint',
+                    arguments: { kind: 'l1Accepted' },
+                },
+            });
+            const startsBefore = fixture.handles
+                .flatMap((candidate) => candidate.requests)
+                .filter((request) => request.method === 'turn/start').length;
+            const first = handle.request(checkpointCall(813));
+            await vi.waitFor(() => expect(handle.pendingResponses.has(813)).toBe(true));
+            handle.responseSettled({ id: 813, outcome: 'resultWritten' });
+            await expect(first).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
+            const replay = handle.request(checkpointCall(814));
+            await vi.waitFor(() => expect(handle.pendingResponses.has(814)).toBe(true));
+            handle.responseSettled({ id: 814, outcome: 'resultWritten' });
+            await expect(replay).resolves.toEqual(toOrgPlanCheckpointToolResponse('alreadyRecorded'));
+            const database = new DatabaseSync(join(fixture.dataDir, 'relay.sqlite'));
+            const acceptedEvents = database
+                .prepare("SELECT count(*) AS count FROM session_events WHERE session_id = ? AND type = 'org-plan.milestone-checkpointed'")
+                .get(fixture.sessionId);
+            const pendingInteractions = database
+                .prepare('SELECT count(*) AS count FROM pending_interactions WHERE session_id = ? AND resolved_at IS NULL')
+                .get(fixture.sessionId);
+            database.close();
+            expect(acceptedEvents.count).toBe(1);
+            expect(pendingInteractions.count).toBe(0);
+            expect(fixture.handles
+                .flatMap((candidate) => candidate.requests)
+                .filter((request) => request.method === 'turn/start')).toHaveLength(startsBefore);
+            handle.notify({ method: 'turn/completed', params: { threadId, turn: { id: turnId } } });
+            await expect
+                .poll(async () => (await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json().activeTurnId)
+                .toBeNull();
+            const startedTurns = () => fixture.handles
+                .flatMap((candidate) => candidate.requests)
+                .filter((request) => request.method === 'turn/start').length;
+            for (let attempts = 0; attempts < 3 && startedTurns() === startsBefore; attempts += 1) {
+                await vi.waitFor(() => expect(timers.find((timer) => !timer.cancelled && !timer.fired)).toBeDefined());
+                const continuation = timers.find((timer) => !timer.cancelled && !timer.fired);
+                continuation.fired = true;
+                continuation.callback();
+                await vi.waitFor(() => expect(startedTurns() > startsBefore ||
+                    timers.some((timer) => !timer.cancelled && !timer.fired)).toBe(true));
+            }
+            await vi.waitFor(() => expect(startedTurns()).toBe(startsBefore + 1));
+            await fixture.app.close();
+        });
         it('returns a typed failed checkpoint result when persistence never occurs', async () => {
             let coordinator;
             const timers = [];
@@ -980,7 +1081,13 @@ describe('production composition', () => {
             const { handle, response, startsBefore, writersBefore } = await holdCheckpointRequest(fixture, timers, 995, false);
             await vi.waitFor(() => expect(handle.pendingResponses.has(995)).toBe(true));
             handle.responseSettled({ id: 995, outcome: 'resultWritten' });
-            await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('failed'));
+            const failure = (await response);
+            expect(failure.success).toBe(false);
+            expect(JSON.parse(failure.contentItems[0].text)).toMatchObject({
+                status: 'failed',
+                reasonCode: 'checkpointPersistenceFailed',
+                correlationId: expect.any(String),
+            });
             expect(coordinator.checkpointAccepted).not.toBe(original);
             expect(fixture.handles).toHaveLength(writersBefore);
             expect(fixture.handles
@@ -1340,14 +1447,20 @@ describe('production composition', () => {
             const planIdentity = createHash('sha256')
                 .update(join(fixture.workspacePath, 'autopilot.org'))
                 .digest('hex');
-            await expect(handle.request(l2CheckpointCall(812, threadId, active.active_turn_id, planIdentity))).resolves.toEqual(toOrgPlanCheckpointToolResponse('failed'));
+            const rejected = (await handle.request(l2CheckpointCall(812, threadId, active.active_turn_id, planIdentity)));
+            expect(rejected.success).toBe(false);
+            expect(JSON.parse(rejected.contentItems[0].text)).toMatchObject({
+                status: 'failed',
+                reasonCode: 'rootNotOwner',
+                correlationId: expect.any(String),
+            });
             expect(timers).toHaveLength(timersAfterFinal);
             expect(fixture.handles
                 .flatMap((candidate) => candidate.requests)
                 .filter((request) => request.method === 'turn/start')).toHaveLength(startsAfterFinal);
             await fixture.app.close();
         });
-        it('production attention request requires explicit re-enable and a complete plan transitions to completed', async () => {
+        it('production attention approval resumes Autopilot and a complete plan transitions to completed', async () => {
             const fixture = await createProductionAutopilotFixture();
             const handle = fixture.handles.find((candidate) => candidate.request);
             expect((await fixture.app.inject({
@@ -1356,6 +1469,7 @@ describe('production composition', () => {
                 payload: { enabled: true },
             })).statusCode).toBe(200);
             const attention = handle.request(attentionCall(810));
+            await expect(attention).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(async () => expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
                 autopilot: { state: 'attentionRequired', enabled: false, reason: 'attentionRequired' },
             }));
@@ -1365,16 +1479,6 @@ describe('production composition', () => {
                 url: `/api/sessions/${fixture.sessionId}/attention/810/resolve`,
                 payload: { operationKey: 'resume-attention', action: 'resume' },
             })).statusCode).toBe(202);
-            await expect(attention).resolves.toEqual(toOrgPlanAttentionToolResponse({ action: 'resume' }));
-            await new Promise((resolve) => setTimeout(resolve, 25));
-            expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
-                autopilot: { state: 'attentionRequired', enabled: false },
-            });
-            expect((await fixture.app.inject({
-                method: 'PUT',
-                url: `/api/sessions/${fixture.sessionId}/autopilot`,
-                payload: { enabled: true },
-            })).statusCode).toBe(200);
             await vi.waitFor(async () => expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
                 autopilot: { enabled: true, state: expect.stringMatching(/monitoring|backoff/) },
             }));
@@ -1662,7 +1766,7 @@ describe('production composition', () => {
             // rejected child continuation; it must never target the dead child.
             expect((starts[3]?.params).threadId).not.toBe('child-1');
             expect((starts[3]?.params).input?.[0]?.text).toContain('Launch task_name l1_g2 for canonical L1');
-            expect((starts[3]?.params).input?.[0]?.text).toContain('explicit model selected by the supervisor');
+            expect((starts[3]?.params).input?.[0]?.text).toContain('agent_type org-plan-executor and reasoning_effort high');
             // Capacity recovery is allowed only for the active root control. It
             // recycles that writer but must retain the one durable g2 handoff.
             const rootHandle = fixture.handles.find((candidate) => candidate.requests.some((request) => request.method === 'turn/start' &&
@@ -1959,6 +2063,56 @@ describe('production composition', () => {
         });
     });
     describeCompositionConcern('attention', () => {
+        it('bounds a wedged attention acknowledgement writer without losing durable attention', async () => {
+            const fixture = await createProductionAutopilotFixture({
+                attentionAcknowledgementDeadlineMs: 100,
+            });
+            const handle = fixture.handles.find((candidate) => candidate.request);
+            handle.deferResponseSettlement = true;
+            const response = handle.request(attentionCall(699));
+            const rejected = expect(response).rejects.toThrow('CODEX_SERVER_REQUEST_CANCELLED');
+            await vi.waitFor(() => expect(handle.pendingResponses.has(699)).toBe(true));
+            await rejected;
+            expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}/attention`)).json()).toMatchObject({ requestId: '699', attention: { reason: 'hardBlock' } });
+            await fixture.app.close();
+        });
+        it('returns a bounded failure when durable attention persistence fails', async () => {
+            const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
+            const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
+            ownTemporaryPaths(root, dataDir);
+            await mkdir(join(root, 'workspace'));
+            const handles = [];
+            const app = await composeAuthorizedApp({
+                root,
+                dataDir,
+                relyingParty,
+                installedCodexVersion: 'codex-cli 0.144.3',
+                startAppServers: true,
+                launchAppServer: liveAppServer(handles),
+                profiles: {
+                    list: async () => [],
+                    require: async () => ({
+                        name: 'default',
+                        state: 'ok',
+                        status: 'ready',
+                    }),
+                },
+            });
+            await createComposedSession(app);
+            const handle = await vi.waitFor(() => {
+                const candidate = handles.find((item) => item.request);
+                expect(candidate).toBeDefined();
+                return candidate;
+            });
+            const database = new DatabaseSync(join(dataDir, 'relay.sqlite'));
+            database.exec(`CREATE TRIGGER reject_attention_insert
+        BEFORE INSERT ON pending_interactions
+        WHEN NEW.kind = 'orgPlanAttention'
+        BEGIN SELECT RAISE(ABORT, 'injected attention persistence failure'); END`);
+            database.close();
+            await expect(handle.request(attentionCall(700))).resolves.toEqual(toOrgPlanAttentionAcknowledgement({ accepted: false, reason: 'persistenceFailed' }));
+            await app.close();
+        });
         it('publishes isolated typed required, resolved, and failed attention transitions through the feature-only seam', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
@@ -2004,6 +2158,7 @@ describe('production composition', () => {
             const unsubscribeA = transitions.subscribe(sessionA, (event) => receivedA.push(event));
             const unsubscribeB = transitions.subscribe(sessionB, (event) => receivedB.push(event));
             const resolving = handleA.request(attentionCall(701));
+            await expect(resolving).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(() => expect(receivedA).toEqual([
                 expect.objectContaining({ kind: 'required', requestId: '701' }),
             ]));
@@ -2013,12 +2168,12 @@ describe('production composition', () => {
                 url: `/api/sessions/${sessionA}/attention/701/resolve`,
                 payload: { operationKey: 'resolve-a', action: 'resume' },
             })).statusCode).toBe(202);
-            await expect(resolving).resolves.toEqual(toOrgPlanAttentionToolResponse({ action: 'resume' }));
             await vi.waitFor(() => expect(receivedA).toEqual([
                 expect.objectContaining({ kind: 'required', requestId: '701' }),
                 expect.objectContaining({ kind: 'resolved', requestId: '701' }),
             ]));
             const failing = handleB.request(attentionCall(702, 'permissionRequired'));
+            await expect(failing).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(() => expect(receivedB).toEqual([
                 expect.objectContaining({ kind: 'required', requestId: '702' }),
             ]));
@@ -2026,13 +2181,10 @@ describe('production composition', () => {
                 method: 'serverRequest/resolved',
                 params: { threadId: 'thread-ignored', requestId: 702 },
             });
-            await expect(failing).rejects.toMatchObject({ message: 'CODEX_SERVER_REQUEST_CLEARED' });
-            await vi.waitFor(() => expect(receivedB).toEqual([
-                expect.objectContaining({ kind: 'required', requestId: '702' }),
-                expect.objectContaining({ kind: 'failed', requestId: '702' }),
-            ]));
+            expect(receivedB).toEqual([expect.objectContaining({ kind: 'required', requestId: '702' })]);
             unsubscribeA();
             const afterUnsubscribe = handleA.request(attentionCall(703));
+            await expect(afterUnsubscribe).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(async () => expect((await app.inject(`/api/sessions/${sessionA}/attention`)).json()).toMatchObject({
                 requestId: '703',
             }));
@@ -2041,9 +2193,6 @@ describe('production composition', () => {
                 method: 'serverRequest/resolved',
                 params: { threadId: 'thread-ignored', requestId: 703 },
             });
-            await expect(afterUnsubscribe).rejects.toMatchObject({
-                message: 'CODEX_SERVER_REQUEST_CLEARED',
-            });
             expect(receivedA).toHaveLength(2);
             unsubscribeB();
             await app.close();
@@ -2074,6 +2223,7 @@ describe('production composition', () => {
             await vi.waitFor(() => expect(handles.find((handle) => handle.request)?.request).toBeDefined());
             const handle = handles.find((candidate) => candidate.calls.includes('thread/start'));
             const attentionFirst = handle.request(attentionCall(711, 'permissionRequired'));
+            await expect(attentionFirst).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             const inputFirst = handle.request({
                 id: 712,
                 method: 'item/tool/requestUserInput',
@@ -2096,11 +2246,11 @@ describe('production composition', () => {
                 url: `/api/sessions/${sessionId}/attention/711/resolve`,
                 payload: { operationKey: 'attention-first', action: 'resume' },
             });
-            await expect(attentionFirst).resolves.toEqual(toOrgPlanAttentionToolResponse({ action: 'resume' }));
             await vi.waitFor(async () => expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
                 agentActivity: { root: { state: 'working' } },
             }));
             const attentionSecond = handle.request(attentionCall(713));
+            await expect(attentionSecond).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             const inputSecond = handle.request({
                 id: 714,
                 method: 'item/tool/requestUserInput',
@@ -2111,7 +2261,6 @@ describe('production composition', () => {
                 url: `/api/sessions/${sessionId}/attention/713/resolve`,
                 payload: { operationKey: 'attention-second', action: 'resume' },
             });
-            await expect(attentionSecond).resolves.toEqual(toOrgPlanAttentionToolResponse({ action: 'resume' }));
             await vi.waitFor(async () => expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
                 agentActivity: { root: { state: 'awaitingHuman', reason: 'pendingInteraction' } },
             }));
@@ -2150,10 +2299,8 @@ describe('production composition', () => {
             const handle = handles.find((candidate) => candidate.calls.includes('thread/start'));
             const active = handle.request(attentionCall(801));
             const terminal = handle.request(attentionCall(802));
-            const terminalResponse = toOrgPlanAttentionToolResponse({
-                action: 'resume',
-                guidance: 'Sensitive terminal guidance.',
-            });
+            await expect(active).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
+            await expect(terminal).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             const accepted = await first.inject({
                 method: 'POST',
                 url: `/api/sessions/${sessionId}/attention/802/resolve`,
@@ -2164,9 +2311,7 @@ describe('production composition', () => {
                 },
             });
             const resolvedAt = accepted.json().resolvedAt;
-            await expect(terminal).resolves.toEqual(terminalResponse);
             await first.close();
-            await expect(active).rejects.toMatchObject({ message: 'CODEX_SERVER_REQUEST_CANCELLED' });
             const reopened = await composeAuthorizedApp({
                 root,
                 dataDir,
@@ -2205,7 +2350,7 @@ describe('production composition', () => {
             })).json()).toEqual({ code: 'ATTENTION_OPERATION_STALE' });
             await reopened.close();
         });
-        it('reports supported offline writers separately from legacy sessions without the attention capability', async () => {
+        it('resolves acknowledged attention offline while retaining legacy writer diagnostics', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
             ownTemporaryPaths(root, dataDir);
@@ -2230,18 +2375,17 @@ describe('production composition', () => {
             const started = handles.filter((handle) => handle.calls.includes('thread/start'));
             const supportedRequest = started[0].request(attentionCall(901));
             const legacyRequest = started[1].request(attentionCall(902));
+            await expect(supportedRequest).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
+            await expect(legacyRequest).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(async () => expect((await first.inject(`/api/sessions/${legacySession}/attention`)).statusCode).toBe(200));
             await first.close();
-            await expect(supportedRequest).rejects.toMatchObject({
-                message: 'CODEX_SERVER_REQUEST_CANCELLED',
-            });
-            await expect(legacyRequest).rejects.toMatchObject({
-                message: 'CODEX_SERVER_REQUEST_CANCELLED',
-            });
             const database = new DatabaseSync(join(dataDir, 'relay.sqlite'));
             database
                 .prepare('UPDATE relay_sessions SET attention_tool_capability = NULL WHERE id = ?')
                 .run(legacySession);
+            database
+                .prepare("UPDATE pending_interactions SET resolution_state = 'active' WHERE session_id = ? AND request_id = '902'")
+                .run(legacySession);
             database.close();
             const offline = await composeAuthorizedApp({
                 root,
@@ -2254,7 +2398,7 @@ describe('production composition', () => {
                 method: 'POST',
                 url: `/api/sessions/${supportedSession}/attention/901/resolve`,
                 payload: { operationKey: 'offline-supported', action: 'resume' },
-            })).json()).toEqual({ code: 'ATTENTION_WRITER_UNAVAILABLE' });
+            })).statusCode).toBe(202);
             expect((await offline.inject({
                 method: 'POST',
                 url: `/api/sessions/${legacySession}/attention/902/resolve`,
@@ -3703,6 +3847,7 @@ describe('production composition', () => {
                     },
                 },
             });
+            await expect(attention).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(async () => {
                 expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
                     pendingInteractions: [
@@ -3747,7 +3892,6 @@ describe('production composition', () => {
                     guidance: 'The release permission is now granted.',
                 },
             })).toMatchObject({ statusCode: 202 });
-            expect(await attention).toEqual(attentionResponse);
             expect((await app.inject({
                 method: 'POST',
                 url: `/api/sessions/${sessionId}/attention/8/resolve`,
@@ -3773,8 +3917,8 @@ describe('production composition', () => {
                 }),
             ]));
             expect(JSON.stringify(attentionHistory)).not.toContain('The release permission is now granted.');
-            // A server-cleared attention request is a durable failed audit and must
-            // re-project the root rather than leaving the GUI awaiting a vanished alert.
+            // Clearing the already-acknowledged dynamic request must not erase the
+            // durable attention record or wedge the caller.
             const clearedAttention = handle.request({
                 id: 9,
                 method: 'item/tool/call',
@@ -3788,6 +3932,7 @@ describe('production composition', () => {
                     },
                 },
             });
+            await expect(clearedAttention).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(async () => expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
                 agentActivity: { root: { state: 'awaitingHuman' } },
             }));
@@ -3795,14 +3940,11 @@ describe('production composition', () => {
                 method: 'serverRequest/resolved',
                 params: { threadId: 'thread-1', requestId: 9 },
             });
-            await expect(clearedAttention).rejects.toMatchObject({
-                message: 'CODEX_SERVER_REQUEST_CLEARED',
-            });
             await vi.waitFor(async () => expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
-                agentActivity: { root: { state: 'working' } },
+                agentActivity: { root: { state: 'awaitingHuman' } },
             }));
             expect((await app.inject(`/api/sessions/${sessionId}/history`)).json().interactions).toEqual(expect.arrayContaining([
-                expect.objectContaining({ requestId: '9', kind: 'orgPlanAttention', outcome: 'failed' }),
+                expect.objectContaining({ requestId: '9', kind: 'orgPlanAttention', resolvedAt: null }),
             ]));
             const quiz = handle.request({
                 id: 71,