gestalt-mobile 0.36.0 → 0.36.1

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

@@ -196,7 +196,7 @@ async function createProductionAutopilotFixture(overrides = {}) {
     await installAutopilotPlan(app, sessionId, workspacePath, 'autopilot');
     return { app, dataDir, handles, root, sessionId, workspacePath };
 }
-async function holdCheckpointRequest(fixture, timers, requestId, expectHeld = true) {
+async function holdCheckpointRequest(fixture, timers, requestId, expectHeld = true, compact = false) {
     timers.find((timer) => !timer.cancelled).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.requests.some((request) => request.method === 'turn/start'));
@@ -218,7 +218,18 @@ async function holdCheckpointRequest(fixture, timers, requestId, expectHeld = tr
     const startsBefore = fixture.handles
         .flatMap((candidate) => candidate.requests)
         .filter((request) => request.method === 'turn/start').length;
-    const response = handle.request(l2CheckpointCall(requestId, threadId, turnId, planIdentity));
+    const response = handle.request(compact
+        ? {
+            id: requestId,
+            method: 'item/tool/call',
+            params: {
+                threadId,
+                turnId,
+                tool: 'gestalt_org_plan_checkpoint',
+                arguments: { kind: 'l2Completed' },
+            },
+        }
+        : l2CheckpointCall(requestId, threadId, turnId, planIdentity));
     // The caller can be synchronously rejected by a coordinator exception.
     // Mark it observed immediately; callers still assert its exact outcome.
     void response.catch(() => { });
@@ -915,6 +926,28 @@ describe('production composition', () => {
                 .filter((request) => request.method === 'turn/start')).toHaveLength(2));
             await fixture.app.close();
         });
