gestalt-mobile 0.30.3 → 0.32.0

package/dist/client/index.html

@@ -16,8 +16,8 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-BK3qsn4l.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DHqGG2Sf.css">
+    <script type="module" crossorigin src="/assets/index-CxAG4Fmv.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CcWoGWyP.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/app.js

@@ -18,6 +18,7 @@ import { registerSkillRoutes } from './features/skills/register-routes.js';
 import { registerOrgPlanAttentionRoutes } from './features/org-plan-attention/register-routes.js';
 import { registerAutopilotRoutes } from './features/autopilot/register-routes.js';
 import { registerFileRoutes } from './features/files/register-routes.js';
+import { registerMaintenanceRoutes } from './features/maintenance/register-routes.js';
 export async function buildApp(deps) {
     // Keep the default boundary finite even when an endpoint forgot a narrower schema.
     const app = fastify({ logger: false, bodyLimit: 1024 * 1024 });
@@ -52,6 +53,7 @@ export async function buildApp(deps) {
     registerFileRoutes(app, deps);
     registerGitRoutes(app, deps);
     registerSkillRoutes(app, deps);
+    registerMaintenanceRoutes(app, deps);
     registerProblemHandler(app, Boolean(deps.staticDir));
     return app;
 }

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

@@ -690,7 +690,9 @@ describe('production composition', () => {
                     url: `/api/sessions/${fixture.sessionId}/autopilot`,
                     payload: { enabled: true },
                 })).statusCode).toBe(200);
