npm - gestalt-mobile - Versions diffs - 0.30.2 → 0.31.0 - Mend

gestalt-mobile 0.30.2 → 0.31.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/client/index.html CHANGED Viewed

@@ -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-v8UC90bI.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CKhqx71S.css">
+    <script type="module" crossorigin src="/assets/index-DKzUE8x1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DDwVphGb.css">
   </head>
   <body>
     <div id="app"></div>

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

@@ -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-'));
@@ -2342,6 +2402,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}`, {
@@ -2500,6 +2561,36 @@ describe('production composition', () => {
             expect((await app.inject(`/api/sessions/${sessionId}/history`)).json().interactions).toEqual(expect.arrayContaining([
                 expect.objectContaining({ requestId: '9', kind: 'orgPlanAttention', outcome: 'failed' }),
             ]));
+            const quiz = handle.request({
+                id: 71,
+                method: 'item/tool/call',
+                params: {
+                    tool: 'gestalt_quiz',
+                    arguments: {
+                        questions: [
+                            {
+                                id: 'mode',
+                                header: 'Mode',
+                                question: 'How should this run?',
+                                choices: [
+                                    { label: 'Solo', description: 'Use one agent.' },
+                                    { label: 'Team', description: 'Use several agents.' },
+                                ],
+                                allowCustom: false,
+                            },
+                        ],
+                    },
+                },
+            });
+            const clearedQuiz = quiz.catch((error) => error);
+            handle.notify({
+                method: 'serverRequest/resolved',
+                params: { threadId: 'thread-1', requestId: 71 },
+            });
+            expect(await clearedQuiz).toEqual(expect.objectContaining({ message: 'CODEX_SERVER_REQUEST_CLEARED' }));
+            expect((await app.inject(`/api/sessions/${sessionId}/history`)).json().interactions).toEqual(expect.arrayContaining([
+                expect.objectContaining({ requestId: '71', kind: 'quiz', resolvedAt: null }),
+            ]));
             await app.close();
         });
     });

package/dist/server/server/composition.js CHANGED Viewed

@@ -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,6 +52,7 @@ 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';
@@ -95,6 +97,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 +119,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 +291,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 +354,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);
@@ -352,6 +370,10 @@ export async function composeRelayApp(options) {
     };
     const dismissPendingInteractions = (sessionId, occurredAt, outcome = 'dismissed') => {
         for (const interaction of interactions.list(sessionId)) {
+            // Quiz answers remain useful after Codex clears the original dynamic-tool
+            // request: the client can deliver them as a follow-up prompt instead.
+            if (interaction.kind === 'quiz')
+                continue;
             if (interactions.resolve(sessionId, interaction.requestId, occurredAt, outcome))
                 publishInteractionResolved(sessionId, interaction.requestId, occurredAt, outcome);
         }
@@ -381,17 +403,18 @@ 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);
                 const outcome = interaction?.kind === 'orgPlanAttention' ? 'failed' : 'dismissed';
-                if (interactions.resolve(sessionId, resolvedRequestId, occurredAt, outcome)) {
+                if (interaction?.kind !== 'quiz' &&
+                    interactions.resolve(sessionId, resolvedRequestId, occurredAt, outcome)) {
                     if (outcome === 'failed')
                         publishAttentionSettlement(sessionId, resolvedRequestId, occurredAt, outcome);
                     else
@@ -411,8 +434,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;
@@ -424,6 +450,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));

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

@@ -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 CHANGED Viewed

@@ -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,
         })),