gestalt-mobile 0.42.0 → 0.43.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-BRly-q56.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-D57mr3B1.css">
+    <script type="module" crossorigin src="/assets/index-BLgr7z1T.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-5-CmBBPG.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/app.js

@@ -7,7 +7,7 @@ import fastifyStatic from '@fastify/static';
 import fastifyCookie from '@fastify/cookie';
 import fastify, {} from 'fastify';
 import { registerGetHealth } from './features/health/get-health/endpoint.js';
-import { registerGetBootstrap } from './features/catalog/get-bootstrap/endpoint.js';
+import { registerCatalogRoutes } from './features/catalog/register-routes.js';
 import { registerAuthRoutes } from './features/auth/register-routes.js';
 import { registerGitRoutes } from './features/git/register-routes.js';
 import { registerPlanRoutes } from './features/plans/register-routes.js';
@@ -45,8 +45,7 @@ export async function buildApp(deps) {
         });
     registerGetHealth(app, deps.health);
     registerAuthRoutes(app, deps);
-    if (deps.bootstrap)
-        registerGetBootstrap(app, deps.bootstrap);
+    registerCatalogRoutes(app, { bootstrap: deps.bootstrap, sessionDefaults: deps.sessionDefaults });
     registerSessionRoutes(app, deps);
     if (deps.autopilot)
         registerAutopilotRoutes(app, deps.autopilot, deps.sessionRoutes?.idempotency, deps.sessionRoutes ? (id) => deps.sessionRoutes?.find(id)?.provider : undefined);

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

@@ -2886,6 +2886,9 @@ 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'],
+                ['GET', '/api/session-defaults', '/api/session-defaults', 'protected'],
+                ['HEAD', '/api/session-defaults', '/api/session-defaults', 'protected'],
+                ['PUT', '/api/session-defaults', '/api/session-defaults', 'protected'],
                 ['POST', '/api/session-models/:provider', '/api/session-models/codex', 'protected'],
                 ['POST', '/api/sessions', '/api/sessions', 'protected'],
                 ['GET', '/api/sessions', '/api/sessions', 'protected'],