+        it('expands and acknowledges a compact checkpoint signal from the active root', async () => {
+            const timers = [];
+            const fixture = await createProductionAutopilotFixture({
+                autopilotSchedule: (callback) => {
+                    const timer = { callback, cancelled: false };
+                    timers.push(timer);
+                    return () => {
+                        timer.cancelled = true;
+                    };
+                },
+            });
+            const { handle, response } = await holdCheckpointRequest(fixture, timers, 812, true, true);
+            handle.responseSettled({ id: 812, outcome: 'resultWritten' });
+            await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+            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'")
+                .get(fixture.sessionId);
+            database.close();
+            expect(checkpoint.count).toBe(1);
+            await fixture.app.close();
+        });
         it('leaves an unsupported checkpoint exception before persistence inert', async () => {
             let coordinator;
             const timers = [];
@@ -3652,8 +3685,6 @@ describe('production composition', () => {
                     tool: 'gestalt_org_plan_attention',
                     arguments: {
                         reason: 'permissionRequired',
-                        summary: 'A protected release needs approval.',
-                        requestedAction: 'Grant the release permission.',
                         resumeCondition: 'permissionGranted',
                     },
                 },

package/dist/server/server/composition.js

@@ -46,9 +46,9 @@ 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 { completedCommandId, isAgentCapacityRecoveryCall, isAutopilotWaitLeaseCall, resolvedServerRequestId, toPendingInteraction, } from './platform/codex/server-request.js';
+import { completedCommandId, compactOrgPlanCheckpointKind, 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 { resolveOrgPlanCheckpointSignal, validOrgPlanCheckpoint, } from './features/org-plan-checkpoint/application/validate.js';
 import { isValidInteractionResponse, isValidQuizInteractionResponse, } from './features/sessions/interaction/response-validator.js';
 import { promoteRecentThread } from './features/sessions/promote-recent-thread/use-case.js';
 import { FilesystemSkillProfileStore } from './platform/skills/filesystem-skill-profile-store.js';
@@ -676,10 +676,24 @@ export async function composeRelayApp(options) {
             if (completedSession)
                 events.publish(journal.append(sessionId, 'session.updated', completedSession, occurredAt));
         }, (sessionId, request, origin) => {
-            const rawInteraction = toPendingInteraction(request);
+            let rawInteraction = toPendingInteraction(request);
             const session = withPendingInteractions(sessions.find(sessionId));
             if (!session)
                 return false;
+            const compactCheckpointKind = compactOrgPlanCheckpointKind(request);
+            if (!rawInteraction && compactCheckpointKind) {
+                const retained = supervisedPlans.find(sessionId);
+                const identity = supervisedPlans.identity(sessionId);
+                const checkpoint = retained && identity
+                    ? resolveOrgPlanCheckpointSignal(compactCheckpointKind, retained, identity)
+                    : null;
+                if (checkpoint)
+                    rawInteraction = {
+                        requestId: String(request.id),
+                        kind: 'orgPlanCheckpoint',
+                        payload: checkpoint,
+                    };
+            }
             if (!rawInteraction && isAgentCapacityRecoveryCall(request)) {
                 const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
                 return (rootOwned &&

package/dist/server/server/features/org-plan-checkpoint/application/validate.js

@@ -3,6 +3,46 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+/** Expands a host-owned compact boundary signal from authoritative plan state. */
+export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity) {
+    if (kind === 'terminalReviewAccepted')
+        return {
+            version: 1,
+            kind,
+            planIdentity,
+            verdict: 'ACCEPT',
+        };
+    const selected = plan.steps.find((step) => step.id === plan.currentStepId) ??
+        [...plan.steps].reverse().find((step) => step.state === 'DONE' || step.state === 'WIP');
+    if (!selected)
+        return null;
+    const l1Position = `L${plan.steps.indexOf(selected) + 1}`;
+    if (kind === 'l1Accepted')
+        return {
+            version: 1,
+            kind,
+            planIdentity,
+            l1Id: selected.id,
+            position: l1Position,
+            verdict: 'ACCEPT',
+            commit: { kind: 'notRequired' },
+        };
+    const child = [...selected.children].reverse().find((step) => step.state === 'DONE');
+    if (!child)
+        return null;
+    return {
+        version: 1,
+        kind,
+        planIdentity,
+        l1Id: selected.id,
+        l2Id: child.id,
+        position: `${l1Position}.${selected.children.indexOf(child) + 1}`,
+        status: 'DONE',
+        changes: 'Validated from the authoritative Org Plan boundary.',
+        files: 'Recorded by the supervised executor.',
+        tests: 'Focused verification recorded before the boundary.',
+    };
+}
 export function validOrgPlanCheckpoint(input) {
     const { checkpoint, plan, planIdentity, rootOwned } = input;
     if (!rootOwned || checkpoint.planIdentity !== planIdentity)

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

@@ -70,6 +70,20 @@ export function isAutopilotWaitLeaseCall(input) {
         isRecord(input.params) &&
         input.params.tool === GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME);
 }
+/** Compatibility signal used by newer hosts that let Mobile derive boundary details. */
+export function compactOrgPlanCheckpointKind(input) {
+    if (!Number.isSafeInteger(input.id) ||
+        input.method !== 'item/tool/call' ||
+        !isRecord(input.params) ||
+        input.params.tool !== GESTALT_ORG_PLAN_CHECKPOINT_TOOL_NAME ||
+        !isRecord(input.params.arguments) ||
+        Object.keys(input.params.arguments).length !== 1)
+        return null;
+    const kind = input.params.arguments.kind;
+    return kind === 'l2Completed' || kind === 'l1Accepted' || kind === 'terminalReviewAccepted'
+        ? kind
+        : null;
+}
 export function isAgentCapacityRecoveryCall(input) {
     return (Number.isSafeInteger(input.id) &&
         input.method === 'item/tool/call' &&

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

@@ -951,7 +951,11 @@ function asRecord(value) {
     return value && typeof value === 'object' ? value : undefined;
 }
 function decodeAgentTaskPath(value) {
-    const subagent = asRecord(asRecord(value)?.subagent);
+    const source = asRecord(value);
+    // Codex 0.153 renamed this source discriminator from `subagent` to
+    // `subAgent`. Accept both spellings because the task path is the durable
+    // correlation between a physical child thread and its Org Plan executor.
+    const subagent = asRecord(source?.subAgent) ?? asRecord(source?.subagent);
     const spawn = asRecord(subagent?.thread_spawn);
     const path = boundedString(spawn?.agent_path, 256);
     return path?.startsWith('/') && !path.includes('..') ? path : undefined;

package/dist/server/shared/contracts/org-plan-attention.js

@@ -52,7 +52,21 @@ export const gestaltOrgPlanAttentionDynamicTool = {
     },
 };
 export function parseOrgPlanAttention(value) {
-    if (!isRecord(value) || Object.keys(value).length !== 4)
+    if (!isRecord(value))
+        return null;
+    const keys = Object.keys(value);
+    if (keys.length === 2 &&
+        keys.every((key) => key === 'reason' || key === 'resumeCondition') &&
+        isReason(value.reason) &&
+        isResumeCondition(value.resumeCondition) &&
+        orgPlanAttentionResumeConditionByReason[value.reason] === value.resumeCondition)
+        return {
+            reason: value.reason,
+            summary: `Supervised execution requires human attention (${value.reason}).`,
+            requestedAction: `Satisfy the ${value.resumeCondition} resume condition, then resume or disable Autopilot.`,
+            resumeCondition: value.resumeCondition,
+        };
+    if (keys.length !== 4)
         return null;
     if (!isReason(value.reason) ||
         !isBoundedText(value.summary, 600) ||

package/package.json

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