gestalt-mobile 0.30.3 → 0.31.0

package/dist/server/server/features/autopilot/domain/autopilot-session.js

@@ -3,6 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { observableWakeConditions, } from './supervision-protocol.js';
 export function disabledAutopilot(sessionId, now) {
     return {
         sessionId,
@@ -18,10 +19,99 @@ export function disabledAutopilot(sessionId, now) {
         updatedAt: now,
     };
 }
-export function autopilotSnapshot(state, retryLimit) {
+export function autopilotSnapshot(state, retryLimit, facts = {
+    activeTurn: false,
+    executorActive: false,
+    control: 'none',
+    timerArmed: false,
+    reconciling: false,
+    planMatches: false,
+    parkedSubscriptionActive: false,
+    transitionFresh: false,
+    observedAt: state.updatedAt,
+}) {
+    const supervision = state.supervision?.outcome ?? 'none';
+    const waitCategories = supportedWakeCategories(state.supervision?.waitLease?.wakeConditions ?? []);
+    const parkedWait = supervision === 'parked' && waitCategories.length > 0 && facts.parkedSubscriptionActive;
+    const evaluationAt = state.nextEvaluationAt ? Date.parse(state.nextEvaluationAt) : Number.NaN;
+    const scheduled = state.state === 'backoff' &&
+        facts.control === 'scheduled' &&
+        facts.timerArmed &&
+        Number.isFinite(evaluationAt) &&
+        evaluationAt > Date.parse(facts.observedAt);
+    const rootWorking = facts.activeTurn;
+    // Runtime observations are current at observedAt.  A slow or old durable
+    // transition must not turn an actually active root/timer/reconciliation or
+    // installed wait lease into a false idle signal.
+    const liveContinuation = parkedWait || scheduled || rootWorking || facts.executorActive || facts.reconciling;
+    const healthy = state.requestedEnabled &&
+        facts.planMatches &&
+        !['attentionRequired', 'safetyPaused'].includes(supervision) &&
+        !['attentionRequired', 'safetyPaused', 'completed', 'disabled'].includes(state.state) &&
+        liveContinuation;
+    const phase = state.state === 'disabled'
+        ? 'off'
+        : state.state === 'completed'
+            ? 'complete'
+            : state.state === 'attentionRequired'
+                ? 'needsYou'
+                : state.state === 'safetyPaused' || supervision === 'safetyPaused'
+                    ? 'safetyPaused'
+                    : healthy && (parkedWait || facts.executorActive)
+                        ? 'waitingForAgentEvent'
+                        : healthy && scheduled
+                            ? 'continuationScheduled'
+                            : healthy && (supervision === 'probeRequired' || facts.reconciling)
+                                ? 'checkingState'
+                                : healthy && rootWorking
+                                    ? 'rootWorking'
+                                    : 'degraded';
+    const nextExpectedAction = phase === 'rootWorking'
+        ? 'Wait for the root turn to settle.'
+        : phase === 'continuationScheduled'
+            ? 'Run the scheduled continuation.'
+            : phase === 'waitingForAgentEvent'
+                ? parkedWait
+                    ? 'Wait for a subscribed agent or process event.'
+                    : 'Wait for the active executor or owned process to settle.'
+                : phase === 'checkingState'
+                    ? 'Reconcile supervised execution state.'
+                    : phase === 'needsYou'
+                        ? 'Respond to the pending attention request.'
+                        : phase === 'complete'
+                            ? 'No further plan action is required.'
+                            : phase === 'off'
+                                ? 'Enable Autopilot to supervise an incomplete plan.'
+                                : phase === 'safetyPaused'
+                                    ? 'Resume manually after reviewing the safety pause.'
+                                    : 'Restore a valid continuation before relying on Autopilot.';
     return {
         state: state.state,
         enabled: state.requestedEnabled,
+        health: {
+            healthy,
+            phase,
+            supervision,
+            wait: {
+                present: Boolean(state.supervision?.waitLease),
+                wakeCategories: [...waitCategories].slice(0, 9),
+            },
+            observedAt: facts.observedAt,
+            lastTransitionAt: state.updatedAt,
+            nextExpectedAction,
+            ...(!healthy && state.requestedEnabled
+                ? {
+                    degradationReason: !facts.planMatches
+                        ? 'planMismatch'
+                        : !facts.transitionFresh ||
+                            (Number.isFinite(evaluationAt) && evaluationAt <= Date.parse(facts.observedAt))
+                            ? 'staleTransition'
+                            : state.supervision?.waitLease && !parkedWait
+                                ? 'invalidWaitLease'
+                                : 'missingContinuation',
+                }
+                : {}),
+        },
         ...(state.stopReason ? { reason: state.stopReason } : {}),
         retry: { position: state.consecutiveNoProgress, limit: retryLimit },
         ...(state.lastControlId
@@ -40,3 +130,12 @@ export function autopilotSnapshot(state, retryLimit) {
         updatedAt: state.updatedAt,
     };
 }
+function supportedWakeCategories(conditions) {
+    if (conditions.length > observableWakeConditions.length)
+        return [];
+    const categories = conditions.filter((condition) => typeof condition === 'string' &&
+        observableWakeConditions.includes(condition));
+    return categories.length === conditions.length && new Set(categories).size === categories.length
+        ? categories
+        : [];
+}

package/dist/server/server/features/sessions/get-session/endpoint.js

@@ -4,16 +4,30 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { buildResumeCommand } from '../application/resume-command.js';
-export function registerGetSession(app, find, activity, autopilot) {
+import { toAgentActivityDto } from '../../agent-activity/activity-dto.js';
+import { deriveSessionStatus } from '../session-status.js';
+export function registerGetSession(app, find, activity, autopilot, plan) {
     app.get('/api/sessions/:id', async (request, reply) => {
         const session = find(request.params.id);
-        return session
-            ? reply.send({
-                ...session,
-                ...(activity ? { agentActivity: activity(session.id) } : {}),
-                ...(autopilot ? { autopilot: autopilot(session.id) } : {}),
-                resumeCommand: session.threadId ? buildResumeCommand(session) : null,
-            })
-            : reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const activitySnapshot = activity?.(session.id) ?? null;
+        const autopilotSnapshot = autopilot?.(session.id) ?? null;
+        const retainedPlan = plan?.(session.id) ?? null;
+        return reply.send({
+            ...session,
+            ...(activitySnapshot ? { agentActivity: toAgentActivityDto(activitySnapshot) } : {}),
+            ...(autopilotSnapshot ? { autopilot: autopilotSnapshot } : {}),
+            ...(retainedPlan ? { plan: retainedPlan } : {}),
+            sessionStatus: deriveSessionStatus({
+                session,
+                plan: retainedPlan,
+                activity: activitySnapshot,
+                autopilot: autopilotSnapshot,
+                pendingAttention: Boolean(session.pendingInteractions?.length),
+                observedAt: new Date().toISOString(),
+            }),
+            resumeCommand: session.threadId ? buildResumeCommand(session) : null,
+        });
     });
 }

package/dist/server/server/features/sessions/list-sessions/endpoint.js

@@ -4,14 +4,26 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { buildResumeCommand } from '../application/resume-command.js';
+import { toAgentActivityDto } from '../../agent-activity/activity-dto.js';
+import { deriveSessionStatus } from '../session-status.js';
 export function registerListSessions(app, deps) {
     app.get('/api/sessions', async () => deps.list().map((session) => {
         const plan = deps.plan?.(session.id) ?? null;
+        const activity = deps.activity?.(session.id) ?? null;
+        const autopilot = deps.autopilot?.(session.id) ?? null;
         return {
             ...session,
-            ...(deps.activity ? { agentActivity: deps.activity(session.id) } : {}),
-            ...(deps.autopilot ? { autopilot: deps.autopilot(session.id) } : {}),
+            ...(activity ? { agentActivity: toAgentActivityDto(activity) } : {}),
+            ...(autopilot ? { autopilot } : {}),
             ...(plan ? { plan } : {}),
+            sessionStatus: deriveSessionStatus({
+                session,
+                plan,
+                activity,
+                autopilot,
+                pendingAttention: Boolean(session.pendingInteractions?.length),
+                observedAt: new Date().toISOString(),
+            }),
             resumeCommand: session.threadId ? buildResumeCommand(session) : null,
         };
     }));

package/dist/server/server/features/sessions/register-routes.js

@@ -48,7 +48,7 @@ export function registerSessionRoutes(app, deps) {
             ...sessions,
             reportFailure: (operation, error) => deps.logger.error(`${operation} failed: ${safeErrorLabel(error)}`),
         });
-        registerGetSession(app, sessions.find, sessions.agentActivity, sessions.autopilotSnapshot);
+        registerGetSession(app, sessions.find, sessions.agentActivity, sessions.autopilotSnapshot, sessions.plan);
         if (sessions.refreshActivity)
             registerRefreshActivity(app, {
                 exists: (id) => sessions.find(id) !== null,

package/dist/server/server/features/sessions/session-status.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * A conservative, server-owned verdict. It deliberately uses only durable
+ * state and bounded activity facts: neither model prose nor opaque identity is
+ * accepted as evidence of progress.
+ */
+export function deriveSessionStatus(input) {
+    const confidence = input.activity?.confidence ?? 'stale';
+    const base = (state, reason, nextExpectedAction) => ({
+        state,
+        reason,
+        confidence,
+        observedAt: input.observedAt,
+        nextExpectedAction,
+    });
+    if (input.pendingAttention || input.autopilot?.state === 'attentionRequired')
+        return base('idle', 'needsYou', 'Respond to the pending request.');
+    const activeProcess = input.activity?.subagents.some((agent) => agent.ownedProcesses?.some((process) => process.state === 'running' || process.state === 'detached-active'));
+    const rootWorking = Boolean(input.session.activeTurnId) ||
+        (input.activity?.confidence === 'fresh' && input.activity.root.state === 'working');
+    const observedChildWorking = input.activity?.subagents.some((agent) => agent.state === 'working' || agent.state === 'awaitingAgent');
+    // A completed plan is authoritative.  Old child/process rows are historical
+    // unless their activity observation is fresh; an active root turn remains
+    // direct session evidence regardless of roster freshness.
+    const childWorking = input.activity?.confidence === 'fresh' ? observedChildWorking : false;
+    const currentProcess = input.activity?.confidence === 'fresh' ? activeProcess : false;
+    if (input.plan?.executionComplete || input.plan?.allDone) {
+        if (rootWorking)
+            return base('working', 'rootTurn', 'Wait for the active turn to settle.');
+        if (childWorking)
+            return base('working', 'agent', 'Wait for the active agent to settle.');
+        if (currentProcess)
+            return base('working', 'process', 'Wait for the owned process result.');
+        return base('idle', 'complete', 'No further plan action is required.');
+    }
+    if (rootWorking)
+        return base('working', 'rootTurn', 'Wait for the supervisor turn to settle.');
+    if (childWorking)
+        return base('working', 'agent', 'Wait for the active agent to settle.');
+    if (currentProcess)
+        return base('working', 'process', 'Wait for the owned process result.');
+    if (input.plan && input.autopilot?.health?.healthy)
+        return base('working', 'autopilot', input.autopilot.health.nextExpectedAction);
+    if (input.plan)
+        return base('idle', 'incompleteWithoutContinuation', 'Resume supervision or enable a healthy Autopilot continuation.');
+    if (input.activity?.root.state === 'disconnected')
+        return base('idle', 'disconnected', 'Restore or reopen the session.');
+    if (input.session.state === 'stopped' || input.session.state === 'released')
+        return base('idle', 'stopped', 'Open the session to continue.');
+    return base('idle', 'unknown', 'Refresh session status.');
+}

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

@@ -294,9 +294,10 @@ export class CodexSessionRuntime {
         if (!owned)
             return [];
         const children = [];
+        const childIds = new Set();
         const cursors = new Set();
         let cursor;
-        for (let page = 0; page < 4 && children.length < 64; page += 1) {
+        for (let page = 0; page < 4 && childIds.size < 64; page += 1) {
             const result = await owned.process.rpc.request('thread/list', {
                 parentThreadId: session.threadId,
                 ...(cursor ? { cursor } : {}),
@@ -320,6 +321,7 @@ export class CodexSessionRuntime {
                     rawStatus === 'systemError'
                     ? rawStatus
                     : undefined;
+                childIds.add(value.id);
                 return [
                     {
                         id: value.id,
@@ -339,19 +341,21 @@ export class CodexSessionRuntime {
                     },
                 ];
             }));
+            if (childIds.size > 64)
+                throw new Error('CODEX_CHILD_LIST_UNSUPPORTED');
             const next = typeof response?.nextCursor === 'string' && response.nextCursor.length <= 256
                 ? response.nextCursor
                 : undefined;
             if (!next)
-                return this.withResolvedChildModels(owned, children);
-            if (cursors.has(next) || children.length >= 64)
+                return this.withResolvedChildModels(owned, uniqueDirectChildren(children));
+            if (cursors.has(next) || childIds.size >= 64)
                 throw new Error('CODEX_CHILD_LIST_UNSUPPORTED');
             cursors.add(next);
             cursor = next;
         }
         if (cursor)
             throw new Error('CODEX_CHILD_LIST_UNSUPPORTED');
-        return this.withResolvedChildModels(owned, children);
+        return this.withResolvedChildModels(owned, uniqueDirectChildren(children));
     }
     async withResolvedChildModels(resource, children) {
         for (const child of children) {
@@ -784,6 +788,13 @@ export class CodexSessionRuntime {
         return origin;
     }
 }
+/** `thread/list` pages can replay an id while a child transitions. Keep its newest row. */
+function uniqueDirectChildren(children) {
+    const result = new Map();
+    for (const child of children)
+        result.set(child.id, child);
+    return [...result.values()].slice(0, 64);
+}
 function isMethodNotFound(error) {
     return Boolean(error && typeof error === 'object' && error.code === -32601);
 }

package/gestalt-supervision-capabilities.json

@@ -0,0 +1,15 @@
+{
+  "schemaVersion": 1,
+  "component": "mobile",
+  "supervisionContract": 1,
+  "capabilities": [
+    "supervision-start",
+    "wait-lease-tool",
+    "checkpoint-tool",
+    "controller-status",
+    "canonical-agent-identity",
+    "session-verdict",
+    "acknowledgement-safe-composer",
+    "org-plan-contract"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.30.3",
+  "version": "0.31.0",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",
@@ -26,7 +26,8 @@
     "dist/server",
     "dist/client",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "gestalt-supervision-capabilities.json"
   ],
   "engines": {
     "node": ">=24.0.0"