@@ -2914,6 +2917,24 @@ describe('production composition', () => {
                 ['GET', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
                 ['HEAD', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
                 ['DELETE', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
+                [
+                    'POST',
+                    '/api/workspaces/:workspaceId/files/references',
+                    '/api/workspaces/workspace-1/files/references',
+                    'protected',
+                ],
+                [
+                    'GET',
+                    '/api/workspaces/:workspaceId/files/preview',
+                    '/api/workspaces/workspace-1/files/preview?path=README.md',
+                    'protected',
+                ],
+                [
+                    'HEAD',
+                    '/api/workspaces/:workspaceId/files/preview',
+                    '/api/workspaces/workspace-1/files/preview?path=README.md',
+                    'protected',
+                ],
                 [
                     'GET',
                     '/api/workspaces/:workspaceId/files',
@@ -2974,6 +2995,12 @@ describe('production composition', () => {
                     '/api/workspaces/workspace-1/plans/plan.org',
                     'protected',
                 ],
+                [
+                    'POST',
+                    '/api/workspaces/:workspaceId/plans/:planName/archive',
+                    '/api/workspaces/workspace-1/plans/.gestalt%2Fplan.org/archive',
+                    'protected',
+                ],
                 [
                     'GET',
                     '/api/git/repositories/:workspaceId',

package/dist/server/server/composition.js

@@ -6,6 +6,8 @@
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { FilesystemSessionDefaults } from './platform/persistence/filesystem-session-defaults.js';
+import { SessionModelConfig } from './platform/codex/session-model-config.js';
 import { basename, dirname, join, resolve } from 'node:path';
 import { debuglog } from 'node:util';
 import { buildApp } from './app.js';
@@ -59,6 +61,7 @@ import { compileSkillOverride } from './features/skills/model/skill-profile.js';
 import { SupervisedPlanRegistry } from './features/plans/application/supervised-plan-registry.js';
 import { FilesystemPlanStatusSource } from './platform/plans/filesystem-plan-status-source.js';
 import { FilesystemWorkspacePlanCatalog } from './platform/plans/filesystem-workspace-plan-catalog.js';
+import { FilesystemPlanArchiver } from './platform/plans/filesystem-plan-archiver.js';
 import { checkpointPlanMeasurement } from './platform/plans/plan-measurement-command.js';
 import { PlanMeasurementRefresh } from './platform/plans/plan-measurement-refresh.js';
 import { SqliteAutopilotStore } from './platform/persistence/sqlite-autopilot-store.js';
@@ -389,6 +392,8 @@ export async function composeRelayApp(options) {
         list: (provider) => (provider === 'kimi' ? kimiModels.listForSession() : models.list(provider)),
     };
     const skillProfiles = new FilesystemSkillProfileStore(options.homeDirectory ?? homedir());
+    const sessionDefaults = new FilesystemSessionDefaults(options.homeDirectory ?? homedir());
+    const sessionModelConfig = new SessionModelConfig(process.env.CODEX_HOME ?? join(options.homeDirectory ?? homedir(), '.codex-gestalt'), dirname(databasePath));
     // kimi discovery is workspace-scoped, not profile-scoped: the profile only
     // decides which discovered skills a session's server materializes.
     const kimiSkillCatalog = new KimiSkillCatalog(kimiManager ?? null, kimiManager != null);
@@ -397,6 +402,7 @@ export async function composeRelayApp(options) {
         : new CodexSkillCatalog(profile, options.launchAppServer ?? launchCodexAppServer);
     const editorSkillCatalog = new CachedSkillCatalog((provider, profile, workspace) => skillCatalog(provider, profile).list(workspace));
     const workspacePlanCatalog = new FilesystemWorkspacePlanCatalog();
+    const planArchiver = new FilesystemPlanArchiver();
     const resolveSkills = async (session) => {
         const catalog = session.provider === 'kimi'
             ? await kimiSkillCatalog.list(session.workspacePath)
@@ -907,7 +913,7 @@ export async function composeRelayApp(options) {
             failPendingCheckpointHandoffs(sessionId, false);
             dismissPendingInteractions(sessionId, new Date().toISOString(), 'failed');
             recoverExitedSession(sessionId);
-        }, resolveSkills, planStatusSource, acceptPlanUpdate, options.planMeasurementBaseUrl, 30_000, 64, root)
+        }, resolveSkills, planStatusSource, acceptPlanUpdate, options.planMeasurementBaseUrl, 30_000, 64, root, (session) => sessionModelConfig.resolve(session))
         : null;
     const handleKimiNotification = (sessionId, event) => {
         const occurredAt = new Date().toISOString();
@@ -1155,7 +1161,9 @@ export async function composeRelayApp(options) {
             staticDir: options.staticDir,
             pwaIcon: options.pwaIcon,
             recentThreads: recentThreadsForRelay,
+            sessionDefaults,
             bootstrap: {
+                sessionDefaults,
                 workspaces,
                 profiles: options.profiles,
                 models,
@@ -1390,7 +1398,7 @@ export async function composeRelayApp(options) {
                     events.publish(journal.append(id, 'plan.closed', {}, occurredAt));
                 },
             },
-            workspacePlanRoutes: { workspaces, plans: workspacePlanCatalog },
+            workspacePlanRoutes: { workspaces, plans: workspacePlanCatalog, archiver: planArchiver },
             workspaceFileRoutes: { workspaces, files: workspaceFiles },
             autopilot,
             ...(runtime

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

@@ -102,6 +102,10 @@ export class AgentActivityRegistry {
                     kind: 'collaboration',
                     childId: child.id,
                     childStatus: 'notLoaded',
+                    // The bounded roster/process read is authoritative as a unit. If a
+                    // child disappeared, its previous runtime-local process projection
+                    // cannot remain eligible as live work after this reconciliation.
+                    childOwnedProcesses: [],
                 });
         // A malformed/unknown `thread/list` row is not proof that a child is
         // healthy. Preserve it as disconnected but keep the aggregate qualified

package/dist/server/server/features/autopilot/application/policy.js

@@ -49,6 +49,47 @@ export function classifyAgentActivity(activity) {
     const subagentsSettled = activity.aggregateSubagents === 'idle' || activity.aggregateSubagents === 'blocked';
     return rootSettled && subagentsSettled ? 'settled' : 'observe';
 }
+/**
+ * Classifies actor state against the plan position that can legally run next.
+ * Completed canonical executors remain visible evidence, but their terminal
+ * topology cannot indefinitely turn a fresh read into a reconciliation loop.
+ */
+function classifySupervisedActivity(activity, plan) {
+    const selected = plan.steps.findIndex((step) => step.id === plan.currentStepId || step.state === 'WIP');
+    const index = selected >= 0 ? selected : plan.steps.findIndex((step) => step.state !== 'DONE');
+    if (index < 0)
+        return classifyAgentActivity(activity);
+    const position = index + 1;
+    const retained = activity.subagents.filter((child) => {
+        const match = /^L([1-9]\d*)$/.exec(child.canonicalPosition ?? '');
+        if (!match)
+            return true;
+        const historical = Number(match[1]) < position;
+        const supervisedProcess = child.ownedProcesses?.some((process) => process.ownership === 'supervisor' &&
+            (process.state === 'running' || process.state === 'detached-active'));
+        return !historical || supervisedProcess;
+    });
+    // An aggregate-only observation cannot prove which child is historical.
+    if (retained.length === activity.subagents.length)
+        return classifyAgentActivity(activity);
+    if (activity.root.state === 'awaitingHuman' ||
+        retained.some((child) => child.state === 'awaitingHuman'))
+        return 'attention';
+    if (activity.root.state === 'working' ||
+        retained.some((child) => child.state === 'working' ||
+            child.state === 'awaitingAgent' ||
+            child.ownedProcesses?.some((process) => (child.state !== 'disconnected' || process.ownership === 'supervisor') &&
+                (process.state === 'running' || process.state === 'detached-active'))))
+        return 'active';
+    if (activity.root.state === 'disconnected' ||
+        retained.some((child) => child.state === 'disconnected'))
+        return 'reconcile';
+    const rootSettled = activity.root.state === 'idle' ||
+        activity.root.state === 'blocked' ||
+        activity.root.state === 'awaitingAgent';
+    const childrenSettled = retained.every((child) => child.state === 'idle' || child.state === 'blocked');
+    return rootSettled && childrenSettled ? 'settled' : 'observe';
+}
 /** A deliberately pure, exhaustive safety gate. Adapters may only enact this result. */
 export function decideAutopilot(input) {
     const { state, plan, activity, hasPendingInteraction, now, policy } = input;
@@ -93,7 +134,7 @@ export function decideAutopilot(input) {
         return { kind: 'reconcile' };
     if (Date.parse(now) - Date.parse(activity.root.observedAt) > policy.staleAfterMs)
         return { kind: 'reconcile' };
-    const disposition = classifyAgentActivity(activity);
+    const disposition = classifySupervisedActivity(activity, plan);
     if (disposition === 'attention')
         return { kind: 'observe' };
     if (disposition === 'reconcile')

package/dist/server/server/features/catalog/get-bootstrap/use-case.js

@@ -10,7 +10,18 @@ export async function getBootstrap(deps) {
         deps.models?.list('codex').catch(() => []) ?? [],
         deps.models?.list('kimi').catch(() => []) ?? [],
     ]);
+    let sessionDefaults = null;
+    let sessionDefaultsError = false;
+    if (deps.sessionDefaults) {
+        try {
+            sessionDefaults = await deps.sessionDefaults.read();
+        }
+        catch {
+            sessionDefaultsError = true;
+        }
+    }
     return {
+        ...(deps.sessionDefaults ? { sessionDefaults, sessionDefaultsError } : {}),
         workspaces,
         profiles,
         models: { codex: codexModels, kimi: kimiModels },

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { registerGetBootstrap } from './get-bootstrap/endpoint.js';
+import { registerSessionDefaults } from './session-defaults/endpoint.js';
+export function registerCatalogRoutes(app, deps) {
+    if (deps.bootstrap)
+        registerGetBootstrap(app, deps.bootstrap);
+    if (deps.sessionDefaults)
+        registerSessionDefaults(app, deps.sessionDefaults);
+}

package/dist/server/server/features/catalog/session-defaults/endpoint.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { sessionDefaultsSchema, } from '../../../../shared/contracts/session-defaults.js';
+export function registerSessionDefaults(app, store) {
+    app.get('/api/session-defaults', async () => ({ defaults: await store.read() }));
+    app.put('/api/session-defaults', async (request, reply) => {
+        const parsed = sessionDefaultsSchema.safeParse(request.body);
+        if (!parsed.success)
+            return reply.code(400).send({ error: 'INVALID_SESSION_DEFAULTS' });
+        await store.save(parsed.data);
+        return { defaults: parsed.data };
+    });
+}

package/dist/server/server/features/files/check-references/endpoint.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerCheckReferences(app, deps) {
+    if (!deps.files.exists)
+        return;
+    app.post('/api/workspaces/:workspaceId/files/references', async (request, reply) => {
+        const body = request.body;
+        const paths = body?.paths;
+        if (!Array.isArray(paths) ||
+            paths.length > 64 ||
+            !paths.every((path) => typeof path === 'string' && path.length <= 4096 && !path.includes('\0')))
+            return reply.code(400).send({ code: 'INVALID_FILE_REFERENCES' });
+        try {
+            const workspace = await deps.workspaces.resolve(request.params.workspaceId);
+            const unique = [...new Set(paths)];
+            const existing = [];
+            for (let index = 0; index < unique.length; index += 8) {
+                const group = unique.slice(index, index + 8);
+                const results = await Promise.all(group.map((path) => deps.files.exists(workspace.realPath, path)));
+                group.forEach((path, offset) => {
+                    if (results[offset])
+                        existing.push(path);
+                });
+            }
+            return reply.send({ paths: existing });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND')
+                return reply.code(404).send({ code: 'WORKSPACE_NOT_FOUND' });
+            return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+        }
+    });
+}

package/dist/server/server/features/files/read-entry/endpoint.js

@@ -0,0 +1,28 @@
+export function registerReadEntry(app, deps) {
+    if (!deps.files.read)
+        return;
+    app.get('/api/workspaces/:workspaceId/files/preview', async (request, reply) => {
+        const { path } = request.query;
+        if (typeof path !== 'string' || path.includes('\0') || path.length > 4096)
+            return reply.code(400).send({ code: 'INVALID_FILE_PREVIEW' });
+        try {
+            const workspace = await deps.workspaces.resolve(request.params.workspaceId);
+            const result = await deps.files.read(workspace.realPath, path);
+            if (result.kind === 'available')
+                return reply.send(result.preview);
+            const errors = {
+                missing: [404, 'FILE_PREVIEW_NOT_FOUND'],
+                unreadable: [403, 'FILE_PREVIEW_UNREADABLE'],
+                unsupported: [415, 'FILE_PREVIEW_UNSUPPORTED'],
+                'too-large': [413, 'FILE_PREVIEW_TOO_LARGE'],
+            };
+            const [status, code] = errors[result.kind];
+            return reply.code(status).send({ code });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND')
+                return reply.code(404).send({ code: 'WORKSPACE_NOT_FOUND' });
+            return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+        }
+    });
+}

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

@@ -3,6 +3,8 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { registerCheckReferences } from './check-references/endpoint.js';
+import { registerReadEntry } from './read-entry/endpoint.js';
 import { registerListDirectory } from './list-directory/endpoint.js';
 import { registerCopyEntry } from './copy-entry/endpoint.js';
 import { registerMoveEntry } from './move-entry/endpoint.js';
@@ -11,6 +13,8 @@ import { registerDeleteEntry } from './delete-entry/endpoint.js';
 export function registerFileRoutes(app, deps) {
     if (!deps.workspaceFileRoutes)
         return;
+    registerCheckReferences(app, deps.workspaceFileRoutes);
+    registerReadEntry(app, deps.workspaceFileRoutes);
     registerListDirectory(app, deps.workspaceFileRoutes);
     registerCopyEntry(app, deps.workspaceFileRoutes);
     registerMoveEntry(app, deps.workspaceFileRoutes);

package/dist/server/server/features/plans/application/parse-supervised-plan.js

@@ -54,6 +54,8 @@ export function parseSupervisedPlan(input) {
         if (!closed)
             return unavailable('MALFORMED_ORG');
         const descriptions = new Map();
+        let descriptionKey;
+        let blankLines = 0;
         while (index < lines.length && !lines[index].startsWith('*')) {
             const description = descriptionPattern.exec(lines[index]);
             if (description) {
@@ -61,6 +63,15 @@ export function parseSupervisedPlan(input) {
                 if (descriptions.has(key))
                     return unavailable('MALFORMED_ORG');
                 descriptions.set(key, description[2] ?? '');
+                descriptionKey = key;
+                blankLines = 0;
+            }
+            else if (descriptionKey && /^[ \t]+\S/.test(lines[index])) {
+                descriptions.set(descriptionKey, `${descriptions.get(descriptionKey)}${'\n'.repeat(blankLines + 1)}${lines[index].replace(/^(?:  |\t)/, '')}`);
+                blankLines = 0;
+            }
+            else if (lines[index].trim() === '') {
+                blankLines += 1;
             }
             else if (lines[index].trim() !== '') {
                 return unavailable('MALFORMED_ORG');

package/dist/server/server/features/plans/archive-workspace-plan/endpoint.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerArchiveWorkspacePlan(app, deps) {
+    app.post('/api/workspaces/:workspaceId/plans/:planName/archive', async (request, reply) => {
+        try {
+            const { workspaceId, planName } = request.params;
+            const workspace = await deps.workspaces.resolve(workspaceId);
+            const result = await deps.archiver.archive(workspace.realPath, planName);
+            if (result.kind === 'archived')
+                return reply.send({ archived: true });
+            if (result.kind === 'missing')
+                return reply.code(404).send({ code: 'PLAN_NOT_FOUND' });
+            if (result.kind === 'conflict')
+                return reply.code(409).send({ code: 'PLAN_ARCHIVE_CONFLICT' });
+            return reply.code(422).send({ code: 'PLAN_ARCHIVE_UNAVAILABLE' });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND')
+                return reply.code(404).send({ code: 'WORKSPACE_NOT_FOUND' });
+            return reply.code(503).send({ code: 'PLAN_ARCHIVE_UNAVAILABLE' });
+        }
+    });
+}

package/dist/server/server/features/plans/list-workspace-plans/endpoint.js

@@ -7,7 +7,7 @@ export function registerListWorkspacePlans(app, deps) {
     app.get('/api/workspaces/:workspaceId/plans', async (request, reply) => {
         try {
             const workspace = await deps.workspaces.resolve(request.params.workspaceId);
-            return reply.send(await deps.plans.list(workspace.realPath));
+            return reply.send(await deps.plans.list(workspace.realPath, true));
         }
         catch (error) {
             if (error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND')

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

@@ -9,6 +9,7 @@ import { registerGetPlan } from './get-plan/endpoint.js';
 import { registerGetWorkspacePlan } from './get-workspace-plan/endpoint.js';
 import { registerListWorkspacePlans } from './list-workspace-plans/endpoint.js';
 import { registerOpenPlan } from './open-plan/endpoint.js';
+import { registerArchiveWorkspacePlan } from './archive-workspace-plan/endpoint.js';
 export function registerPlanRoutes(app, deps) {
     if (deps.planRoutes) {
         registerGetPlan(app, deps.planRoutes);
@@ -18,6 +19,11 @@ export function registerPlanRoutes(app, deps) {
     if (deps.workspacePlanRoutes) {
         registerListWorkspacePlans(app, deps.workspacePlanRoutes);
         registerGetWorkspacePlan(app, deps.workspacePlanRoutes);
+        if (deps.workspacePlanRoutes.archiver)
+            registerArchiveWorkspacePlan(app, {
+                workspaces: deps.workspacePlanRoutes.workspaces,
+                archiver: deps.workspacePlanRoutes.archiver,
+            });
     }
     if (deps.planMeasurementRoutes)
         registerGetPlanMeasurement(app, deps.planMeasurementRoutes);

package/dist/server/server/features/sessions/model/relay-session.js

@@ -59,6 +59,7 @@ export class RelaySession {
             provider: input.provider,
             profile: profileName(input.profile),
             ...(input.model === undefined ? {} : { model: input.model }),
+            ...(input.modelSettings === undefined ? {} : { modelSettings: { ...input.modelSettings } }),
             ...(input.branch === undefined ? {} : { branch: input.branch }),
             effectiveSkillSelection: createEffectiveSkillSelection(input.effectiveSkillSelection),
             executionPolicy: createSessionExecutionPolicy(input),
@@ -173,6 +174,7 @@ export class RelaySession {
 function copy(snapshot) {
     return {
         ...snapshot,
+        ...(snapshot.modelSettings ? { modelSettings: { ...snapshot.modelSettings } } : {}),
         ...(snapshot.effectiveSkillSelection === undefined
             ? {}
             : {

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

@@ -30,6 +30,12 @@ export function registerStartSession(app, deps) {
         }
         catch (error) {
             deps.reportFailure?.('start-session', error);
+            if (error instanceof Error &&
+                ['ORG_EXECUTOR_PROFILE_UNAVAILABLE', 'ORG_EXECUTOR_PROFILE_INVALID'].includes(error.message))
+                return reply
+                    .code(503)
+                    .type('application/problem+json')
+                    .send(problem(error.message, 503, 'The installed Org-plan executor profile could not be configured. Restore the Gestalt agent profile and retry.'));
             if (error instanceof SkillProfileError)
                 return reply
                     .code(400)

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

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { z } from 'zod';
+import { thinkingLevels } from '../../../../shared/contracts/session-model-settings.js';
 const schema = z.object({
     workspaceId: z.string().min(1),
     provider: z.enum(['codex', 'kimi']),
@@ -14,6 +15,9 @@ const schema = z.object({
         .trim()
         .optional()
         .transform((value) => value || undefined),
+    reasoningEffort: z.enum(thinkingLevels).optional(),
+    executorModel: z.string().trim().min(1).max(256).optional(),
+    executorReasoningEffort: z.enum(thinkingLevels).optional(),
     sandbox: z
         .enum(['workspace-git', 'read-only', 'workspace-write', 'danger-full-access'])
         .optional(),

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

@@ -62,6 +62,18 @@ export async function startSession(input, deps) {
         provider: input.provider,
         profile: input.profile,
         model,
+        ...(input.provider === 'codex' &&
+            (input.reasoningEffort || input.executorModel || input.executorReasoningEffort)
+            ? {
+                modelSettings: {
+                    ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
+                    ...(input.executorModel ? { executorModel: input.executorModel } : {}),
+                    ...(input.executorReasoningEffort
+                        ? { executorReasoningEffort: input.executorReasoningEffort }
+                        : {}),
+                },
+            }
+            : {}),
         ...(branch ? { branch } : {}),
         sandbox: input.sandbox,
         approvalPolicy: input.approvalPolicy,

package/dist/server/server/platform/catalog/filesystem-workspace-catalog.js

@@ -15,6 +15,9 @@ export class FilesystemWorkspaceCatalog {
         return [(await this.tree()).option];
     }
     async resolve(id) {
+        const root = await this.root;
+        if (id === this.id(root))
+            return { id, name: '/', realPath: root };
         const found = this.find(await this.tree(), id);
         if (!found)
             throw new Error('WORKSPACE_NOT_FOUND');

package/dist/server/server/platform/codex/recent-thread-lister.js

@@ -47,7 +47,8 @@ async function listProfileThreads(launch, profile, cwd) {
             limit: 20,
             sortKey: 'recency_at',
             sortDirection: 'desc',
-            sourceKinds: ['cli', 'appServer'],
+            sourceKinds: ['cli', 'vscode', 'appServer'],
+            modelProviders: [],
         }));
         return (result.data ?? []).flatMap((thread) => {
             if (typeof thread.id !== 'string' || typeof thread.cwd !== 'string')

package/dist/server/server/platform/codex/session-model-config.js

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Finds root assignments without treating instruction strings or TOML tables as settings. */
+function replaceRootSetting(profile, key, value) {
+    const lines = profile.split('\n');
+    let stringDelimiter = null;
+    let rootEnd = lines.length;
+    const assignments = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!stringDelimiter) {
+            if (/^\s*\[/.test(line)) {
+                rootEnd = index;
+                break;
+            }
+            if (new RegExp(`^\\s*${key}\\s*=`).test(line))
+                assignments.push(index);
+        }
+        for (let offset = 0; offset < line.length; offset += 1) {
+            const character = line[offset];
+            if (stringDelimiter) {
+                if (stringDelimiter.startsWith('"') && character === '\\') {
+                    offset += 1;
+                }
+                else if (line.startsWith(stringDelimiter, offset)) {
+                    offset += stringDelimiter.length - 1;
+                    stringDelimiter = null;
+                }
+            }
+            else if (character === '#') {
+                break;
+            }
+            else if (character === '"' || character === "'") {
+                stringDelimiter = line.startsWith(character.repeat(3), offset)
+                    ? character.repeat(3)
+                    : character;
+                offset += stringDelimiter.length - 1;
+            }
+        }
+        if (stringDelimiter?.length === 1)
+            throw new Error('ORG_EXECUTOR_PROFILE_INVALID');
+    }
+    if (stringDelimiter || assignments.length > 1)
+        throw new Error('ORG_EXECUTOR_PROFILE_INVALID');
+    const assignment = `${key} = ${JSON.stringify(value)}`;
+    if (assignments.length)
+        lines[assignments[0]] = assignment;
+    else
+        lines.splice(rootEnd, 0, assignment);
+    return lines.join('\n');
+}
+/** Keeps installed Org role instructions while pinning settings only for the owning session. */
+export class SessionModelConfig {
+    codexHome;
+    stateDirectory;
+    constructor(codexHome, stateDirectory) {
+        this.codexHome = codexHome;
+        this.stateDirectory = stateDirectory;
+    }
+    async resolve(session) {
+        const settings = session.modelSettings;
+        if (!settings)
+            return {};
+        const config = settings.reasoningEffort
+            ? { model_reasoning_effort: settings.reasoningEffort }
+            : {};
+        if (!settings.executorModel && !settings.executorReasoningEffort)
+            return config;
+        let profile;
+        try {
+            profile = await readFile(join(this.codexHome, 'agents', 'org-plan-executor.toml'), 'utf8');
+        }
+        catch {
+            throw new Error('ORG_EXECUTOR_PROFILE_UNAVAILABLE');
+        }
+        for (const [key, value] of [
+            ['model', settings.executorModel],
+            ['model_reasoning_effort', settings.executorReasoningEffort],
+        ]) {
+            if (!value)
+                continue;
+            profile = replaceRootSetting(profile, key, value);
+        }
+        const directory = join(this.stateDirectory, 'agent-profiles');
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const name = createHash('sha256').update(session.id).digest('hex');
+        const path = join(directory, `${name}.toml`);
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, profile, { flag: 'wx', mode: 0o600 });
+            await rename(temporary, path);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        return { ...config, agents: { 'org-plan-executor': { config_file: path } } };
+    }
+}