gestalt-mobile 0.35.5 → 0.36.0

package/dist/server/server/features/sessions/promote-recent-thread/endpoint.js

@@ -8,13 +8,17 @@ import { RecentThreadHistoryUnavailable } from './use-case.js';
 const requestSchema = z.object({
     threadId: z.string().min(1),
     cwd: z.string().startsWith('/'),
+    // Requests written before provider support remain Codex-compatible.
+    provider: z.enum(['codex', 'kimi']).optional().default('codex'),
 });
 export function registerPromoteRecentThread(app, deps) {
     app.post('/api/sessions/recent-threads/open', { bodyLimit: 8 * 1024 }, async (request, reply) => {
         const parsed = requestSchema.safeParse(request.body);
         if (!parsed.success)
             return reply.code(400).send({ code: 'INVALID_RECENT_THREAD' });
-        const thread = (await deps.list()).find((candidate) => candidate.id === parsed.data.threadId && candidate.cwd === parsed.data.cwd);
+        const thread = (await deps.list()).find((candidate) => candidate.id === parsed.data.threadId &&
+            candidate.cwd === parsed.data.cwd &&
+            (candidate.provider ?? 'codex') === parsed.data.provider);
         if (!thread)
             return reply.code(404).send({ code: 'RECENT_THREAD_NOT_FOUND' });
         try {
@@ -27,7 +31,7 @@ export function registerPromoteRecentThread(app, deps) {
                     ? 'RECENT_THREAD_HISTORY_UNAVAILABLE'
                     : 'RECENT_THREAD_OPEN_FAILED',
                 detail: historyUnavailable
-                    ? 'The selected thread history is currently unavailable. Retry after Codex is available.'
+                    ? 'The selected thread history is currently unavailable. Retry after its provider is available.'
                     : 'The selected thread could not be opened. Retry shortly.',
             });
         }

package/dist/server/server/features/sessions/promote-recent-thread/use-case.js

@@ -11,7 +11,8 @@ export class RecentThreadHistoryUnavailable extends Error {
 }
 const inFlightPromotions = new Map();
 export async function promoteRecentThread(thread, deps) {
-    const key = `${thread.profile}:${thread.cwd}:${thread.id}`;
+    const provider = thread.provider ?? 'codex';
+    const key = `${provider}:${thread.profile}:${thread.cwd}:${thread.id}`;
     const ongoing = inFlightPromotions.get(key);
     if (ongoing)
         return ongoing;
@@ -26,7 +27,10 @@ export async function promoteRecentThread(thread, deps) {
     }
 }
 async function promote(thread, deps) {
-    const existing = deps.list().find((session) => session.threadId === thread.id);
+    const provider = thread.provider ?? 'codex';
+    const existing = deps
+        .list()
+        .find((session) => session.threadId === thread.id && (session.provider ?? 'codex') === provider);
     if (existing) {
         const executionPolicy = existing.executionPolicy
             ? undefined
@@ -51,6 +55,7 @@ async function promote(thread, deps) {
             id: deps.createId(),
             workspaceId: thread.cwd,
             workspacePath: thread.cwd,
+            provider,
             profile: thread.profile,
             threadId: thread.id,
             ...(executionPolicy === undefined ? {} : { executionPolicy }),

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

@@ -17,6 +17,7 @@ import { registerReleaseSession } from './release-session/endpoint.js';
 import { registerRestoreSession } from './restore-session/endpoint.js';
 import { registerRespondInteraction } from './respond-interaction/endpoint.js';
 import { registerSelectModel } from './select-model/endpoint.js';
+import { registerListSessionModels } from './list-models/endpoint.js';
 import { registerSessionEvents } from './session-events/endpoint.js';
 import { registerStartSession } from './start-session/endpoint.js';
 import { registerStartTurn } from './start-turn/endpoint.js';
@@ -27,8 +28,10 @@ export function registerSessionRoutes(app, deps) {
     if (deps.recentThreads) {
         registerListRecentThreads(app, {
             ...deps.recentThreads,
-            metadata: (threadId) => {
-                const session = sessions?.list?.().find((candidate) => candidate.threadId === threadId);
+            metadata: (threadId, provider) => {
+                const session = sessions
+                    ?.list?.()
+                    .find((candidate) => candidate.threadId === threadId && (candidate.provider ?? 'codex') === provider);
                 if (!session)
                     return null;
                 return {
@@ -44,6 +47,8 @@ export function registerSessionRoutes(app, deps) {
         });
     }
     if (sessions) {
+        if (sessions.sessionModels)
+            registerListSessionModels(app, sessions.sessionModels);
         registerStartSession(app, {
             ...sessions,
             reportFailure: (operation, error) => deps.logger.error(`${operation} failed: ${safeErrorLabel(error)}`),
@@ -84,7 +89,7 @@ export function registerSessionRoutes(app, deps) {
         if (sessions.models)
             registerSelectModel(app, {
                 find: sessions.find,
-                models: () => sessions.models.list(),
+                models: (provider) => sessions.models.list(provider),
                 now: sessions.now,
                 save: sessions.save,
             });

package/dist/server/server/features/sessions/respond-interaction/endpoint.js

@@ -18,7 +18,7 @@ export function registerRespondInteraction(app, deps) {
             return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
         if (deps.validate && !deps.validate(id, requestId, value))
             return reply.code(400).send({ code: 'INTERACTION_RESPONSE_INVALID' });
-        const delivery = deps.reply(id, requestId, value);
+        const delivery = await deps.reply(id, requestId, value);
         if (delivery === false || delivery === 'unavailable')
             return reply.code(409).send({ code: 'INTERACTION_DELIVERY_UNAVAILABLE' });
         if (delivery === 'cleared') {

package/dist/server/server/features/sessions/select-model/endpoint.js

@@ -12,7 +12,7 @@ export function registerSelectModel(app, deps) {
         const model = request.body.model;
         if (typeof model !== 'string')
             return reply.code(400).send({ code: 'MODEL_REQUIRED' });
-        if (!(await deps.models()).includes(model))
+        if (!(await deps.models(session.provider)).includes(model))
             return reply.code(400).send({ code: 'MODEL_UNAVAILABLE' });
         if (session.state !== 'ready')
             return reply.code(409).send({ code: 'SESSION_NOT_READY' });

package/dist/server/server/features/sessions/start-session/request.js

@@ -6,6 +6,7 @@
 import { z } from 'zod';
 const schema = z.object({
     workspaceId: z.string().min(1),
+    provider: z.enum(['codex', 'kimi']),
     profile: z.string().min(1),
     skillProfile: z.string().trim().min(1).optional(),
     model: z

package/dist/server/server/features/sessions/start-session/use-case.js

@@ -8,15 +8,28 @@ import { DEFAULT_SESSION_MODEL } from '../application/start-settings.js';
 import { reconcileSkillSelectionSnapshot, } from '../../skills/model/skill-profile.js';
 import { SkillProfileError } from '../../skills/model/errors.js';
 export async function startSession(input, deps) {
-    const model = input.model ?? DEFAULT_SESSION_MODEL;
+    // Codex launcher profiles select the app-server skill directory. Kimi owns
+    // its isolated profile lifecycle, so it must not require a Codex launcher
+    // profile before its own catalog/runtime can be selected.
     const [workspace] = await Promise.all([
         deps.workspaces.resolve(input.workspaceId),
-        deps.profiles.require(input.profile),
+        ...(input.provider === 'codex' ? [deps.profiles.require(input.profile)] : []),
     ]);
-    if (deps.models) {
-        const models = await deps.models.list();
+    let model = input.model;
+    const modelCatalog = deps.sessionModels ?? deps.models;
+    if (modelCatalog) {
+        const models = await modelCatalog.list(input.provider);
+        // An omitted model resolves to the provider's own default: the relay-wide
+        // default when that provider serves it, otherwise the provider's first
+        // available model, so a kimi request never inherits the codex default.
+        model ??= models.includes(DEFAULT_SESSION_MODEL)
+            ? DEFAULT_SESSION_MODEL
+            : (models[0] ?? DEFAULT_SESSION_MODEL);
         if (!models.includes(model))
-            throw new Error('CODEX_MODEL_UNAVAILABLE');
+            throw new Error(input.provider === 'codex' ? 'CODEX_MODEL_UNAVAILABLE' : 'KIMI_MODEL_UNAVAILABLE');
+    }
+    else {
+        model ??= DEFAULT_SESSION_MODEL;
     }
     const selectedProfile = input.skillProfile
         ? await deps.skillProfiles.readGlobalProfile(input.skillProfile)
@@ -25,7 +38,7 @@ export async function startSession(input, deps) {
         throw new SkillProfileError('UNKNOWN_SKILL_PROFILE', 'The selected skill profile does not exist.');
     const [projectProfile, catalog] = await Promise.all([
         deps.skillProfiles.readWorkspaceDefault(workspace.realPath),
-        deps.skillCatalog(input.profile).list(workspace.realPath),
+        deps.skillCatalog(input.provider, input.profile).list(workspace.realPath),
     ]);
     const sourceProfile = selectedProfile ?? projectProfile;
     const reconciledSkills = reconcileSkillSelectionSnapshot(catalog.skills, sourceProfile?.skills);
@@ -46,6 +59,7 @@ export async function startSession(input, deps) {
         id: deps.createId(),
         workspaceId: workspace.id,
         workspacePath: workspace.realPath,
+        provider: input.provider,
         profile: input.profile,
         model,
         ...(branch ? { branch } : {}),
@@ -57,7 +71,7 @@ export async function startSession(input, deps) {
     deps.save(session);
     if (!deps.activate)
         return session;
-    const active = await deps.activate(session, {});
+    const active = await deps.activate(session, { provider: session.provider });
     deps.save(active);
     return active;
 }

package/dist/server/server/features/skills/list-available/endpoint.js

@@ -11,6 +11,7 @@ const querySchema = z
     .object({
     workspaceId: z.string().min(1),
     profile: z.string().min(1),
+    provider: z.enum(['codex', 'kimi']).optional(),
     refresh: z.enum(['true']).optional(),
 })
     .strict();
@@ -28,10 +29,11 @@ export function registerListAvailableSkills(app, deps) {
                 deps.workspaces.resolve(parsed.data.workspaceId),
                 deps.profiles.require(parsed.data.profile),
             ]);
+            const provider = parsed.data.provider ?? 'codex';
             const [discovered, project] = await Promise.all([
                 parsed.data.refresh
-                    ? deps.catalog.refresh(profile.name, workspace.realPath)
-                    : deps.catalog.list(profile.name, workspace.realPath),
+                    ? deps.catalog.refresh(provider, profile.name, workspace.realPath)
+                    : deps.catalog.list(provider, profile.name, workspace.realPath),
                 deps.selections.readWorkspaceDefault(workspace.realPath),
             ]);
             const skills = applySkillSelectionSnapshot(discovered.skills, project?.skills);

package/dist/server/server/platform/catalog/provider-model-catalog.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Routes each provider's model query to that provider's own catalog adapter. */
+export class ProviderModelCatalog {
+    catalogs;
+    constructor(catalogs) {
+        this.catalogs = catalogs;
+    }
+    list(provider) {
+        return this.catalogs[provider].list();
+    }
+}

package/dist/server/server/platform/kimi/kimi-activity-facts.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * Decodes bounded activity evidence from kimi web events. Turn lifecycle is
+ * prompt-based; `agent.status.updated` supplies context usage and
+ * awaiting-human transitions (kimi 2.0.2 has no dedicated interaction events —
+ * pending approvals/questions arrive through status changes plus REST lists).
+ */
+export function decodeKimiActivityFacts(sessionId, occurredAt, event, context) {
+    const payload = record(event.payload);
+    if (!payload || typeof payload.type !== 'string')
+        return [];
+    switch (payload.type) {
+        case 'turn.started': {
+            const agentId = safeId(payload.agentId);
+            const turnNumber = safeTurn(payload.turnId);
+            if (!agentId || turnNumber === null)
+                return [];
+            const turnId = context.resolveTurnId(agentId, turnNumber);
+            return [
+                {
+                    sessionId,
+                    occurredAt,
+                    kind: 'turnStarted',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    ...(turnId ? { turnId } : {}),
+                    ...(context.isChildAgent(agentId) ? { childThreadId: agentId } : {}),
+                },
+            ];
+        }
+        case 'prompt.completed':
+        case 'prompt.aborted': {
+            const agentId = safeId(payload.agentId);
+            const promptId = safeId(payload.promptId);
+            if (!agentId || !promptId || context.isChildAgent(agentId))
+                return [];
+            return [
+                {
+                    sessionId,
+                    occurredAt,
+                    kind: 'turnCompleted',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    turnId: promptId,
+                },
+            ];
+        }
+        case 'agent.status.updated': {
+            const status = typeof payload.status === 'string' ? payload.status : null;
+            const facts = [];
+            const usage = typeof payload.contextUsage === 'number' ? payload.contextUsage : null;
+            if (usage !== null && usage >= 0) {
+                facts.push({
+                    sessionId,
+                    occurredAt,
+                    kind: 'contextUsage',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    contextUsedPercent: usage <= 1 ? Math.round(usage * 100) : Math.min(100, Math.round(usage)),
+                });
+            }
+            if (status === 'awaiting_approval' || status === 'awaiting_question') {
+                facts.push({
+                    sessionId,
+                    occurredAt,
+                    kind: 'interactionPending',
+                    ...(event.session_id ? { threadId: event.session_id } : {}),
+                    attentionReason: status === 'awaiting_approval' ? 'permissionRequired' : 'materialAmbiguity',
+                });
+            }
+            return facts;
+        }
+        default:
+            return [];
+    }
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function safeId(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 256 ? value : null;
+}
+function safeTurn(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}

package/dist/server/server/platform/kimi/kimi-errors.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
+ */
+/**
+ * Error surfaced by the kimi web client. `code` is the protocol business code
+ * (0 means success on the wire, so a thrown error always has code !== 0);
+ * HTTP-level failures are normalized to code -1 with the transport message.
+ */
+export class KimiWebError extends Error {
+    code;
+    requestId;
+    constructor(code, message, requestId) {
+        super(boundMessage(message));
+        this.code = code;
+        this.requestId = requestId;
+        this.name = 'KimiWebError';
+    }
+}
+export function isKimiWebError(error) {
+    return error instanceof KimiWebError;
+}
+/** Caps and redacts wire messages before they enter logs or client payloads. */
+export function boundMessage(message) {
+    return message
+        .replace(/((?:authorization|token|api[_ -]?key|password)\s*[:=]\s*)\S+/gi, '$1[REDACTED]')
+        .replace(/(authentication failed:\s*).*/i, '$1[REDACTED]')
+        .slice(0, 256);
+}

package/dist/server/server/platform/kimi/kimi-model-catalog.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const MODELS_TIMEOUT_MS = 5_000;
+/**
+ * Lists kimi model aliases from a running gestalt-owned kimi web server
+ * (`GET /api/v1/models`) when a Kimi profile server is already running.
+ * Discovery is deliberately read-only: bootstrap must not spawn or wait for
+ * Kimi on behalf of an otherwise ordinary Codex client. Explicit Kimi session
+ * activation owns server startup; any discovery failure degrades to an empty
+ * list, matching the catalog contract.
+ */
+export class KimiModelCatalog {
+    servers;
+    available;
+    constructor(servers, available) {
+        this.servers = servers;
+        this.available = available;
+    }
+    async list() {
+        if (!this.available || !this.servers)
+            return [];
+        try {
+            const handle = this.servers.list()[0];
+            if (!handle)
+                return [];
+            return await this.read(handle);
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Explicit Kimi session setup may start its isolated default server. */
+    async listForSession() {
+        if (!this.available || !this.servers)
+            return [];
+        try {
+            return await this.read(await this.servers.ensure('default', []));
+        }
+        catch {
+            return [];
+        }
+    }
+    async read(handle) {
+        const data = await withTimeout(handle.client.get('/api/v1/models'), MODELS_TIMEOUT_MS, 'kimi model list timed out');
+        const items = Array.isArray(data?.items)
+            ? data.items
+            : [];
+        return [
+            ...new Set(items.flatMap((item) => typeof item.model === 'string' && item.model.length > 0 && item.model.length <= 128
+                ? [item.model]
+                : [])),
+        ].sort();
+    }
+}
+function withTimeout(promise, timeoutMs, message) {
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => setTimeout(() => reject(new Error(message)), timeoutMs).unref()),
+    ]);
+}

package/dist/server/server/platform/kimi/kimi-normalizer.js

@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * Maps kimi web session events onto the relay's provider-neutral event types.
+ * The relay's turn lifecycle is prompt-based (`prompt.completed`/`aborted`),
+ * because a gestalt turn id is the kimi prompt id; `turn.started` exists only
+ * to bind kimi per-agent turn numbers to prompt ids. Unknown future event
+ * types deliberately become `null`, mirroring the codex normalizer.
+ */
+export function normalizeKimiEvent(sessionId, sequence, occurredAt, event, context = {
+    resolveTurnId: () => null,
+    isChildAgent: () => false,
+}) {
+    const payload = record(event.payload);
+    if (!payload || typeof payload.type !== 'string')
+        return null;
+    switch (payload.type) {
+        case 'assistant.delta': {
+            const agentId = safeId(payload.agentId);
+            const turnNumber = safeTurn(payload.turnId);
+            const delta = bounded(payload.delta, 64_000);
+            if (!agentId || turnNumber === null || delta === null)
+                return null;
+            if (context.isChildAgent(agentId))
+                return null;
+            const turnId = context.resolveTurnId(agentId, turnNumber) ?? `kimi:${agentId}:${turnNumber}`;
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'agentMessageDelta',
+                payload: { text: delta, itemId: `kimi:${agentId}:${turnNumber}`, turnId },
+            };
+        }
+        case 'tool.call.started': {
+            const toolCallId = safeId(payload.toolCallId);
+            const agentId = safeId(payload.agentId) ?? 'main';
+            const turnNumber = safeTurn(payload.turnId);
+            if (!toolCallId || turnNumber === null)
+                return null;
+            const display = record(payload.display);
+            const kind = typeof display?.kind === 'string' ? display.kind : 'generic';
+            const name = safeId(payload.name);
+            const description = bounded(payload.description, 500);
+            const detail = (typeof display?.command === 'string' ? bounded(display.command, 500) : null) ??
+                (typeof display?.path === 'string' ? bounded(display.path, 500) : null) ??
+                description ??
+                name ??
+                kind;
+            const label = kind === 'command' || kind === 'bash'
+                ? 'Command'
+                : kind === 'file_io'
+                    ? 'File'
+                    : `Tool · ${name ?? kind}`;
+            const owner = ownership(agentId, turnNumber, context);
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: { id: toolCallId, label, detail, ...owner },
+            };
+        }
+        case 'tool.result': {
+            const toolCallId = safeId(payload.toolCallId);
+            const agentId = safeId(payload.agentId) ?? 'main';
+            const turnNumber = safeTurn(payload.turnId);
+            if (!toolCallId || turnNumber === null)
+                return null;
+            const isError = payload.isError === true;
+            const owner = ownership(agentId, turnNumber, context);
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: {
+                    id: toolCallId,
+                    label: isError ? 'Tool error' : 'Tool result',
+                    detail: bounded(safeJson(payload.output), 400) ?? (isError ? 'failed' : 'done'),
+                    ...owner,
+                },
+            };
+        }
+        case 'subagent.spawned': {
+            const subagentId = safeId(payload.subagentId);
+            if (!subagentId)
+                return null;
+            const name = bounded(payload.subagentName, 128);
+            const description = bounded(payload.description, 300);
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: {
+                    id: subagentId,
+                    label: 'Subagent',
+                    detail: [name, description].filter(Boolean).join(' · '),
+                    ...(context.activeTurnId ? { turnId: context.activeTurnId } : {}),
+                },
+            };
+        }
+        case 'subagent.completed':
+        case 'subagent.failed': {
+            const subagentId = safeId(payload.subagentId);
+            if (!subagentId)
+                return null;
+            const failed = payload.type === 'subagent.failed';
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'activity.updated',
+                payload: {
+                    id: subagentId,
+                    label: failed ? 'Subagent failed' : 'Subagent completed',
+                    detail: bounded(payload.resultSummary, 500) ?? '',
+                    ...(context.activeTurnId ? { turnId: context.activeTurnId } : {}),
+                },
+            };
+        }
+        case 'prompt.completed': {
+            const agentId = safeId(payload.agentId);
+            const promptId = safeId(payload.promptId);
+            if (!agentId || !promptId || context.isChildAgent(agentId))
+                return null;
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'turnCompleted',
+                payload: {
+                    turn: {
+                        id: promptId,
+                        ...(typeof payload.reason === 'string' ? { status: bounded(payload.reason, 64) } : {}),
+                    },
+                },
+            };
+        }
+        case 'prompt.aborted': {
+            const agentId = safeId(payload.agentId);
+            const promptId = safeId(payload.promptId);
+            if (!agentId || !promptId || context.isChildAgent(agentId))
+                return null;
+            return {
+                sessionId,
+                sequence,
+                occurredAt,
+                type: 'turnInterrupted',
+                payload: { turn: { id: promptId } },
+            };
+        }
+        default:
+            return null;
+    }
+}
+function ownership(agentId, turnNumber, context) {
+    if (context.isChildAgent(agentId)) {
+        return {
+            ...(context.activeTurnId ? { turnId: context.activeTurnId } : {}),
+            actorTurnId: `${agentId}:${turnNumber}`,
+        };
+    }
+    const turnId = context.resolveTurnId(agentId, turnNumber);
+    return turnId ? { turnId } : context.activeTurnId ? { turnId: context.activeTurnId } : {};
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function safeId(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 256 ? value : null;
+}
+function safeTurn(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function bounded(value, max) {
+    return typeof value === 'string' ? value.slice(0, max) : null;
+}
+function safeJson(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === 'string')
+        return value.slice(0, 400);
+    try {
+        return JSON.stringify(value).slice(0, 400);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/server/platform/kimi/kimi-recent-session-lister.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const LIST_PATH = '/api/v2/sessions?page_size=50&sort=meta.updated_at_desc';
+const LIST_TIMEOUT_MS = 5_000;
+/**
+ * Lists recent kimi web sessions across every running gestalt-owned server,
+ * for parity with the codex recent-thread lister. Each skill profile owns an
+ * isolated `kimi web` process and state directory, so a profile's sessions
+ * only exist on that profile's server; only already-running servers are
+ * queried, never spawned just to list. kimi timestamps arrive as epoch
+ * seconds (or, defensively, epoch millis), normalized to seconds.
+ */
+export function createKimiRecentSessionLister(deps) {
+    return {
+        async list() {
+            if (!deps.available || !deps.servers)
+                return [];
+            const listings = await Promise.all(deps.servers.list().map(listFromServer));
+            return listings.flat().sort((a, b) => (b.recencyAt ?? 0) - (a.recencyAt ?? 0));
+        },
+    };
+}
+async function listFromServer(handle) {
+    try {
+        const data = (await withTimeout(handle.client.get(LIST_PATH), LIST_TIMEOUT_MS, 'kimi session list timed out'));
+        const items = Array.isArray(data.items) ? data.items : [];
+        return items.flatMap((item) => {
+            if (!item || typeof item !== 'object')
+                return [];
+            const workspace = item.workspace;
+            const cwd = workspace && typeof workspace === 'object'
+                ? workspace.cwd
+                : undefined;
+            if (typeof item.id !== 'string' || typeof cwd !== 'string' || !cwd.startsWith('/'))
+                return [];
+            const updatedAt = item.meta && typeof item.meta === 'object'
+                ? item.meta.updated_at
+                : undefined;
+            return [
+                {
+                    id: item.id,
+                    cwd,
+                    profile: handle.profileKey,
+                    recencyAt: toEpochSeconds(updatedAt),
+                    provider: 'kimi',
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function toEpochSeconds(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    // Epoch millis are roughly 1e12+ today; seconds stay below 1e11 for decades.
+    return value > 1e11 ? Math.floor(value / 1000) : Math.floor(value);
+}
+function withTimeout(promise, timeoutMs, message) {
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => setTimeout(() => reject(new Error(message)), timeoutMs).unref()),
+    ]);
+}