gestalt-mobile 0.41.0 → 0.41.2

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

@@ -19,7 +19,7 @@ import { authorizationSessionId, authorizedDeviceId, localOwnerId, webAuthnCrede
 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));
@@ -789,13 +808,21 @@ describe('production composition', () => {
             beforeWriteDatabase.close();
             expect(beforeWrite.resolved_at).toBeNull();
             handle.responseSettled({ id: 811, outcome: 'resultWritten' });
-            await expect(checkpointResponse).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+            await expect(checkpointResponse).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
+            const replayResponse = handle.request(l2CheckpointCall(812, threadId, active.active_turn_id, planIdentity));
+            await vi.waitFor(() => expect(handle.pendingResponses.has(812)).toBe(true));
+            handle.responseSettled({ id: 812, outcome: 'resultWritten' });
+            await expect(replayResponse).resolves.toEqual(toOrgPlanCheckpointToolResponse('alreadyRecorded'));
             const afterWriteDatabase = new DatabaseSync(join(fixture.dataDir, 'relay.sqlite'));
             const afterWrite = afterWriteDatabase
                 .prepare('SELECT resolved_at FROM pending_interactions WHERE session_id = ? AND request_id = ?')
                 .get(fixture.sessionId, '811');
+            const checkpointEvents = afterWriteDatabase
+                .prepare("SELECT count(*) AS count FROM session_events WHERE session_id = ? AND type = 'org-plan.step-checkpointed'")
+                .get(fixture.sessionId);
             afterWriteDatabase.close();
             expect(afterWrite.resolved_at).toEqual(expect.any(String));
+            expect(checkpointEvents.count).toBe(1);
             expect(timers).toHaveLength(schedulesBeforeCheckpoint);
             expect(coordinator.snapshot(fixture.sessionId).health).not.toMatchObject({
                 phase: 'waitingForAgentEvent',
@@ -941,7 +968,7 @@ describe('production composition', () => {
             });
             const { handle, response } = await holdCheckpointRequest(fixture, timers, 812, true, true);
             handle.responseSettled({ id: 812, outcome: 'resultWritten' });
-            await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+            await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
             const database = new DatabaseSync(join(fixture.dataDir, 'relay.sqlite'));
             const checkpoint = database
                 .prepare("SELECT count(*) AS count FROM session_events WHERE session_id = ? AND type = 'org-plan.step-checkpointed'")
@@ -950,7 +977,84 @@ describe('production composition', () => {
             expect(checkpoint.count).toBe(1);
             await fixture.app.close();
         });
-        it('leaves an unsupported checkpoint exception before persistence inert', async () => {
+        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 = [];
             const fixture = await createProductionAutopilotFixture({
@@ -969,8 +1073,16 @@ describe('production composition', () => {
             vi.spyOn(coordinator, 'checkpointAccepted').mockImplementation(() => {
                 throw new Error('injected-before-checkpoint-persistence');
             });
-            const { response, startsBefore, writersBefore } = await holdCheckpointRequest(fixture, timers, 995, false);
-            await expect(response).rejects.toThrow('CODEX_SERVER_REQUEST_UNSUPPORTED');
+            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' });
+            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
@@ -1139,7 +1251,7 @@ describe('production composition', () => {
             };
             if (scenario === 'resultWritten-before-timeout') {
                 handle.responseSettled({ id: 992, outcome: 'resultWritten' });
-                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
                 await new Promise((resolve) => setTimeout(resolve, 30));
                 expect(fixture.handles).toHaveLength(writersBefore);
                 expect(failures()).toBe(0);
@@ -1147,7 +1259,7 @@ describe('production composition', () => {
             else if (scenario === 'duplicate-settlement') {
                 handle.responseSettled({ id: 992, outcome: 'resultWritten' });
                 handle.responseSettled({ id: 992, outcome: 'resultWritten' });
-                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
                 await new Promise((resolve) => setTimeout(resolve, 30));
                 expect(fixture.handles).toHaveLength(writersBefore);
                 expect(failures()).toBe(0);
@@ -1292,7 +1404,7 @@ describe('production composition', () => {
             expect(approvalTurn.statusCode).toBe(202);
             await approvalFixture.app.close();
         });
-        it('rejects a checkpoint delivered after its owning root final has closed', async () => {
+        it('returns failed for a checkpoint delivered after its owning root final has closed', async () => {
             const timers = [];
             const fixture = await createProductionAutopilotFixture({
                 autopilotSchedule: (callback) => {
@@ -1330,7 +1442,13 @@ 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))).rejects.toThrow('CODEX_SERVER_REQUEST_UNSUPPORTED');
+            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)
@@ -1346,6 +1464,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' },
             }));
@@ -1355,7 +1474,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 },
@@ -1949,6 +2067,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-'));
@@ -1994,6 +2162,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' }),
             ]));
@@ -2003,12 +2172,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' }),
             ]));
@@ -2016,13 +2185,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',
             }));
@@ -2031,9 +2197,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();
@@ -2064,6 +2227,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',
@@ -2086,11 +2250,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',
@@ -2101,7 +2265,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' } },
             }));
@@ -2140,10 +2303,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`,
@@ -2154,9 +2315,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,
@@ -2195,7 +2354,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);
@@ -2220,18 +2379,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,
@@ -2244,7 +2402,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`,
@@ -3693,6 +3851,7 @@ describe('production composition', () => {
                     },
                 },
             });
+            await expect(attention).resolves.toEqual(toOrgPlanAttentionAcknowledgement());
             await vi.waitFor(async () => {
                 expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
                     pendingInteractions: [
@@ -3737,7 +3896,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`,
@@ -3763,8 +3921,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',
@@ -3778,6 +3936,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' } },
             }));
@@ -3785,14 +3944,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,