gestalt-mobile 0.35.5 → 0.36.1

package/dist/server/client/features/chat/message-store.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function appendUserMessage(messages, id, text, occurredAt) {
+    return [
+        ...messages,
+        { id, role: 'user', text, ...(occurredAt ? { occurredAt } : {}), complete: true },
+    ];
+}
+export function applyDelta(messages, id, text, occurredAt) {
+    const previous = messages.find((message) => message.id === id);
+    return previous
+        ? messages.map((message) => message.id === id ? { ...message, text: message.text + text } : message)
+        : [
+            ...messages,
+            {
+                id,
+                role: 'assistant',
+                phase: 'commentary',
+                text,
+                ...(occurredAt ? { occurredAt } : {}),
+                complete: false,
+            },
+        ];
+}
+export function completeMessage(messages, id) {
+    return messages.map((message) => (message.id === id ? { ...message, complete: true } : message));
+}

package/dist/server/server/app.js

@@ -46,7 +46,7 @@ export async function buildApp(deps) {
         registerGetBootstrap(app, deps.bootstrap);
     registerSessionRoutes(app, deps);
     if (deps.autopilot)
-        registerAutopilotRoutes(app, deps.autopilot, deps.sessionRoutes?.idempotency);
+        registerAutopilotRoutes(app, deps.autopilot, deps.sessionRoutes?.idempotency, deps.sessionRoutes ? (id) => deps.sessionRoutes?.find(id)?.provider : undefined);
     if (deps.orgPlanAttention)
         registerOrgPlanAttentionRoutes(app, deps.orgPlanAttention);
     registerPlanRoutes(app, deps);

package/dist/server/server/cli.js

@@ -98,6 +98,12 @@ export async function probeCodexVersion() {
         .then(({ stdout }) => stdout.trim() || null)
         .catch(() => null);
 }
+/** Detects the kimi CLI exactly like the codex probe; absence is a soft status. */
+export async function probeKimiVersion() {
+    return runFile('kimi', ['--version'])
+        .then(({ stdout }) => stdout.trim() || null)
+        .catch(() => null);
+}
 export function installShutdownHandlers(app, signalSource = process) {
     let closing;
     const shutdown = () => {
@@ -205,6 +211,7 @@ export async function runCli(dependencies = {}) {
     if (!diagnosis.ok)
         stderr.write('WARNING: Startup diagnostics reported a problem; Gestalt Mobile will continue so it can show recovery controls.\n');
     const installedCodexVersion = await (dependencies.probeCodexVersion ?? probeCodexVersion)();
+    const installedKimiVersion = await (dependencies.probeKimiVersion ?? probeKimiVersion)();
     const mobileVersion = await packageVersion(moduleUrl);
     const app = await (dependencies.compose ?? composeRelayApp)({
         root: config.root,
@@ -214,6 +221,7 @@ export async function runCli(dependencies = {}) {
         staticDir: packagedClientDir(moduleUrl),
         profiles: new LauncherProfileCatalog(),
         installedCodexVersion,
+        installedKimiVersion,
         componentVersions: componentVersions(mobileVersion, installedCodexVersion, dependencies.environment),
         startAppServers: true,
         homeDirectory: dependencies.homeDirectory,

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

@@ -21,6 +21,7 @@ import { workspaceId } from './platform/catalog/workspace-id.js';
 import { planStatusDirectoryPath, planStatusFilePath, } from './platform/plans/filesystem-plan-status-source.js';
 import { toOrgPlanAttentionToolResponse } from '../shared/contracts/org-plan-attention.js';
 import { toOrgPlanCheckpointToolResponse } from '../shared/contracts/org-plan-checkpoint.js';
+import { applyProjectionEvent, createChatProjection, } from '../client/features/chat/chat-projection.js';
 function fakeAppServer(calls) {
     return {
         rpc: {
@@ -125,7 +126,7 @@ async function createComposedSession(app) {
     const created = await app.inject({
         method: 'POST',
         url: '/api/sessions',
-        payload: { workspaceId: workspace.id, profile: 'default' },
+        payload: { workspaceId: workspace.id, profile: 'default', provider: 'codex' },
     });
     expect(created.statusCode).toBe(202);
     return created.json().id;
@@ -195,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'));
@@ -217,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(() => { });
@@ -914,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 = [];
@@ -2680,6 +2714,7 @@ describe('production composition', () => {
                 ['DELETE', '/api/auth/devices/:deviceId', '/api/auth/devices/device-1', 'protected'],
                 ['GET', '/api/bootstrap', '/api/bootstrap', 'protected'],
                 ['HEAD', '/api/bootstrap', '/api/bootstrap', 'protected'],
+                ['POST', '/api/session-models/:provider', '/api/session-models/codex', 'protected'],
                 ['POST', '/api/sessions', '/api/sessions', 'protected'],
                 ['GET', '/api/sessions', '/api/sessions', 'protected'],
                 ['HEAD', '/api/sessions', '/api/sessions', 'protected'],
@@ -3060,7 +3095,7 @@ describe('production composition', () => {
             const created = await app.inject({
                 method: 'POST',
                 url: '/api/sessions',
-                payload: { workspaceId: workspace.id, profile: 'default' },
+                payload: { workspaceId: workspace.id, profile: 'default', provider: 'codex' },
             });
             expect(created.statusCode).toBe(202);
             const restored = await app.inject({
@@ -3073,6 +3108,156 @@ describe('production composition', () => {
             });
             await app.close();
         });
+        it('keeps cold bootstrap passive while explicit Kimi session creation resolves a Kimi model', 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 sessionModelCalls = [];
+            const app = await composeAuthorizedApp({
+                root,
+                dataDir,
+                relyingParty,
+                installedCodexVersion: null,
+                installedKimiVersion: '2.0.2',
+                launchAppServer: () => fakeAppServer([]),
+                sessionModelCatalog: {
+                    list: async (provider) => {
+                        sessionModelCalls.push(provider);
+                        return provider === 'kimi' ? ['k2-thinking'] : ['gpt-5.6-terra'];
+                    },
+                },
+                profiles: {
+                    list: async () => [],
+                    require: async () => {
+                        throw new Error('CODEX_LAUNCHER_UNAVAILABLE');
+                    },
+                },
+            });
+            const bootstrap = await app.inject('/api/bootstrap');
+            const workspace = bootstrap
+                .json()
+                .workspaces[0]?.children.find((item) => item.name === 'workspace');
+            expect(bootstrap.json().models.kimi).toEqual([]);
+            expect(sessionModelCalls).toEqual([]);
+            const created = await app.inject({
+                method: 'POST',
+                url: '/api/sessions',
+                payload: { workspaceId: workspace.id, profile: 'default', provider: 'kimi' },
+            });
+            expect(created.statusCode).toBe(202);
+            expect(created.json()).toMatchObject({ provider: 'kimi', model: 'k2-thinking' });
+            expect(sessionModelCalls).toEqual(['kimi']);
+            await app.close();
+        });
+        it('keeps real server listen passive when Kimi is installed', 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 ensure = vi.fn(async () => {
+                throw new Error('passive startup must not ensure Kimi');
+            });
+            const app = await composeAuthorizedApp({
+                root,
+                dataDir,
+                relyingParty,
+                installedCodexVersion: null,
+                installedKimiVersion: '2.0.2',
+                startAppServers: true,
+                kimiServerManager: {
+                    ensure,
+                    get: () => null,
+                    list: () => [],
+                    stopAll: async () => { },
+                },
+                profiles: {
+                    list: async () => [],
+                    require: async () => {
+                        throw new Error('CODEX_LAUNCHER_UNAVAILABLE');
+                    },
+                },
+            });
+            await app.listen({ host: '127.0.0.1', port: 0 });
+            expect(ensure).not.toHaveBeenCalled();
+            await app.close();
+        });
+        it('delivers a realistic Codex answer notification through the journal to the chat projection', 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.calls.includes('thread/start'));
+            const started = await app.inject({
+                method: 'POST',
+                url: `/api/sessions/${sessionId}/turns`,
+                payload: { text: 'give the answer' },
+            });
+            expect(started.statusCode).toBe(202);
+            const turnId = started.json().activeTurnId;
+            const threadId = (await app.inject(`/api/sessions/${sessionId}`)).json().threadId;
+            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');
+            handle.notify({
+                method: 'item/completed',
+                params: {
+                    threadId,
+                    turnId,
+                    item: {
+                        id: 'answer-1',
+                        type: 'agentMessage',
+                        phase: 'final_answer',
+                        text: 'The provider boundary is intact.',
+                    },
+                },
+            });
+            await vi.waitFor(() => expect(messages.some((message) => message.event.type === 'agentMessageCompleted')).toBe(true));
+            const projection = messages
+                .map((message) => message.event)
+                .sort((left, right) => left.sequence - right.sequence)
+                .reduce((current, event) => applyProjectionEvent(current, event), createChatProjection(sessionId));
+            expect(projection.messages).toEqual([
+                expect.objectContaining({
+                    id: 'assistant:answer-1',
+                    role: 'assistant',
+                    text: 'The provider boundary is intact.',
+                    phase: 'final_answer',
+                    complete: true,
+                    turnId,
+                }),
+            ]);
+            socket.close();
+            await app.close();
+        });
         it('hands a replayed session-owned plan replacement off to its live close event exactly once', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
@@ -3110,7 +3295,7 @@ describe('production composition', () => {
             const created = await app.inject({
                 method: 'POST',
                 url: '/api/sessions',
-                payload: { workspaceId: workspace.id, profile: 'default' },
+                payload: { workspaceId: workspace.id, profile: 'default', provider: 'codex' },
             });
             const sessionId = created.json().id;
             await writeFile(planStatusFilePath(planStatusDirectoryPath(workspacePath, sessionId), planPath), JSON.stringify({
@@ -3234,7 +3419,7 @@ describe('production composition', () => {
             const created = await first.inject({
                 method: 'POST',
                 url: '/api/sessions',
-                payload: { workspaceId: workspace.id, profile: 'default' },
+                payload: { workspaceId: workspace.id, profile: 'default', provider: 'codex' },
             });
             expect(created.statusCode).toBe(202);
             expect(firstCalls).toEqual([
@@ -3316,7 +3501,7 @@ describe('production composition', () => {
             await app.inject({
                 method: 'POST',
                 url: '/api/sessions',
-                payload: { workspaceId: workspace.id, profile: 'default' },
+                payload: { workspaceId: workspace.id, profile: 'default', provider: 'codex' },
             });
             await app.close();
             // Model and skill catalogs run for bootstrap and session start; the active child closes with the relay.
@@ -3387,7 +3572,7 @@ describe('production composition', () => {
             const created = await app.inject({
                 method: 'POST',
                 url: '/api/sessions',
-                payload: { workspaceId: workspace.id, profile: 'default' },
+                payload: { workspaceId: workspace.id, profile: 'default', provider: 'codex' },
             });
             const sessionId = created.json().id;
             const handle = handles.find((candidate) => candidate.calls.includes('thread/start'));
@@ -3500,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',
                     },
                 },