gestalt-mobile 0.32.0 → 0.32.1

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

@@ -1368,6 +1368,87 @@ describe('production composition', () => {
         });
     });
     describeCompositionConcern('lifecycle', () => {
+        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-'));
+            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 first = handles.find((candidate) => candidate.calls.includes('thread/start'));
+            expect(first?.request).toBeDefined();
+            const started = await app.inject({
+                method: 'POST',
+                url: `/api/sessions/${sessionId}/turns`,
+                payload: { text: 'continue supervised work' },
+            });
+            expect(started.statusCode).toBe(202);
+            const turnId = started.json().activeTurnId;
+            const threadId = (await app.inject(`/api/sessions/${sessionId}`)).json().threadId;
+            const handlesBeforeRecovery = handles.length;
+            first.notify?.({
+                method: 'turn/started',
+                params: { threadId, turn: { id: turnId } },
+            });
+            await expect(first.request({
+                id: 90,
+                method: 'item/tool/call',
+                params: {
+                    threadId: 'child-thread',
+                    turnId,
+                    tool: 'gestalt_agent_capacity_recovery',
+                    arguments: { version: 1, reason: 'agentThreadLimit' },
+                },
+            })).rejects.toThrow('CODEX_SERVER_REQUEST_UNSUPPORTED');
+            expect(handles).toHaveLength(handlesBeforeRecovery);
+            await expect(first.request({
+                id: 91,
+                method: 'item/tool/call',
+                params: {
+                    threadId,
+                    turnId,
+                    tool: 'gestalt_agent_capacity_recovery',
+                    arguments: { version: 1, reason: 'agentThreadLimit' },
+                },
+            })).resolves.toEqual({
+                success: true,
+                contentItems: [
+                    { type: 'inputText', text: '{"accepted":true,"action":"sessionRuntimeRecycle"}' },
+                ],
+            });
+            await expect.poll(() => handles.length).toBeGreaterThan(handlesBeforeRecovery);
+            const replacement = handles.find((candidate) => candidate !== first &&
+                candidate.requests.some((request) => request.method === 'thread/resume'));
+            expect(replacement?.requests).toContainEqual({
+                method: 'thread/resume',
+                params: expect.objectContaining({ threadId, cwd: join(root, 'workspace') }),
+            });
+            await expect
+                .poll(async () => (await app.inject(`/api/sessions/${sessionId}`)).json().state)
+                .toBe('ready');
+            expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
+                threadId,
+                activeTurnId: null,
+                desiredState: 'active',
+            });
+            await app.close();
+        });
         it('publishes an idle websocket status after saving a completed turn', 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

@@ -36,7 +36,7 @@ import { RelaySession, } from './features/sessions/model/relay-session.js';
 import { AgentActivityRegistry } from './features/agent-activity/registry.js';
 import { toAgentActivityDto } from './features/agent-activity/activity-dto.js';
 import { decodeAgentActivityFacts } from './platform/codex/activity-facts.js';
-import { isAutopilotWaitLeaseCall, resolvedServerRequestId, toPendingInteraction, } from './platform/codex/server-request.js';
+import { isAgentCapacityRecoveryCall, isAutopilotWaitLeaseCall, resolvedServerRequestId, toPendingInteraction, } from './platform/codex/server-request.js';
 import { parseOrgPlanCheckpoint, toOrgPlanCheckpointToolResponse, } from '../shared/contracts/org-plan-checkpoint.js';
 import { validOrgPlanCheckpoint } from './features/org-plan-checkpoint/application/validate.js';
 import { isValidInteractionResponse, isValidQuizInteractionResponse, } from './features/sessions/interaction/response-validator.js';
@@ -58,6 +58,7 @@ import { createRelyingPartyConfig } from './config.js';
 import { parseOrgPlanAttention } from '../shared/contracts/org-plan-attention.js';
 import { GestaltUpdateRestartScheduler } from './platform/process/gestalt-update-restart.js';
 import { autopilotWaitLeaseToolResponse, } from '../shared/contracts/autopilot-wait-lease.js';
+import { agentCapacityRecoveryToolResponse } from '../shared/contracts/agent-capacity-recovery.js';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
 export async function composeRelayApp(options) {
     const passkeyAuthEnabled = options.passkeyAuthEnabled ?? true;
@@ -346,6 +347,7 @@ export async function composeRelayApp(options) {
     const gitFetches = new GitFetchCoordinator(fetchUpstream);
     const gitSummaries = new GitSummaryCache(inspectGit);
     let recoverExitedSession = () => { };
+    let scheduleAgentCapacityRecovery = () => false;
     let planMeasurementRefresh;
     const publishInteractionResolved = (sessionId, requestId, occurredAt, outcome) => {
         const interaction = interactions
@@ -464,6 +466,11 @@ export async function composeRelayApp(options) {
             const session = withPendingInteractions(sessions.find(sessionId));
             if (!session)
                 return false;
+            if (!rawInteraction && isAgentCapacityRecoveryCall(request)) {
+                const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
+                return (rootOwned &&
+                    scheduleAgentCapacityRecovery(sessionId, () => runtime?.resolveServerRequest(sessionId, String(request.id), agentCapacityRecoveryToolResponse()) === true));
+            }
             if (!rawInteraction && isAutopilotWaitLeaseCall(request)) {
                 const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
                 if (rootOwned)
@@ -565,6 +572,39 @@ export async function composeRelayApp(options) {
             autopilot.restore(session.id);
     };
     if (runtime) {
+        const capacityRecoveries = new Set();
+        scheduleAgentCapacityRecovery = (sessionId, acknowledge) => {
+            if (capacityRecoveries.has(sessionId) || !acknowledge())
+                return false;
+            capacityRecoveries.add(sessionId);
+            setTimeout(() => {
+                void (async () => {
+                    try {
+                        if (closing)
+                            return;
+                        const session = sessions.find(sessionId);
+                        if (!session || session.desiredState !== 'active' || !session.threadId)
+                            return;
+                        const recovering = RelaySession.rehydrate(session).beginRecovery(new Date().toISOString()).snapshot;
+                        saveSession(recovering);
+                        try {
+                            const restored = await runtime.recycle(recovering, new Date().toISOString());
+                            saveSession(restored);
+                        }
+                        catch {
+                            const current = sessions.find(sessionId);
+                            if (current)
+                                saveSession(RelaySession.rehydrate(current).requireAttention(new Date().toISOString())
+                                    .snapshot);
+                        }
+                    }
+                    finally {
+                        capacityRecoveries.delete(sessionId);
+                    }
+                })();
+            }, 500);
+            return true;
+        };
         const supervisor = new SessionSupervisor(async (sessionId) => {
             const session = sessions.find(sessionId);
             if (!session || session.desiredState !== 'active' || !session.threadId)

package/dist/server/server/platform/codex/server-request.js

@@ -7,6 +7,7 @@ import { GESTALT_QUIZ_TOOL_NAME, parseQuiz } from '../../../shared/contracts/qui
 import { GESTALT_ORG_PLAN_ATTENTION_TOOL_NAME, parseOrgPlanAttention, } from '../../../shared/contracts/org-plan-attention.js';
 import { GESTALT_ORG_PLAN_CHECKPOINT_TOOL_NAME, parseOrgPlanCheckpoint, } from '../../../shared/contracts/org-plan-checkpoint.js';
 import { GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME, parseAutopilotWaitLease, } from '../../../shared/contracts/autopilot-wait-lease.js';
+import { GESTALT_AGENT_CAPACITY_RECOVERY_TOOL_NAME, parseAgentCapacityRecovery, } from '../../../shared/contracts/agent-capacity-recovery.js';
 export function toPendingInteraction(input) {
     if (!Number.isSafeInteger(input.id) || !isRecord(input.params))
         return null;
@@ -58,6 +59,13 @@ export function isAutopilotWaitLeaseCall(input) {
         isRecord(input.params) &&
         input.params.tool === GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME);
 }
+export function isAgentCapacityRecoveryCall(input) {
+    return (Number.isSafeInteger(input.id) &&
+        input.method === 'item/tool/call' &&
+        isRecord(input.params) &&
+        input.params.tool === GESTALT_AGENT_CAPACITY_RECOVERY_TOOL_NAME &&
+        parseAgentCapacityRecovery(input.params.arguments) !== null);
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/server/server/platform/codex/session-runtime.js

@@ -11,6 +11,7 @@ import { gestaltQuizDynamicTool } from '../../../shared/contracts/quiz.js';
 import { gestaltOrgPlanAttentionDynamicTool } from '../../../shared/contracts/org-plan-attention.js';
 import { gestaltOrgPlanCheckpointDynamicTool } from '../../../shared/contracts/org-plan-checkpoint.js';
 import { gestaltAutopilotWaitLeaseDynamicTool } from '../../../shared/contracts/autopilot-wait-lease.js';
+import { gestaltAgentCapacityRecoveryDynamicTool } from '../../../shared/contracts/agent-capacity-recovery.js';
 import { countDiffLines } from '../../../shared/contracts/file-change.js';
 import { threadPlanName } from './thread-plan-name.js';
 import { WriterAcquisitionError, } from '../../features/sessions/application/writer-acquisition.js';
@@ -145,6 +146,11 @@ export class CodexSessionRuntime {
         }
         this.stop(sessionId);
     }
+    /** Replaces only this session's app-server while retaining its durable root thread. */
+    async recycle(session, now) {
+        this.stop(session.id);
+        return this.restore(session, now);
+    }
     /** Releases all relay-owned app-server children during graceful shutdown. */
     stopAll() {
         // Exit delivery can already be queued when shutdown begins. Declare the
@@ -574,6 +580,7 @@ export class CodexSessionRuntime {
                         gestaltOrgPlanAttentionDynamicTool,
                         gestaltOrgPlanCheckpointDynamicTool,
                         gestaltAutopilotWaitLeaseDynamicTool,
+                        gestaltAgentCapacityRecoveryDynamicTool,
                     ],
                 });
                 result = {
@@ -665,6 +672,7 @@ export class CodexSessionRuntime {
                 gestaltOrgPlanAttentionDynamicTool,
                 gestaltOrgPlanCheckpointDynamicTool,
                 gestaltAutopilotWaitLeaseDynamicTool,
+                gestaltAgentCapacityRecoveryDynamicTool,
             ],
             ...(session.model ? { model: session.model } : {}),
             ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),

package/dist/server/shared/contracts/agent-capacity-recovery.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Bounded recovery for a Codex collaboration registry whose resident slots leaked. */
+export const GESTALT_AGENT_CAPACITY_RECOVERY_TOOL_NAME = 'gestalt_agent_capacity_recovery';
+export const gestaltAgentCapacityRecoveryDynamicTool = {
+    type: 'function',
+    name: GESTALT_AGENT_CAPACITY_RECOVERY_TOOL_NAME,
+    description: 'Recover the current supervised session after Codex reports its agent thread limit and stale pending-init agents cannot be closed. This recycles only the current Codex runtime, preserves the durable root thread and Org Plan, and cannot request human authority.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['version', 'reason'],
+        properties: {
+            version: { const: 1 },
+            reason: { const: 'agentThreadLimit' },
+        },
+    },
+};
+export function parseAgentCapacityRecovery(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        Array.isArray(value) ||
+        Object.keys(value).length !== 2)
+        return null;
+    const candidate = value;
+    return candidate.version === 1 && candidate.reason === 'agentThreadLimit'
+        ? { version: 1, reason: 'agentThreadLimit' }
+        : null;
+}
+export function agentCapacityRecoveryToolResponse() {
+    return {
+        success: true,
+        contentItems: [
+            { type: 'inputText', text: '{"accepted":true,"action":"sessionRuntimeRecycle"}' },
+        ],
+    };
+}

package/gestalt-supervision-capabilities.json

@@ -6,6 +6,7 @@
     "supervision-start",
     "wait-lease-tool",
     "checkpoint-tool",
+    "agent-capacity-recovery",
     "controller-status",
     "canonical-agent-identity",
     "session-verdict",

package/package.json

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