gestalt-mobile 0.13.0 → 0.15.0

package/dist/client/icons/gestalt-mobile-maskable.svg

@@ -0,0 +1,10 @@
+<!--
+Copyright (C) 2026 Dyne.org foundation
+Designed by Denis Roio <jaromil@dyne.org>
+SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+
+<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" viewBox="0 0 512 512">
+  <rect width="512" height="512" fill="#141414" />
+  <image href="../branding/p_glogo_white.svg" x="102" y="102" width="308" height="308" />
+</svg>

package/dist/client/icons/gestalt-mobile.svg

@@ -0,0 +1,10 @@
+<!--
+Copyright (C) 2026 Dyne.org foundation
+Designed by Denis Roio <jaromil@dyne.org>
+SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+
+<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" viewBox="0 0 512 512">
+  <rect width="512" height="512" fill="#141414" />
+  <image href="../branding/p_glogo_white.svg" x="64" y="64" width="384" height="384" />
+</svg>

package/dist/client/index.html

@@ -9,9 +9,15 @@ SPDX-License-Identifier: AGPL-3.0-or-later
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Codex Relay</title>
-    <script type="module" crossorigin src="/assets/index-D2sT9ZHY.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CMs5ZzxJ.css">
+    <meta name="color-scheme" content="light dark" />
+    <meta name="theme-color" content="#141414" />
+    <meta name="application-name" content="Gestalt Mobile" />
+    <link rel="manifest" href="/manifest.webmanifest" />
+    <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-Dnm_kS5p.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-2L2KZzwK.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/client/manifest.webmanifest

@@ -0,0 +1,32 @@
+{
+  "id": "/",
+  "name": "Gestalt Mobile",
+  "short_name": "Gestalt",
+  "description": "A mobile interface for durable Codex development sessions.",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "background_color": "#141414",
+  "theme_color": "#141414",
+  "categories": ["productivity", "utilities"],
+  "icons": [
+    {
+      "src": "/icons/gestalt-mobile-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/icons/gestalt-mobile-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/icons/gestalt-mobile-maskable-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "maskable"
+    }
+  ]
+}

package/dist/client/service-worker.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+// Installability only: authenticated relay data must always remain network-fresh.
+self.addEventListener('install', () => self.skipWaiting());
+self.addEventListener('activate', (event) => event.waitUntil(self.clients.claim()));

package/dist/server/server/cli.js

