gestalt-mobile 0.35.4 → 0.36.0

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;
@@ -152,13 +153,13 @@ const autopilotPlanText = (childState = 'TODO') => `#+TITLE: Autopilot fixture
 const completedAutopilotPlanText = () => autopilotPlanText('DONE')
     .replace('* WIP [#A] Parent', '* DONE [#A] Parent')
     .replace(':REVIEW_STATUS: UNREVIEWED', ':REVIEW_STATUS: REVIEWED');
-async function installAutopilotPlan(app, sessionId, workspacePath, name, childState = 'TODO') {
+async function installAutopilotPlan(app, sessionId, workspacePath, name, childState = 'TODO', reason = 'supervision-start') {
     const planPath = join(workspacePath, `${name}.org`);
     await writeFile(planPath, autopilotPlanText(childState));
     await writeFile(planStatusFilePath(planStatusDirectoryPath(workspacePath, sessionId), planPath), JSON.stringify({
         schemaVersion: 1,
         planPath,
-        reason: 'supervision-start',
+        reason,
         updatedAt: new Date().toISOString(),
     }));
     await expect
@@ -2242,6 +2243,37 @@ describe('production composition', () => {
         });
     });
     describeCompositionConcern('lifecycle', () => {
+        it('retains an authored plan without starting supervision', async () => {
+            const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
+            const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
+            ownTemporaryPaths(root, dataDir);
+            const workspacePath = join(root, 'workspace');
+            await mkdir(workspacePath);
+            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);
+            await installAutopilotPlan(app, sessionId, workspacePath, 'authored-only', 'TODO', 'authoring-start');
+            expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
+                autopilot: { enabled: false, state: 'disabled' },
+            });
+            expect(handles.flatMap((handle) => handle.requests.filter((request) => request.method === 'turn/start'))).toHaveLength(0);
+            await app.close();
+        });
         it('rejects a wait lease when automatic continuation is unavailable', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
@@ -2649,6 +2681,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'],
@@ -3029,7 +3062,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({
@@ -3042,6 +3075,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-'));
@@ -3079,7 +3262,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({
@@ -3203,7 +3386,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([
@@ -3285,7 +3468,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.
@@ -3356,7 +3539,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'));