gestalt-mobile 0.4.1 → 0.6.0

package/dist/server/server/composition.js

@@ -6,11 +6,12 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { buildApp } from './app.js';
 import { FilesystemWorkspaceCatalog } from './platform/catalog/filesystem-workspace-catalog.js';
 import { protocolCompatibility } from './platform/codex/protocol-compatibility.js';
 import { launchCodexAppServer } from './platform/codex/codex-process-launcher.js';
+import { CodexModelCatalog } from './platform/codex/codex-model-catalog.js';
 import { createRecentThreadLister } from './platform/codex/recent-thread-lister.js';
 import { CodexSessionRuntime } from './platform/codex/session-runtime.js';
 import { normalizeCodexNotification } from './platform/codex/normalizer.js';
@@ -33,7 +34,10 @@ import { isValidInteractionResponse } from './features/sessions/interaction/resp
 import { promoteRecentThread } from './features/sessions/promote-recent-thread/use-case.js';
 import { FilesystemSkillProfileStore } from './platform/skills/filesystem-skill-profile-store.js';
 import { CodexSkillCatalog } from './platform/skills/codex-skill-catalog.js';
+import { CachedSkillCatalog } from './platform/skills/cached-skill-catalog.js';
 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';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
 export async function composeRelayApp(options) {
     const root = resolve(options.root);
@@ -46,15 +50,25 @@ export async function composeRelayApp(options) {
     const journal = new SqliteEventJournal(database);
     const interactions = new SqlitePendingInteractionStore(database);
     const idempotency = new SqliteIdempotencyStore(database);
+    const supervisedPlans = new SupervisedPlanRegistry();
+    const planStatusSource = new FilesystemPlanStatusSource(join(dirname(databasePath), 'plans'));
     const withPendingInteractions = (session) => (session ? { ...session, pendingInteractions: interactions.list(session.id) } : null);
     const events = new SessionEventBus();
     const workspaces = new FilesystemWorkspaceCatalog(root);
+    const models = new CodexModelCatalog(root, options.launchAppServer ?? launchCodexAppServer);
     const skillProfiles = new FilesystemSkillProfileStore(options.homeDirectory ?? homedir());
-    const resolveSkills = async (profile, cwd) => {
-        const project = await skillProfiles.readWorkspaceDefault(cwd);
+    const skillCatalog = (profile) => new CodexSkillCatalog(profile, options.launchAppServer ?? launchCodexAppServer);
+    const editorSkillCatalog = new CachedSkillCatalog((profile, workspace) => skillCatalog(profile).list(workspace));
+    const resolveSkills = async (session) => {
+        const catalog = await skillCatalog(session.profile).list(session.workspacePath);
+        if (session.effectiveSkillSelection)
+            return compileSkillOverride({
+                discovered: catalog.skills,
+                explicit: session.effectiveSkillSelection.skills,
+            }).skillsConfig;
+        const project = await skillProfiles.readWorkspaceDefault(session.workspacePath);
         if (!options.explicitSkillProfile && !project)
             return undefined;
-        const catalog = await new CodexSkillCatalog(profile, options.launchAppServer ?? launchCodexAppServer).list(cwd);
         return compileSkillOverride({
             discovered: catalog.skills,
             explicit: options.explicitSkillProfile?.skills,
@@ -93,7 +107,13 @@ export async function composeRelayApp(options) {
             sessions.save(updated);
             events.publish(journal.append(sessionId, 'interaction.requested', interaction, updated.updatedAt));
             return true;
-        }, (sessionId) => recoverExitedSession(sessionId), resolveSkills)
+        }, (sessionId) => recoverExitedSession(sessionId), resolveSkills, planStatusSource, (sessionId, update) => {
+            supervisedPlans.accept(sessionId, update);
+            if (update.kind === 'updated') {
+                const occurredAt = new Date().toISOString();
+                events.publish(journal.append(sessionId, 'plan.updated', update.plan, occurredAt));
+            }
+        })
         : null;
     const saveSession = (session) => {
         sessions.save(session);
@@ -131,11 +151,12 @@ export async function composeRelayApp(options) {
         skills: {
             workspaces,
             profiles: options.profiles,
-            catalog: (profile) => new CodexSkillCatalog(profile, options.launchAppServer ?? launchCodexAppServer),
+            catalog: editorSkillCatalog,
             selections: skillProfiles,
             listGlobalProfileNames: () => skillProfiles.listGlobalProfileNames(),
             readGlobalProfile: (name) => skillProfiles.readGlobalProfile(name),
             replaceGlobalProfile: (profile) => skillProfiles.replaceGlobalProfile(profile),
+            deleteGlobalProfile: (name) => skillProfiles.deleteGlobalProfile(name),
             profilePath: (name) => skillProfiles.globalProfilePath(name),
         },
         logger: console,
@@ -144,6 +165,7 @@ export async function composeRelayApp(options) {
         bootstrap: {
             workspaces,
             profiles: options.profiles,
+            models,
             sessions: {
                 list: () => sessions.list().map((session) => withPendingInteractions(session)),
             },
@@ -157,12 +179,16 @@ export async function composeRelayApp(options) {
             list: () => sessions.list().map((session) => withPendingInteractions(session)),
             workspaces,
             profiles: options.profiles,
+            skillProfiles,
+            skillCatalog,
+            defaultSkillProfile: options.explicitSkillProfile,
             activate: runtime
                 ? async (session, settings) => runtime.start(session, new Date().toISOString(), settings)
                 : undefined,
             startTurn: runtime
                 ? async (session, text) => runtime.startTurn(session, text, new Date().toISOString())
                 : undefined,
+            models,
             readHistory: runtime ? (session) => runtime.readHistory(session) : undefined,
             currentSequence: (sessionId) => journal.since(sessionId, 0).at(-1)?.sequence ?? 0,
             interruptTurn: runtime
@@ -196,6 +222,16 @@ export async function composeRelayApp(options) {
             since: (id, after) => journal.since(id, after),
             subscribe: (id, listener) => events.subscribe(id, listener),
         },
+        planRoutes: {
+            exists: (id) => sessions.find(id) !== null,
+            find: (id) => supervisedPlans.find(id),
+            removeStatus: (id) => planStatusSource.remove(id, supervisedPlans.identity(id) ?? undefined),
+            clear: (id) => supervisedPlans.clear(id),
+            closed: (id) => {
+                const occurredAt = new Date().toISOString();
+                events.publish(journal.append(id, 'plan.closed', {}, occurredAt));
+            },
+        },
         interactions: {
             resolve: (sessionId, requestId, resolvedAt) => interactions.resolve(sessionId, requestId, resolvedAt),
             validate: (sessionId, requestId, value) => {
@@ -247,10 +283,15 @@ export async function composeRelayApp(options) {
             }
         });
     };
-    if (runtime)
-        app.addHook('onListen', () => void restoreActiveSessions());
+    app.addHook('onListen', async () => {
+        const profile = (await options.profiles.list()).find((item) => item.state === 'ok')?.name;
+        if (profile)
+            await editorSkillCatalog.refresh(profile, root);
+        await restoreActiveSessions();
+    });
     app.addHook('onClose', async () => {
         runtime?.stopAll();
+        planStatusSource.closeAll();
         database.close();
     });
     return app;

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

@@ -4,10 +4,15 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 export async function getBootstrap(deps) {
-    const [workspaces, profiles] = await Promise.all([deps.workspaces.list(), deps.profiles.list()]);
+    const [workspaces, profiles, models] = await Promise.all([
+        deps.workspaces.list(),
+        deps.profiles.list(),
+        deps.models?.list().catch(() => []) ?? [],
+    ]);
     return {
         workspaces,
         profiles,
+        models,
         sessions: deps.sessions.list(),
         capabilities: {
             approvals: true,

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

@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { isAbsolute, relative, resolve } from 'node:path';
+const headingPattern = /^(\*{1,2}) (TODO|WIP|DONE) \[#([ABC])\] (.+)$/;
+const propertyPattern = /^:([A-Z_]+):(?:[ \t](.*))?$/;
+const descriptionPattern = /^- ([A-Za-z][A-Za-z ]*?) ::(?:[ \t](.*))?$/;
+/**
+ * Projects only the small, validated org-plan dialect used by supervised plans.
+ * `planPath` is used solely for admission control and never retained in the model.
+ */
+export function parseSupervisedPlan(input) {
+    if (!isPlanPathWithinWorkspace(input.planPath, input.workspacePath))
+        return unavailable('PATH_OUTSIDE_WORKSPACE');
+    const lines = input.source.replace(/\r\n?/g, '\n').split('\n');
+    const metadata = new Map();
+    const headings = [];
+    for (let index = 0; index < lines.length;) {
+        const line = lines[index];
+        const metadataMatch = /^#\+([A-Z]+):(?:[ \t](.*))?$/.exec(line);
+        if (metadataMatch) {
+            metadata.set(metadataMatch[1], metadataMatch[2] ?? '');
+            index += 1;
+            continue;
+        }
+        if (!line.startsWith('*')) {
+            index += 1;
+            continue;
+        }
+        const headingMatch = headingPattern.exec(line);
+        if (!headingMatch)
+            return unavailable('MALFORMED_ORG');
+        const level = headingMatch[1].length;
+        const propertiesStart = lines[index + 1];
+        if (propertiesStart !== ':PROPERTIES:')
+            return unavailable('MALFORMED_ORG');
+        const properties = new Map();
+        index += 2;
+        let closed = false;
+        for (; index < lines.length; index += 1) {
+            const propertyLine = lines[index];
+            if (propertyLine === ':END:') {
+                closed = true;
+                index += 1;
+                break;
+            }
+            const property = propertyPattern.exec(propertyLine);
+            if (!property || properties.has(property[1]))
+                return unavailable('MALFORMED_ORG');
+            properties.set(property[1], property[2] ?? '');
+        }
+        if (!closed)
+            return unavailable('MALFORMED_ORG');
+        const descriptions = new Map();
+        while (index < lines.length && !lines[index].startsWith('*')) {
+            const description = descriptionPattern.exec(lines[index]);
+            if (description) {
+                const key = description[1];
+                if (descriptions.has(key))
+                    return unavailable('MALFORMED_ORG');
+                descriptions.set(key, description[2] ?? '');
+            }
+            else if (lines[index].trim() !== '') {
+                return unavailable('MALFORMED_ORG');
+            }
+            index += 1;
+        }
+        const id = properties.get('ID');
+        if (!id)
+            return unavailable('MISSING_REQUIRED_FIELD');
+        headings.push({
+            id,
+            title: headingMatch[4],
+            level,
+            state: headingMatch[2],
+            priority: headingMatch[3],
+            properties,
+            descriptions,
+        });
+    }
+    const title = metadata.get('TITLE');
+    if (!title)
+        return unavailable('MISSING_TITLE');
+    if (!headings.length)
+        return unavailable('MALFORMED_ORG');
+    if (new Set(headings.map((heading) => heading.id)).size !== headings.length)
+        return unavailable('DUPLICATE_ID');
+    if (!hasValidWipPath(headings))
+        return unavailable('MULTIPLE_WIP');
+    const built = buildSteps(headings);
+    if (!built)
+        return unavailable('MISSING_REQUIRED_FIELD');
+    const allSteps = headings;
+    const allDone = allSteps.every((step) => step.state === 'DONE');
+    const currentStepId = findCurrentStepId(allSteps, allDone);
+    if (!currentStepId)
+        return unavailable('MALFORMED_ORG');
+    return {
+        kind: 'available',
+        plan: freezePlan({
+            title,
+            ...(metadata.has('SUBTITLE') ? { subtitle: metadata.get('SUBTITLE') } : {}),
+            ...(metadata.has('DATE') ? { date: metadata.get('DATE') } : {}),
+            ...(metadata.has('KEYWORDS') ? { keywords: metadata.get('KEYWORDS') } : {}),
+            steps: built,
+            totalSteps: allSteps.length,
+            doneSteps: allSteps.filter((step) => step.state === 'DONE').length,
+            allDone,
+            currentStepId,
+        }),
+    };
+}
+export function isPlanPathWithinWorkspace(planPath, workspacePath) {
+    if (!isAbsolute(planPath) || !isAbsolute(workspacePath))
+        return false;
+    const pathWithinWorkspace = relative(resolve(workspacePath), resolve(planPath));
+    return (pathWithinWorkspace === '' ||
+        (!pathWithinWorkspace.startsWith('..') && !isAbsolute(pathWithinWorkspace)));
+}
+function buildSteps(headings) {
+    const parents = [];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        if (heading.level === 1) {
+            const step = makeStep(heading);
+            if (!step)
+                return null;
+            parents.push(step);
+            continue;
+        }
+        const parent = parents.at(-1);
+        if (!parent)
+            return null;
+        const child = makeStep(heading);
+        if (!child)
+            return null;
+        parent.children.push(child);
+    }
+    return parents;
+}
+function makeStep(heading) {
+    const description = descriptionFor(heading);
+    if (!description)
+        return null;
+    if (heading.level === 1) {
+        const reviewStatus = heading.properties.get('REVIEW_STATUS');
+        const skills = heading.properties.get('SKILLS');
+        if ((reviewStatus !== 'UNREVIEWED' && reviewStatus !== 'REVIEWED') || skills === undefined)
+            return null;
+        return {
+            id: heading.id,
+            title: heading.title,
+            level: heading.level,
+            state: heading.state,
+            priority: heading.priority,
+            reviewStatus: reviewStatus,
+            skills: skills.split(/\s+/).filter(Boolean),
+            description,
+            children: [],
+        };
+    }
+    if (heading.properties.has('REVIEW_STATUS') || heading.properties.has('SKILLS'))
+        return null;
+    return {
+        id: heading.id,
+        title: heading.title,
+        level: heading.level,
+        state: heading.state,
+        priority: heading.priority,
+        description,
+        children: [],
+    };
+}
+function descriptionFor(heading) {
+    const fields = heading.level === 1 ? ['Effort', 'Goal', 'Notes'] : ['Why', 'Change', 'Tests', 'Done when'];
+    if (!fields.every((field) => heading.descriptions.has(field)))
+        return null;
+    const description = heading.descriptions;
+    return heading.level === 1
+        ? {
+            effort: description.get('Effort'),
+            goal: description.get('Goal'),
+            notes: description.get('Notes'),
+        }
+        : {
+            why: description.get('Why'),
+            change: description.get('Change'),
+            tests: description.get('Tests'),
+            doneWhen: description.get('Done when'),
+        };
+}
+function hasValidWipPath(headings) {
+    const wipByLevel = new Map();
+    for (const heading of headings) {
+        if (heading.state !== 'WIP')
+            continue;
+        const sameLevel = wipByLevel.get(heading.level) ?? [];
+        sameLevel.push(heading);
+        wipByLevel.set(heading.level, sameLevel);
+    }
+    if ([...wipByLevel.values()].some((steps) => steps.length > 1))
+        return false;
+    const l2Wip = wipByLevel.get(2)?.[0];
+    if (!l2Wip)
+        return true;
+    const parentIndex = headings.indexOf(l2Wip) - 1;
+    for (let index = parentIndex; index >= 0; index -= 1) {
+        if (headings[index].level === 1)
+            return headings[index].state === 'WIP';
+    }
+    return false;
+}
+function findCurrentStepId(headings, allDone) {
+    const wip = headings
+        .filter((heading) => heading.state === 'WIP')
+        .sort((a, b) => b.level - a.level)[0];
+    if (wip)
+        return wip.id;
+    const review = headings.find((heading) => heading.level === 1 &&
+        heading.state === 'DONE' &&
+        heading.properties.get('REVIEW_STATUS') === 'UNREVIEWED');
+    if (review)
+        return review.id;
+    const todo = headings.find((heading) => heading.state === 'TODO');
+    if (todo)
+        return todo.id;
+    return allDone ? (headings.findLast((heading) => heading.level === 1)?.id ?? null) : null;
+}
+function freezePlan(plan) {
+    const freezeStep = (step) => Object.freeze({
+        ...step,
+        ...(step.skills ? { skills: Object.freeze([...step.skills]) } : {}),
+        description: Object.freeze({ ...step.description }),
+        children: Object.freeze(step.children.map(freezeStep)),
+    });
+    return Object.freeze({ ...plan, steps: Object.freeze(plan.steps.map(freezeStep)) });
+}
+function unavailable(reason) {
+    return { kind: 'unavailable', reason };
+}

package/dist/server/server/features/plans/application/ports.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Retains at most one validated plan projection for each relay session. */
+export class SupervisedPlanRegistry {
+    plans = new Map();
+    accept(sessionId, update) {
+        if (update.kind === 'updated')
+            this.plans.set(sessionId, { plan: update.plan, identity: update.identity });
+    }
+    find(sessionId) {
+        return this.plans.get(sessionId)?.plan ?? null;
+    }
+    identity(sessionId) {
+        return this.plans.get(sessionId)?.identity ?? null;
+    }
+    clear(sessionId) {
+        this.plans.delete(sessionId);
+    }
+}

package/dist/server/server/features/plans/close-plan/endpoint.js

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { problem } from '../../../platform/http/problem.js';
+export function registerClosePlan(app, deps) {
+    app.delete('/api/sessions/:id/plan', async (request, reply) => {
+        const id = request.params.id;
+        if (!deps.exists(id))
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const plan = deps.find(id);
+        if (!plan)
+            return reply.code(204).send();
+        if (!plan.allDone)
+            return reply
+                .code(409)
+                .type('application/problem+json')
+                .send(problem('PLAN_INCOMPLETE', 409, 'Only completed supervised plans can be closed.'));
+        try {
+            await deps.removeStatus(id);
+        }
+        catch {
+            return reply
+                .code(503)
+                .type('application/problem+json')
+                .send(problem('PLAN_CLOSE_UNAVAILABLE', 503, 'The relay could not close the supervised plan.', true));
+        }
+        deps.clear(id);
+        deps.closed(id);
+        return reply.code(204).send();
+    });
+}

package/dist/server/server/features/plans/domain/supervised-plan.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};

package/dist/server/server/features/plans/get-plan/endpoint.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerGetPlan(app, deps) {
+    app.get('/api/sessions/:id/plan', (request, reply) => {
+        const id = request.params.id;
+        if (!deps.exists(id))
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const plan = deps.find(id);
+        return plan ? reply.send(plan) : reply.code(204).send();
+    });
+}

package/dist/server/server/features/sessions/application/start-settings.js

@@ -3,4 +3,5 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-export {};
+/** The relay's configured default, kept explicit so deployments can change it centrally later. */
+export const DEFAULT_SESSION_MODEL = 'gpt-5.6-terra';

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

@@ -4,7 +4,16 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { DomainError } from './errors.js';
+import { createSkillSelection, normalizeSkillProfileName, } from '../../skills/model/skill-profile.js';
 import { interactionId, profileName, sessionId, threadId, turnId, workspaceId, workspacePath, } from './value-objects.js';
+export function createEffectiveSkillSelection(input) {
+    return {
+        ...(input.selectedProfileName === undefined
+            ? {}
+            : { selectedProfileName: normalizeSkillProfileName(input.selectedProfileName) }),
+        skills: createSkillSelection(input.skills),
+    };
+}
 export class RelaySession {
     value;
     events;
@@ -18,6 +27,9 @@ export class RelaySession {
             workspaceId: workspaceId(input.workspaceId),
             workspacePath: workspacePath(input.workspacePath),
             profile: profileName(input.profile),
+            ...(input.model === undefined ? {} : { model: input.model }),
+            ...(input.branch === undefined ? {} : { branch: input.branch }),
+            effectiveSkillSelection: createEffectiveSkillSelection(input.effectiveSkillSelection),
             threadId: null,
             state: 'starting',
             desiredState: 'active',
@@ -55,6 +67,11 @@ export class RelaySession {
     bindThread(value, now) {
         return this.transition({ threadId: threadId(value), state: 'ready' }, 'ThreadBound', now);
     }
+    selectModel(value, now) {
+        if (this.value.state !== 'ready')
+            throw new DomainError('SESSION_NOT_READY');
+        return this.transition({ model: value }, 'ModelSelected', now);
+    }
     startTurn(value, now) {
         if (this.value.state === 'turnActive')
             throw new DomainError('SESSION_TURN_ACTIVE');
@@ -117,6 +134,9 @@ export class RelaySession {
 function copy(snapshot) {
     return {
         ...snapshot,
+        ...(snapshot.effectiveSkillSelection === undefined
+            ? {}
+            : { effectiveSkillSelection: createEffectiveSkillSelection(snapshot.effectiveSkillSelection) }),
         pendingInteractions: snapshot.pendingInteractions.map((item) => ({ ...item })),
     };
 }

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

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { RelaySession } from '../model/relay-session.js';
+export function registerSelectModel(app, deps) {
+    app.post('/api/sessions/:id/model', async (request, reply) => {
+        const session = deps.find(request.params.id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const model = request.body.model;
+        if (typeof model !== 'string')
+            return reply.code(400).send({ code: 'MODEL_REQUIRED' });
+        if (!(await deps.models()).includes(model))
+            return reply.code(400).send({ code: 'MODEL_UNAVAILABLE' });
+        if (session.state !== 'ready')
+            return reply.code(409).send({ code: 'SESSION_NOT_READY' });
+        const selected = RelaySession.rehydrate(session).selectModel(model, deps.now()).snapshot;
+        deps.save(selected);
+        return reply.send(selected);
+    });
+}

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

@@ -6,6 +6,8 @@
 import { idempotencyKey } from '../../../platform/http/idempotency.js';
 import { parseStartSessionRequest } from './request.js';
 import { startSession } from './use-case.js';
+import { SkillProfileError } from '../../skills/model/errors.js';
+import { problem } from '../../../platform/http/problem.js';
 export function registerStartSession(app, deps) {
     app.post('/api/sessions', async (request, reply) => {
         const key = idempotencyKey(request.headers);
@@ -28,6 +30,10 @@ export function registerStartSession(app, deps) {
         }
         catch (error) {
             deps.reportFailure?.('start-session', error);
+            if (error instanceof SkillProfileError)
+                return reply.code(400).type('application/problem+json').send(problem(error.code, 400, error.code === 'UNKNOWN_SKILL_PROFILE'
+                    ? 'The selected skill profile does not exist.'
+                    : 'The selected skill profile is invalid.'));
             throw error;
         }
         if (key)

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

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

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

@@ -4,23 +4,54 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { RelaySession } from '../model/relay-session.js';
+import { DEFAULT_SESSION_MODEL, } from '../application/start-settings.js';
+import { applySkillSelectionSnapshot, } 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;
     const [workspace] = await Promise.all([
         deps.workspaces.resolve(input.workspaceId),
         deps.profiles.require(input.profile),
     ]);
+    if (deps.models) {
+        const models = await deps.models.list();
+        if (!models.includes(model))
+            throw new Error('CODEX_MODEL_UNAVAILABLE');
+    }
+    const selectedProfile = input.skillProfile
+        ? await deps.skillProfiles.readGlobalProfile(input.skillProfile)
+        : deps.defaultSkillProfile;
+    if (input.skillProfile && !selectedProfile)
+        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),
+    ]);
+    const sourceProfile = selectedProfile ?? projectProfile;
+    const effectiveSkillSelection = {
+        ...(selectedProfile ? { selectedProfileName: selectedProfile.name } : {}),
+        skills: applySkillSelectionSnapshot(catalog.skills, sourceProfile?.skills).map((skill) => ({
+            name: skill.name,
+            path: skill.path,
+            enabled: skill.enabled,
+        })),
+    };
+    const branch = await deps.gitBranch?.(workspace.realPath);
     const session = RelaySession.create({
         id: deps.createId(),
         workspaceId: workspace.id,
         workspacePath: workspace.realPath,
         profile: input.profile,
+        model,
+        ...(branch ? { branch } : {}),
+        effectiveSkillSelection,
         now: deps.now(),
     }).snapshot;
     deps.save(session);
     if (!deps.activate)
         return session;
     const active = await deps.activate(session, {
-        model: input.model,
+        model,
         sandbox: input.sandbox,
         approvalPolicy: input.approvalPolicy,
     });