gestalt-mobile 0.35.2 → 0.35.4

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

@@ -2242,6 +2242,65 @@ describe('production composition', () => {
         });
     });
     describeCompositionConcern('lifecycle', () => {
+        it('rejects a wait lease when automatic continuation is unavailable', 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',
+                    }),
+                },
+            });
+            const sessionId = await createComposedSession(app);
+            const handle = handles.find((candidate) => candidate.calls.includes('thread/start'));
+            const started = await app.inject({
+                method: 'POST',
+                url: `/api/sessions/${sessionId}/turns`,
+                payload: { text: 'continue supervised work' },
+            });
+            const turnId = started.json().activeTurnId;
+            const threadId = (await app.inject(`/api/sessions/${sessionId}`)).json().threadId;
+            handle.notify?.({ method: 'turn/started', params: { threadId, turn: { id: turnId } } });
+            await expect(handle.request({
+                id: 89,
+                method: 'item/tool/call',
+                params: {
+                    threadId,
+                    turnId,
+                    tool: 'gestalt_autopilot_wait_lease',
+                    arguments: {
+                        version: 2,
+                        reportId: 'unavailable-report',
+                        leaseId: 'unavailable-lease',
+                        wakeConditions: ['executorChanged'],
+                        maxWaitMs: 60_000,
+                    },
+                },
+            })).resolves.toEqual({
+                success: true,
+                contentItems: [
+                    {
+                        type: 'inputText',
+                        text: '{"accepted":false,"reason":"automaticContinuationUnavailable","next":"continueSameTurn"}',
+                    },
+                ],
+            });
+            expect((await app.inject(`/api/sessions/${sessionId}`)).json().activeTurnId).toBe(turnId);
+            await app.close();
+        });
         it('acknowledges root-owned capacity recovery before recycling only its app-server', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));

package/dist/server/server/composition.js

@@ -581,14 +581,14 @@ export async function composeRelayApp(options) {
                 const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
                 if (rootOwned)
                     autopilot.rejectProbe(sessionId);
-                return (runtime?.resolveServerRequest(sessionId, String(request.id), autopilotWaitLeaseToolResponse()) === true);
+                return (runtime?.resolveServerRequest(sessionId, String(request.id), autopilotWaitLeaseToolResponse(false)) === true);
             }
             if (!rawInteraction)
                 return false;
             if (rawInteraction.kind === 'autopilotWaitLease') {
                 const lease = rawInteraction.payload;
                 const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
-                const accepted = rootOwned &&
+                const registration = rootOwned &&
                     (lease.version === 2
                         ? autopilot.registerProactiveWait(sessionId, {
                             id: lease.reportId,
@@ -602,10 +602,12 @@ export async function composeRelayApp(options) {
                             leaseId: lease.leaseId,
                             wakeConditions: lease.wakeConditions,
                         }));
-                if (!accepted) {
-                    if (rootOwned)
+                if (registration !== true) {
+                    if (rootOwned && registration === false)
                         autopilot.rejectProbe(sessionId);
-                    return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, autopilotWaitLeaseToolResponse()) === true);
+                    return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, autopilotWaitLeaseToolResponse(false, registration === 'wakeAlreadySatisfied'
+                        ? 'wakeAlreadySatisfied'
+                        : 'automaticContinuationUnavailable')) === true);
                 }
                 return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, autopilotWaitLeaseToolResponse()) === true);
             }

package/dist/server/server/features/autopilot/application/service.js

@@ -162,6 +162,24 @@ export class AutopilotCoordinator {
             report.maxWaitMs > AUTOPILOT_WAIT_MAX_MS)
             return false;
         const now = this.deps.now();