@@ -99,7 +99,9 @@ async function listSkillProfiles(store, stdout, stderr) {
             if (!profile)
                 continue;
             stdout.write(`${profile.name}\n  ${store.globalProfilePath(name)}\n`);
-            for (const skill of [...profile.skills].filter((entry) => entry.enabled).sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path)))
+            for (const skill of [...profile.skills]
+                .filter((entry) => entry.enabled)
+                .sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path)))
                 stdout.write(`  ${skill.name}\t${skill.path}\n`);
         }
         catch (error) {

package/dist/server/server/composition.js

@@ -44,7 +44,7 @@ import { FilesystemPlanStatusSource } from './platform/plans/filesystem-plan-sta
 import { FilesystemWorkspacePlanCatalog } from './platform/plans/filesystem-workspace-plan-catalog.js';
 import { checkpointPlanMeasurement } from './platform/plans/plan-measurement-command.js';
 import { PlanMeasurementRefresh } from './platform/plans/plan-measurement-refresh.js';
-import { createRelyingPartyConfig, } from './config.js';
+import { createRelyingPartyConfig } from './config.js';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
 export async function composeRelayApp(options) {
     const passkeyAuthEnabled = options.passkeyAuthEnabled ?? true;
@@ -194,29 +194,33 @@ export async function composeRelayApp(options) {
     let app;
     try {
         app = await buildApp({
-            ...(authorization ? { auth: {
-                    repository: authorization,
-                    clock: { now: options.authorizationClock ?? (() => new Date()) },
-                    random: {
-                        bytes: (length) => {
-                            const value = authorizationRandom(length);
-                            if (length !== 32 || value.length !== 32)
-                                throw new Error('Authorization randomness must return exactly 32 bytes');
-                            return value;
+            ...(authorization
+                ? {
+                    auth: {
+                        repository: authorization,
+                        clock: { now: options.authorizationClock ?? (() => new Date()) },
+                        random: {
+                            bytes: (length) => {
+                                const value = authorizationRandom(length);
+                                if (length !== 32 || value.length !== 32)
+                                    throw new Error('Authorization randomness must return exactly 32 bytes');
+                                return value;
+                            },
                         },
-                    },
-                    identifiers: {
-                        sessionId: () => {
-                            const value = authorizationRandom(32);
-                            if (value.length !== 32)
-                                throw new Error('Authorization randomness must return exactly 32 bytes');
-                            return authorizationSessionId(Buffer.from(value).toString('base64url'));
+                        identifiers: {
+                            sessionId: () => {
+                                const value = authorizationRandom(32);
+                                if (value.length !== 32)
+                                    throw new Error('Authorization randomness must return exactly 32 bytes');
+                                return authorizationSessionId(Buffer.from(value).toString('base64url'));
+                            },
+                            deviceId: () => authorizedDeviceId(randomUUID()),
                         },
-                        deviceId: () => authorizedDeviceId(randomUUID()),
+                        webauthn: options.authorizationWebauthn ?? new SimpleWebAuthnAdapter(),
+                        relyingParty,
                     },
-                    webauthn: options.authorizationWebauthn ?? new SimpleWebAuthnAdapter(),
-                    relyingParty,
-                } } : { passkeyAuthDisabled: true }),
+                }
+                : { passkeyAuthDisabled: true }),
             health: {
                 async read() {
                     return {

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

@@ -3,6 +3,12 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-/** Expected proof failure; adapters must translate library-specific failures to this type. */
+/** Expected proof failure; adapters translate library details to a safe diagnostic category. */
 export class PasskeyVerificationError extends Error {
+    reason;
+    constructor(reason = 'VERIFIER_REJECTED') {
+        super('PASSKEY_VERIFICATION_FAILED');
+        this.reason = reason;
+        this.name = 'PasskeyVerificationError';
+    }
 }

package/dist/server/server/features/auth/devices/revoke/endpoint.js

@@ -28,7 +28,9 @@ export function registerRevokeAuthorizedDevice(app, deps) {
                 return unavailable(reply, 404, 'DEVICE_NOT_AVAILABLE');
             if (current === id)
                 reply.clearCookie('gestalt_mobile_session', {
-                    path: '/', httpOnly: true, sameSite: 'strict',
+                    path: '/',
+                    httpOnly: true,
+                    sameSite: 'strict',
                     secure: deps.relyingParty.publicOrigin.startsWith('https://'),
                 });
             return reply.code(204).send();

package/dist/server/server/features/auth/enrollment-tickets/endpoint.js

@@ -4,7 +4,8 @@ export function registerCreateEnrollmentTicket(app, deps) {
     app.post('/api/auth/enrollment-tickets', async (request, reply) => {
         const rawSession = request.cookies.gestalt_mobile_session;
         const session = parseAuthorizationSessionId(rawSession);
-        if (session === null || deps.repository.sessionDevice(session, deps.clock.now().toISOString()) === null)
+        if (session === null ||
+            deps.repository.sessionDevice(session, deps.clock.now().toISOString()) === null)
             return reply.code(401).send();
         const entropy = deps.random.bytes(32);
         if (entropy.length < 32)
@@ -12,6 +13,10 @@ export function registerCreateEnrollmentTicket(app, deps) {
         const ticket = enrollmentTicketId(Buffer.from(entropy).toString('base64url'));
         const expiresAt = new Date(deps.clock.now().getTime() + lifetimeMs).toISOString();
         deps.repository.issueEnrollmentTicket(ticket, session, expiresAt);
-        return reply.code(201).send({ ticket, url: `${deps.relyingParty.publicOrigin.replace(/\/$/, '')}/#enroll=${ticket}`, expiresAt });
+        return reply.code(201).send({
+            ticket,
+            url: `${deps.relyingParty.publicOrigin.replace(/\/$/, '')}/#enroll=${ticket}`,
+            expiresAt,
+        });
     });
 }

package/dist/server/server/features/auth/enrollment-tickets/status/endpoint.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { parseAuthorizationSessionId } from '../../domain/identifiers.js';
-const responseSchema = z.object({ status: z.enum(['none', 'pending', 'used', 'expired']) }).strict();
+const responseSchema = z
+    .object({ status: z.enum(['none', 'pending', 'used', 'expired']) })
+    .strict();
 export function registerEnrollmentTicketStatus(app, deps) {
     app.get('/api/auth/enrollment-tickets/current', async (request, reply) => {
         const rawSession = request.cookies.gestalt_mobile_session;

package/dist/server/server/features/auth/http/cookies.js

@@ -1,6 +1,16 @@
-const seconds = { gestalt_mobile_login: 600, gestalt_mobile_registration: 600, gestalt_mobile_session: 30 * 24 * 60 * 60 };
+const seconds = {
+    gestalt_mobile_login: 600,
+    gestalt_mobile_registration: 600,
+    gestalt_mobile_session: 30 * 24 * 60 * 60,
+};
 function options(name, origin) {
-    return { httpOnly: true, sameSite: 'strict', path: '/', secure: origin.startsWith('https://'), maxAge: seconds[name] };
+    return {
+        httpOnly: true,
+        sameSite: 'strict',
+        path: '/',
+        secure: origin.startsWith('https://'),
+        maxAge: seconds[name],
+    };
 }
 export function setAuthCookie(reply, name, value, origin) {
     reply.setCookie(name, value, options(name, origin));

package/dist/server/server/features/auth/login/verify/endpoint.js

@@ -50,7 +50,7 @@ export function registerLoginVerification(app, deps) {
                 },
             });
             if (!verified.userVerified || verified.credentialId !== device.credentialId)
-                throw new PasskeyVerificationError('PASSKEY_VERIFICATION_FAILED');
+                throw new PasskeyVerificationError('USER_VERIFICATION_REQUIRED');
             const session = deps.identifiers.sessionId();
             if (Buffer.from(session, 'base64url').length !== 32)
                 throw new Error('AUTHORIZATION_RANDOMNESS_INVALID');

package/dist/server/server/features/auth/register/verify/endpoint.js

@@ -1,56 +1,126 @@
 import { z } from 'zod';
 import { problem } from '../../../../platform/http/problem.js';
-import { PasskeyVerificationError } from '../../application/ports.js';
+import { PasskeyVerificationError, } from '../../application/ports.js';
 import { deviceNickname } from '../../domain/device-nickname.js';
 import { passkeyCeremonyId } from '../../domain/identifiers.js';
 import { AuthorizationDomainError } from '../../domain/errors.js';
 import { clearAuthCookie, setAuthCookie } from '../../http/cookies.js';
-const registrationResponseSchema = z.object({
-    id: z.string().min(1), rawId: z.string().min(1), type: z.literal('public-key'),
-    response: z.object({ clientDataJSON: z.string().min(1), attestationObject: z.string().min(1), authenticatorData: z.string().min(1).optional(), transports: z.array(z.enum(['ble', 'hybrid', 'internal', 'nfc', 'usb', 'cable', 'smart-card'])).optional(), publicKeyAlgorithm: z.number().int().optional(), publicKey: z.string().min(1).optional() }).strict(),
-    authenticatorAttachment: z.enum(['platform', 'cross-platform']).optional(), clientExtensionResults: z.record(z.string(), z.unknown()),
-}).strict();
-const requestSchema = z.object({ response: registrationResponseSchema, nickname: z.string() }).strict();
+const registrationResponseSchema = z
+    .object({
+    id: z.string().min(1),
+    rawId: z.string().min(1),
+    type: z.literal('public-key'),
+    response: z
+        .object({
+        clientDataJSON: z.string().min(1),
+        attestationObject: z.string().min(1),
+        authenticatorData: z.string().min(1).optional(),
+        transports: z
+            .array(z.enum(['ble', 'hybrid', 'internal', 'nfc', 'usb', 'cable', 'smart-card']))
+            .optional(),
+        publicKeyAlgorithm: z.number().int().optional(),
+        publicKey: z.string().min(1).optional(),
+    })
+        .strict(),
+    authenticatorAttachment: z.enum(['platform', 'cross-platform']).optional(),
+    clientExtensionResults: z.record(z.string(), z.unknown()),
+})
+    .strict();
+const requestSchema = z
+    .object({ response: registrationResponseSchema, nickname: z.string() })
+    .strict();
 const successSchema = z.object({ status: z.literal('authenticated') }).strict();
 const sessionLifetimeMs = 30 * 24 * 60 * 60 * 1000;
 export function registerRegistrationVerification(app, deps) {
     app.post('/api/auth/register/verify', { bodyLimit: 128 * 1024 }, async (request, reply) => {
         const parsed = requestSchema.safeParse(request.body);
         const token = request.cookies.gestalt_mobile_registration;
-        if (!parsed.success || typeof token !== 'string')
-            return reply.code(400).type('application/problem+json').send(problem('INVALID_REGISTRATION_REQUEST', 400, 'The registration request is invalid.'));
+        if (!parsed.success) {
+            deps.reportVerificationFailure?.('INVALID_RESPONSE_SHAPE');
+            return reply
+                .code(400)
+                .type('application/problem+json')
+                .send(problem('INVALID_REGISTRATION_REQUEST', 400, 'The registration request is invalid.'));
+        }
+        if (typeof token !== 'string') {
+            deps.reportVerificationFailure?.('MISSING_CEREMONY_COOKIE');
+            return reply
+                .code(400)
+                .type('application/problem+json')
+                .send(problem('REGISTRATION_COOKIE_MISSING', 400, 'The registration cookie is missing.'));
+        }
         let nickname;
         try {
             nickname = deviceNickname(parsed.data.nickname);
         }
         catch (error) {
             if (error instanceof AuthorizationDomainError)
-                return reply.code(400).type('application/problem+json').send(problem('INVALID_DEVICE_NICKNAME', 400, 'The device nickname is invalid.'));
+                return reply
+                    .code(400)
+                    .type('application/problem+json')
+                    .send(problem('INVALID_DEVICE_NICKNAME', 400, 'The device nickname is invalid.'));
             throw error;
         }
         const now = deps.clock.now();
         const ceremony = deps.repository.readCeremony(passkeyCeremonyId(token), now.toISOString());
-        if (!ceremony || ceremony.purpose !== 'registration')
-            return reply.code(400).type('application/problem+json').send(problem('REGISTRATION_NOT_AVAILABLE', 400, 'Registration could not be completed.'));
+        if (!ceremony || ceremony.purpose !== 'registration') {
+            deps.reportVerificationFailure?.('CEREMONY_NOT_AVAILABLE');
+            return reply
+                .code(400)
+                .type('application/problem+json')
+                .send(problem('REGISTRATION_NOT_AVAILABLE', 400, 'Registration could not be completed.'));
+        }
         try {
-            const verified = await deps.webauthn.verifyRegistration({ response: parsed.data.response, challenge: ceremony.challenge, expectedOrigin: ceremony.expectedOrigin, rpId: ceremony.rpId });
+            const verified = await deps.webauthn.verifyRegistration({
+                response: parsed.data.response,
+                challenge: ceremony.challenge,
+                expectedOrigin: ceremony.expectedOrigin,
+                rpId: ceremony.rpId,
+            });
             if (!verified.userVerified)
-                throw new PasskeyVerificationError('PASSKEY_VERIFICATION_FAILED');
-            const device = { id: deps.identifiers.deviceId(), credentialId: verified.credentialId, publicKey: verified.publicKey, counter: verified.counter, transports: verified.transports, deviceType: verified.deviceType, backedUp: verified.backedUp, nickname, createdAt: now.toISOString() };
+                throw new PasskeyVerificationError('USER_VERIFICATION_REQUIRED');
+            const device = {
+                id: deps.identifiers.deviceId(),
+                credentialId: verified.credentialId,
+                publicKey: verified.publicKey,
+                counter: verified.counter,
+                transports: verified.transports,
+                deviceType: verified.deviceType,
+                backedUp: verified.backedUp,
+                nickname,
+                createdAt: now.toISOString(),
+            };
             const session = deps.identifiers.sessionId();
             if (Buffer.from(session, 'base64url').length !== 32)
                 throw new Error('AUTHORIZATION_RANDOMNESS_INVALID');
             const expiresAt = new Date(now.getTime() + sessionLifetimeMs).toISOString();
-            const outcome = deps.repository.completeRegistration({ ceremony: passkeyCeremonyId(token), now: now.toISOString(), device, session: { id: session, deviceId: device.id, expiresAt } });
+            const outcome = deps.repository.completeRegistration({
+                ceremony: passkeyCeremonyId(token),
+                now: now.toISOString(),
+                device,
+                session: { id: session, deviceId: device.id, expiresAt },
+            });
             if (outcome !== 'registered')
-                return reply.code(outcome === 'bootstrapAlreadyClaimed' ? 409 : 400).type('application/problem+json').send(problem(outcome === 'bootstrapAlreadyClaimed' ? 'BOOTSTRAP_ALREADY_CLAIMED' : 'REGISTRATION_NOT_AVAILABLE', outcome === 'bootstrapAlreadyClaimed' ? 409 : 400, 'Registration could not be completed.'));
+                return reply
+                    .code(outcome === 'bootstrapAlreadyClaimed' ? 409 : 400)
+                    .type('application/problem+json')
+                    .send(problem(outcome === 'bootstrapAlreadyClaimed'
+                    ? 'BOOTSTRAP_ALREADY_CLAIMED'
+                    : 'REGISTRATION_NOT_AVAILABLE', outcome === 'bootstrapAlreadyClaimed' ? 409 : 400, 'Registration could not be completed.'));
             setAuthCookie(reply, 'gestalt_mobile_session', session, deps.relyingParty.publicOrigin);
             clearAuthCookie(reply, 'gestalt_mobile_registration', deps.relyingParty.publicOrigin);
             return reply.code(201).send(successSchema.parse({ status: 'authenticated' }));
         }
         catch (error) {
-            if (error instanceof PasskeyVerificationError || error instanceof AuthorizationDomainError)
-                return reply.code(400).type('application/problem+json').send(problem('REGISTRATION_VERIFICATION_FAILED', 400, 'Registration could not be completed.'));
+            if (error instanceof PasskeyVerificationError || error instanceof AuthorizationDomainError) {
+                deps.reportVerificationFailure?.(error instanceof PasskeyVerificationError
+                    ? `WEBAUTHN_${error.reason}`
+                    : 'AUTHORIZATION_REJECTED');
+                return reply
+                    .code(400)
+                    .type('application/problem+json')
+                    .send(problem('REGISTRATION_VERIFICATION_FAILED', 400, 'Registration could not be completed.'));
+            }
             throw error;
         }
     });

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

@@ -24,7 +24,10 @@ export function registerAuthRoutes(app, deps) {
             ceremonyAttempts: deps.auth.ceremonyAttempts ?? new ExpiringCeremonyAttemptGate(),
         };
         registerRegistrationOptions(app, auth);
-        registerRegistrationVerification(app, deps.auth);
+        registerRegistrationVerification(app, {
+            ...deps.auth,
+            reportVerificationFailure: (reason) => deps.logger.warn(`Passkey registration verification failed: ${reason}`),
+        });
         registerLoginOptions(app, auth);
         registerLoginVerification(app, deps.auth);
         registerAuthStatus(app, deps.auth);

package/dist/server/server/features/plans/application/measurement-snapshot.js

@@ -19,7 +19,7 @@ export function weeklyRateLimitWindow(windows) {
         Number.isFinite(window.usedPercent) &&
         window.usedPercent >= 0 &&
         window.usedPercent <= 100);
-    return valid.reduce((weekly, window) => (!weekly || window.durationSeconds > weekly.durationSeconds ? window : weekly), null);
+    return valid.reduce((weekly, window) => !weekly || window.durationSeconds > weekly.durationSeconds ? window : weekly, null);
 }
 export function weeklyRemainingPercent(windows) {
     const weekly = weeklyRateLimitWindow(windows);

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

@@ -6,9 +6,7 @@
 export function registerGetPlanMeasurement(app, deps) {
     app.get('/api/sessions/:id/plan-measurement', async (request, reply) => {
         const id = request.params.id;
-        const authorization = typeof request.headers.authorization === 'string'
-            ? request.headers.authorization
-            : undefined;
+        const authorization = typeof request.headers.authorization === 'string' ? request.headers.authorization : undefined;
         if (!deps.exists(id) || !deps.authorize(id, authorization))
             return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
         try {

package/dist/server/server/features/sessions/interaction/kind.js

@@ -4,5 +4,11 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 export function isInteractionKind(value) {
-    return ['commandApproval', 'fileChangeApproval', 'permissionsApproval', 'userInput', 'quiz'].includes(value);
+    return [
+        'commandApproval',
+        'fileChangeApproval',
+        'permissionsApproval',
+        'userInput',
+        'quiz',
+    ].includes(value);
 }

package/dist/server/server/features/sessions/list-recent-threads/endpoint.js

@@ -15,7 +15,9 @@ export function registerListRecentThreads(app, deps) {
                 recencyAt,
                 ...(metadata?.model === undefined ? {} : { model: metadata.model }),
                 ...(metadata?.skillProfile === undefined ? {} : { skillProfile: metadata.skillProfile }),
-                ...(metadata?.orgPlanFilename === undefined ? {} : { orgPlanFilename: metadata.orgPlanFilename }),
+                ...(metadata?.orgPlanFilename === undefined
+                    ? {}
+                    : { orgPlanFilename: metadata.orgPlanFilename }),
                 resumeCommand: buildResumeCommand({ profile, threadId: id, workspacePath: cwd }),
             };
         });

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

@@ -136,7 +136,9 @@ function copy(snapshot) {
         ...snapshot,
         ...(snapshot.effectiveSkillSelection === undefined
             ? {}
-            : { effectiveSkillSelection: createEffectiveSkillSelection(snapshot.effectiveSkillSelection) }),
+            : {
+                effectiveSkillSelection: createEffectiveSkillSelection(snapshot.effectiveSkillSelection),
+            }),
         pendingInteractions: snapshot.pendingInteractions.map((item) => ({ ...item })),
     };
 }

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

@@ -4,7 +4,7 @@
  * 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 { 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) {

package/dist/server/server/features/skills/delete-profile/endpoint.js

@@ -12,13 +12,22 @@ export function registerDeleteSkillProfile(app, deps) {
         try {
             const name = normalizeSkillProfileName(request.params.name);
             if (!(await deps.deleteGlobalProfile(name)))
-                return reply.code(404).type('application/problem+json').send(problem('SKILL_PROFILE_NOT_FOUND', 404, 'The skill profile was not found.'));
+                return reply
+                    .code(404)
+                    .type('application/problem+json')
+                    .send(problem('SKILL_PROFILE_NOT_FOUND', 404, 'The skill profile was not found.'));
             return reply.code(204).send();
         }
         catch (error) {
             if (error instanceof SkillProfileError)
-                return reply.code(400).type('application/problem+json').send(problem('INVALID_SKILL_PROFILE', 400, 'The skill profile could not be deleted.'));
-            return reply.code(500).type('application/problem+json').send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'The skill profile could not be deleted.', true));
+                return reply
+                    .code(400)
+                    .type('application/problem+json')
+                    .send(problem('INVALID_SKILL_PROFILE', 400, 'The skill profile could not be deleted.'));
+            return reply
+                .code(500)
+                .type('application/problem+json')
+                .send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'The skill profile could not be deleted.', true));
         }
     });
 }

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

@@ -7,13 +7,22 @@ import { z } from 'zod';
 import { applySkillSelectionSnapshot } from '../model/skill-profile.js';
 import { SkillProfileError } from '../model/errors.js';
 import { problem } from '../../../platform/http/problem.js';
-const querySchema = z.object({ workspaceId: z.string().min(1), profile: z.string().min(1), refresh: z.enum(['true']).optional() }).strict();
+const querySchema = z
+    .object({
+    workspaceId: z.string().min(1),
+    profile: z.string().min(1),
+    refresh: z.enum(['true']).optional(),
+})
+    .strict();
 /** Register the workspace-scoped skill discovery REPR slice. */
 export function registerListAvailableSkills(app, deps) {
     app.get('/api/skills', async (request, reply) => {
         const parsed = querySchema.safeParse(request.query);
         if (!parsed.success)
-            return reply.code(400).type('application/problem+json').send(problem('INVALID_SKILL_REQUEST', 400, 'workspaceId and profile are required.'));
+            return reply
+                .code(400)
+                .type('application/problem+json')
+                .send(problem('INVALID_SKILL_REQUEST', 400, 'workspaceId and profile are required.'));
         try {
             const [workspace, profile] = await Promise.all([
                 deps.workspaces.resolve(parsed.data.workspaceId),
@@ -52,10 +61,19 @@ export function registerListAvailableSkills(app, deps) {
             };
         }
         catch (error) {
-            if (error instanceof Error && (error.message === 'WORKSPACE_NOT_FOUND' || error.message === 'PROFILE_NOT_FOUND'))
-                return reply.code(404).type('application/problem+json').send(problem(error.message, 404, 'The requested catalog entry was not found.'));
-            const code = error instanceof SkillProfileError && error.code === 'INVALID_SKILL_PROFILE' ? 'INVALID_SKILL_PROFILE' : 'SKILL_DISCOVERY_FAILED';
-            return reply.code(502).type('application/problem+json').send(problem(code, 502, 'Skill discovery could not be completed.', true));
+            if (error instanceof Error &&
+                (error.message === 'WORKSPACE_NOT_FOUND' || error.message === 'PROFILE_NOT_FOUND'))
+                return reply
+                    .code(404)
+                    .type('application/problem+json')
+                    .send(problem(error.message, 404, 'The requested catalog entry was not found.'));
+            const code = error instanceof SkillProfileError && error.code === 'INVALID_SKILL_PROFILE'
+                ? 'INVALID_SKILL_PROFILE'
+                : 'SKILL_DISCOVERY_FAILED';
+            return reply
+                .code(502)
+                .type('application/problem+json')
+                .send(problem(code, 502, 'Skill discovery could not be completed.', true));
         }
     });
 }