-                await vi.waitFor(() => expect(timers).toHaveLength(1));
+                // Initial supervision schedules its control and keeps a separate,
+                // bounded reconciliation watchdog while activity is still stale.
+                await vi.waitFor(() => expect(timers).toHaveLength(2));
                 const staleTimer = timers[0];
                 if (action === 'close') {
                     await writeFile(join(fixture.workspacePath, 'autopilot.org'), completedAutopilotPlanText());
@@ -1366,6 +1368,64 @@ describe('production composition', () => {
         });
     });
     describeCompositionConcern('lifecycle', () => {
+        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-'));
+            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.notify);
+            expect(handle?.notify).toBeDefined();
+            await app.listen({ host: '127.0.0.1', port: 0 });
+            const address = app.server.address();
+            if (!address || typeof address === 'string')
+                throw new Error('Expected TCP listener');
+            const socket = new WebSocket(`ws://127.0.0.1:${address.port}/api/sessions/${sessionId}/events?after=0`, {
+                headers: {
+                    origin: relyingParty.publicOrigin,
+                    cookie: 'gestalt_mobile_session=test-session',
+                },
+            });
+            const messages = [];
+            socket.on('message', (data) => messages.push(JSON.parse(String(data))));
+            await once(socket, 'open');
+            const started = await app.inject({
+                method: 'POST',
+                url: `/api/sessions/${sessionId}/turns`,
+                payload: { text: 'complete this turn' },
+            });
+            expect(started.statusCode).toBe(202);
+            const turnId = started.json().activeTurnId;
+            handle.notify({ method: 'turn/completed', params: { turn: { id: turnId } } });
+            await vi.waitFor(() => {
+                const status = messages
+                    .filter((message) => message.event.type === 'session.status.updated')
+                    .at(-1)?.event.payload;
+                expect(status).toMatchObject({ state: 'idle' });
+            });
+            expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
+                activeTurnId: null,
+            });
+            socket.close();
+            await app.close();
+        });
         it('forgets a session while activity reconciliation is pending without publishing late activity', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
@@ -1699,6 +1759,7 @@ describe('production composition', () => {
                     'protected',
                 ],
                 ['POST', '/api/git/clone', '/api/git/clone', 'protected'],
+                ['POST', '/api/maintenance/update-restart', '/api/maintenance/update-restart', 'protected'],
                 ['GET', '/api/skills', '/api/skills', 'protected'],
                 ['HEAD', '/api/skills', '/api/skills', 'protected'],
                 ['GET', '/api/skill-profiles', '/api/skill-profiles', 'protected'],
@@ -2342,6 +2403,7 @@ describe('production composition', () => {
                 agentActivity: { root: { state: 'working' } },
             });
             expect(activityEvents.filter((message) => message.event.type === 'agent.activity.updated')).toHaveLength(initialActivityEvents + 1);
+            expect(JSON.stringify(activityEvents)).not.toMatch(/ownerThreadId|ownerTaskPath|itemId|cpuPercent|rssBytes|resultArtifact/);
             const activitySequence = activityEvents.find((message) => message.event.type === 'agent.activity.updated').event.sequence;
             socket.close();
             const replaySocket = new WebSocket(`ws://127.0.0.1:${address.port}/api/sessions/${sessionId}/events?after=${activitySequence - 1}`, {

package/dist/server/server/composition.js

@@ -34,6 +34,7 @@ import { SessionSupervisor } from './platform/runtime/session-supervisor.js';
 import { mapWithConcurrency } from './platform/runtime/concurrency.js';
 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 { parseOrgPlanCheckpoint, toOrgPlanCheckpointToolResponse, } from '../shared/contracts/org-plan-checkpoint.js';
@@ -51,9 +52,11 @@ import { checkpointPlanMeasurement } from './platform/plans/plan-measurement-com
 import { PlanMeasurementRefresh } from './platform/plans/plan-measurement-refresh.js';
 import { SqliteAutopilotStore } from './platform/persistence/sqlite-autopilot-store.js';
 import { AutopilotCoordinator } from './features/autopilot/application/service.js';
+import { deriveSessionStatus } from './features/sessions/session-status.js';
 import { AUTOPILOT_CONTINUATION_PROMPT, AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT, autopilotExecutorLaunchPrompt, defaultAutopilotPolicy, } from './features/autopilot/application/policy.js';
 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';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
 export async function composeRelayApp(options) {
@@ -95,6 +98,7 @@ export async function composeRelayApp(options) {
     const withPendingInteractions = (session) => (session ? { ...session, pendingInteractions: interactions.list(session.id) } : null);
     const events = new SessionEventBus();
     let notifyAutopilotActivity = () => undefined;
+    let publishSessionStatus = () => undefined;
     const attentionTransitions = {
         subscribe: (sessionId, listener) => events.subscribe(sessionId, (event) => {
             if (event.type !== 'org-plan.attention-required' &&
@@ -116,7 +120,8 @@ export async function composeRelayApp(options) {
     };
     options.onAttentionTransitions?.(attentionTransitions);
     const activity = new AgentActivityRegistry((snapshot, occurredAt) => {
-        events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', snapshot, occurredAt));
+        events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', toAgentActivityDto(snapshot), occurredAt));
+        publishSessionStatus(snapshot.sessionId, occurredAt);
         notifyAutopilotActivity(snapshot.sessionId);
     }, {
         // Evidence arms one bounded reconciliation; healthy sessions are never polled.
@@ -287,6 +292,19 @@ export async function composeRelayApp(options) {
         },
     });
     notifyAutopilotActivity = (sessionId) => autopilot.activityChanged(sessionId);
+    publishSessionStatus = (sessionId, occurredAt) => {
+        const session = sessions.find(sessionId);
+        if (!session)
+            return;
+        events.publish(journal.append(sessionId, 'session.status.updated', deriveSessionStatus({
+            session,
+            plan: supervisedPlans.find(sessionId),
+            activity: activity.snapshot(sessionId, occurredAt),
+            autopilot: autopilot.snapshot(sessionId),
+            pendingAttention: interactions.list(sessionId).length > 0,
+            observedAt: occurredAt,
+        }), occurredAt));
+    };
     options.onAutopilotCoordinator?.(autopilot);
     const workspaces = new FilesystemWorkspaceCatalog(root);
     const workspaceFiles = new FilesystemWorkspaceFiles();
@@ -337,6 +355,7 @@ export async function composeRelayApp(options) {
         if (interaction?.kind === 'orgPlanAttention')
             events.publish(journal.append(sessionId, 'org-plan.attention-resolved', { requestId, turnId: interaction.turnId ?? null, resolvedAt: occurredAt, outcome }, occurredAt));
         autopilot.semanticEvent(sessionId, 'interactionChanged');
+        publishSessionStatus(sessionId, occurredAt);
     };
     const publishAttentionSettlement = (sessionId, requestId, occurredAt, outcome) => {
         const remaining = interactions.list(sessionId);
@@ -385,12 +404,12 @@ export async function composeRelayApp(options) {
         if (update.kind === 'updated' && update.reason === 'supervision-start')
             autopilot.supervisionStarted(sessionId);
         autopilot.planStatusChanged(sessionId);
+        publishSessionStatus(sessionId, new Date().toISOString());
     };
     runtime = options.startAppServers
         ? new CodexSessionRuntime(options.launchAppServer ?? launchCodexAppServer, undefined, (sessionId, notification, origin) => {
             const occurredAt = new Date().toISOString();
-            for (const activityFact of decodeAgentActivityFacts(sessionId, occurredAt, notification))
-                activity.observe(activityFact);
+            const activityFacts = decodeAgentActivityFacts(sessionId, occurredAt, notification);
             const resolvedRequestId = resolvedServerRequestId(notification);
             if (resolvedRequestId) {
                 const interaction = interactions.find(sessionId, resolvedRequestId);
@@ -416,8 +435,11 @@ export async function composeRelayApp(options) {
                 ? { ...origin, kind: 'root' }
                 : origin;
             const normalized = normalizeCodexNotification(sessionId, 0, occurredAt, notification, currentSession?.workspacePath, currentSession?.activeTurnId, resolvedOrigin);
-            if (!normalized)
+            if (!normalized) {
+                for (const activityFact of activityFacts)
+                    activity.observe(activityFact);
                 return;
+            }
             let completedSession;
             if (normalized.type === 'turnCompleted') {
                 const turnId = normalized.payload.turn?.id;
@@ -429,6 +451,11 @@ export async function composeRelayApp(options) {
                 }
                 planMeasurementRefresh?.refreshNow(sessionId);
             }
+            // Activity publication also derives and broadcasts the session verdict.
+            // Complete the durable turn first so its status cannot retain the just-finished
+            // activeTurnId while the completion fact makes the root appear idle.
+            for (const activityFact of activityFacts)
+                activity.observe(activityFact);
             events.publish(journal.append(sessionId, normalized.type, normalized.payload, normalized.occurredAt));
             if (completedSession)
                 events.publish(journal.append(sessionId, 'session.updated', completedSession, occurredAt));
@@ -616,6 +643,7 @@ export async function composeRelayApp(options) {
                     };
                 },
             },
+            maintenance: { updateRestart: new GestaltUpdateRestartScheduler() },
             skills: {
                 workspaces,
                 profiles: options.profiles,

package/dist/server/server/features/agent-activity/activity-dto.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Public roster projection: never expose process, thread, task-path, or host metrics identifiers. */
+export function toAgentActivityDto(snapshot) {
+    return {
+        sessionId: snapshot.sessionId,
+        root: snapshot.root,
+        subagents: snapshot.subagents.slice(0, 64).map((child) => ({
+            id: child.id,
+            ...(child.nickname ? { nickname: child.nickname } : {}),
+            ...(child.role ? { role: child.role } : {}),
+            ...(child.model ? { model: child.model } : {}),
+            ...(child.canonicalTaskName ? { canonicalTaskName: child.canonicalTaskName } : {}),
+            ...(child.canonicalPosition ? { canonicalPosition: child.canonicalPosition } : {}),
+            ...(child.continuationGeneration
+                ? { continuationGeneration: child.continuationGeneration }
+                : {}),
+            ...(child.outcome ? { outcome: child.outcome } : {}),
+            ownedProcesses: (child.ownedProcesses ?? []).slice(0, 64).map((process) => ({
+                state: process.state,
+                ownership: process.ownership,
+                observedAt: process.observedAt,
+            })),
+            state: child.state,
+            reason: child.reason,
+            observedAt: child.observedAt,
+            lastActivityAt: child.lastActivityAt,
+        })),
+        aggregateSubagents: snapshot.aggregateSubagents,
+        confidence: snapshot.confidence,
+    };
+}

package/dist/server/server/features/agent-activity/model.js

@@ -84,6 +84,9 @@ export function projectAgentActivity(current, fact) {
             const before = children.get(fact.childId);
             const taskPath = fact.childTaskPath ?? before?.taskPath;
             const identity = taskPath ? parseOrgPlanAgentIdentity(taskPath) : null;
+            const terminalReviewer = taskPath?.split('/').filter(Boolean).at(-1) === 'final_review' ||
+                before?.canonicalTaskName === 'final_review' ||
+                fact.childRole === 'org-plan-reviewer';
             const outcome = childOutcome(fact.childStatus, fact.collaborationAction, before?.outcome);
             const child = Object.freeze({
                 id: fact.childId,
@@ -110,7 +113,9 @@ export function projectAgentActivity(current, fact) {
                         canonicalPosition: identity.canonicalPosition,
                         continuationGeneration: identity.generation,
                     }
-                    : {}),
+                    : terminalReviewer
+                        ? { canonicalTaskName: 'final_review' }
+                        : {}),
                 ...(outcome ? { outcome } : {}),
                 ...(fact.childOwnedProcesses
                     ? { ownedProcesses: Object.freeze([...fact.childOwnedProcesses]) }
@@ -143,14 +148,20 @@ export function projectAgentActivity(current, fact) {
 export function withActivityConfidence(snapshot, confidence) {
     return snapshot.confidence === confidence ? snapshot : Object.freeze({ ...snapshot, confidence });
 }
-/** Process loss revokes child identities; recovery must repopulate them from a fresh list read. */
+/**
+ * A process disconnect makes the roster stale, but is not evidence that its
+ * children ceased to exist. Keep their authoritative identity and present the
+ * last known physical generation as disconnected until disposal or a later
+ * reconciliation replaces it.
+ */
 export function clearAgentActivityChildren(snapshot) {
     if (snapshot.subagents.length === 0 && snapshot.aggregateSubagents === 'idle')
         return snapshot;
+    const subagents = Object.freeze(snapshot.subagents.map((child) => Object.freeze({ ...child, state: 'disconnected', reason: 'processExited' })));
     return Object.freeze({
         ...snapshot,
-        subagents: Object.freeze([]),
-        aggregateSubagents: 'idle',
+        subagents,
+        aggregateSubagents: aggregate(subagents),
     });
 }
 function applyStatus(root, status) {
@@ -231,6 +242,12 @@ function semantic(snapshot) {
             nickname: child.nickname,
             role: child.role,
             model: child.model,
+            taskPath: child.taskPath,
+            canonicalTaskName: child.canonicalTaskName,
+            canonicalPosition: child.canonicalPosition,
+            continuationGeneration: child.continuationGeneration,
+            outcome: child.outcome,
+            ownedProcesses: child.ownedProcesses,
             state: child.state,
             reason: child.reason,
         })),