+        if (this.executorWakeAlreadySatisfied(sessionId, state, report.wakeConditions)) {
+            // The executor edge is already visible. Fence every pending automatic
+            // callback before returning control to the still-active root; otherwise
+            // a scheduled executor resume could race same-turn supervision.
+            const cancelled = this.cancelScheduledControl(state, now);
+            this.persist({
+                ...state,
+                generation: state.generation + 1,
+                ...(cancelled ? { lastControlId: null } : {}),
+                nextEvaluationAt: null,
+                updatedAt: now,
+            }, cancelled);
+            this.timers.get(sessionId)?.();
+            this.timers.delete(sessionId);
+            this.completionTimers.get(sessionId)?.();
+            this.completionTimers.delete(sessionId);
+            return 'wakeAlreadySatisfied';
+        }
         const resumeAt = new Date(Date.parse(now) + report.maxWaitMs).toISOString();
         const protocol = state.supervision ?? startSupervisionProtocol(this.progressKey(sessionId));
         const nextProtocol = registerProtocolWait(protocol, { ...report, resumeAt });
@@ -185,6 +203,19 @@ export class AutopilotCoordinator {
         this.armWaitDeadline(sessionId, report.leaseId, resumeAt);
         return true;
     }
+    /** Prevents an edge-triggered executor lease from parking after its edge. */
+    executorWakeAlreadySatisfied(sessionId, state, wakeConditions) {
+        if (!wakeConditions.includes('executorChanged'))
+            return false;
+        if (this.completionTimers.has(sessionId))
+            return true;
+        const retained = this.deps.plan(sessionId);
+        const activity = this.deps.activity(sessionId);
+        if (!retained || activity?.confidence !== 'fresh')
+            return false;
+        const executor = this.currentExecutor(sessionId, retained.plan, state.consecutiveNoProgress, state.executor);
+        return Boolean(executor && !this.authoritativeExecutorActive(state, retained.plan, activity));
+    }
     /** Fails closed only for the currently active bounded probe. */
     rejectProbe(sessionId) {
         const state = this.deps.store.find(sessionId);
@@ -1074,6 +1105,10 @@ export class AutopilotCoordinator {
         this.completionTimers.delete(sessionId);
         this.executorTimers.get(sessionId)?.();
         this.executorTimers.delete(sessionId);
+        this.cancelScheduledExecutorCommands(sessionId);
+    }
+    /** Cancels executor authority while allowing a delivered stale callback to audit itself. */
+    cancelScheduledExecutorCommands(sessionId) {
         const state = this.deps.store.find(sessionId);
         const executor = state?.executor;
         if (state && executor?.commands?.some((command) => command.status === 'scheduled'))

package/dist/server/shared/contracts/autopilot-wait-lease.js

@@ -20,7 +20,7 @@ export const AUTOPILOT_WAIT_MAX_MS = 86_400_000;
 export const gestaltAutopilotWaitLeaseDynamicTool = {
     type: 'function',
     name: GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME,
-    description: 'Register one non-persistent Autopilot wait episode for the current supervised session. Version 2 may be called proactively for known long work and resumes on the first requested event or bounded maxWaitMs deadline; call it again in a later turn only if another long wait is justified. This cannot request human authority and never accepts transcript prose.',
+    description: 'Register one non-persistent Autopilot wait episode for the current supervised session. Version 2 may be called proactively for known long work and resumes on the first requested event or bounded maxWaitMs deadline; call it again in a later turn only if another long wait is justified. Yield only when the response has accepted:true; accepted:false requires same-turn supervision. This cannot request human authority and never accepts transcript prose.',
     inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -74,8 +74,18 @@ export function parseAutopilotWaitLease(value) {
         maxWaitMs: value.maxWaitMs,
     };
 }
-export function autopilotWaitLeaseToolResponse() {
-    return { success: true, contentItems: [{ type: 'inputText', text: '{"accepted":true}' }] };
+export function autopilotWaitLeaseToolResponse(accepted = true, reason = 'automaticContinuationUnavailable') {
+    return {
+        success: true,
+        contentItems: [
+            {
+                type: 'inputText',
+                text: accepted
+                    ? '{"accepted":true}'
+                    : JSON.stringify({ accepted: false, reason, next: 'continueSameTurn' }),
+            },
+        ],
+    };
 }
 function record(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.35.2",
+  "version": "0.35.4",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",