gestalt-mobile 0.3.1 → 0.4.1

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+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) }).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.'));
+        try {
+            const [workspace, profile] = await Promise.all([
+                deps.workspaces.resolve(parsed.data.workspaceId),
+                deps.profiles.require(parsed.data.profile),
+            ]);
+            const [discovered, project] = await Promise.all([
+                deps.catalog(profile.name).list(workspace.realPath),
+                deps.selections.readWorkspaceDefault(workspace.realPath),
+            ]);
+            const skills = project
+                ? applySkillSelectionSnapshot(discovered.skills, project.skills)
+                : discovered.skills;
+            return {
+                source: project ? 'project' : 'native',
+                errors: discovered.errors.map(({ message }) => ({ message })),
+                skills: [...skills]
+                    .sort((left, right) => left.path.localeCompare(right.path))
+                    .map((skill) => ({
+                    name: skill.name,
+                    description: skill.description,
+                    shortDescription: skill.shortDescription,
+                    displayName: skill.interface?.displayName,
+                    interfaceShortDescription: skill.interface?.shortDescription,
+                    iconSmall: skill.interface?.iconSmall,
+                    iconLarge: skill.interface?.iconLarge,
+                    brandColor: skill.interface?.brandColor,
+                    defaultPrompt: skill.interface?.defaultPrompt,
+                    dependencies: skill.dependencies,
+                    path: skill.path,
+                    scope: skill.scope,
+                    nativeEnabled: discovered.skills.find((native) => native.path === skill.path)?.enabled ?? false,
+                    effectiveEnabled: skill.enabled,
+                })),
+            };
+        }
+        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));
+        }
+    });
+}

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

@@ -0,0 +1,28 @@
+/*
+ * 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 registerListSkillProfiles(app, deps) {
+    app.get('/api/skill-profiles', async (_request, reply) => {
+        try {
+            const names = await deps.listGlobalProfileNames();
+            const profiles = await Promise.all(names.sort((a, b) => a.localeCompare(b)).map(async (name) => {
+                try {
+                    const profile = await deps.readGlobalProfile(name);
+                    return profile
+                        ? { name: profile.name, version: profile.version, path: deps.profilePath(name), skills: profile.skills }
+                        : { name, path: deps.profilePath(name), error: { code: 'INVALID_SKILL_PROFILE', message: 'Profile disappeared while reading.' } };
+                }
+                catch (error) {
+                    return { name, path: deps.profilePath(name), error: { code: 'INVALID_SKILL_PROFILE', message: error instanceof Error ? error.message : 'Invalid profile.' } };
+                }
+            }));
+            return { profiles };
+        }
+        catch {
+            return reply.code(500).type('application/problem+json').send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'Skill profiles could not be read.', true));
+        }
+    });
+}

package/dist/server/server/features/skills/model/errors.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
+ */
+/** A stable, transport-independent failure in the skill selection bounded context. */
+export class SkillProfileError extends Error {
+    code;
+    constructor(code, message = code) {
+        super(message);
+        this.code = code;
+        this.name = 'SkillProfileError';
+    }
+}

package/dist/server/server/features/skills/model/skill-profile.js

@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { isAbsolute, normalize } from 'node:path';
+import { parseDocument, stringify } from 'yaml';
+import { z } from 'zod';
+import { SkillProfileError } from './errors.js';
+const profileNamePattern = /^[a-z0-9](?:[a-z0-9-]{0,62})?$/;
+/**
+ * A path-keyed skill record. `name` is display metadata only: a skill's path is
+ * its identity, because Codex may discover equal names in different scopes.
+ */
+export const skillSelectionEntrySchema = z
+    .object({
+    name: z.string().trim().min(1),
+    path: z.string().min(1),
+    enabled: z.boolean(),
+})
+    .strict();
+/** Metadata exposed by the stable skill catalog boundary, never protocol objects. */
+export const availableSkillSchema = z
+    .object({
+    name: z.string().trim().min(1),
+    path: z.string().min(1),
+    enabled: z.boolean(),
+    description: z.string().optional(),
+    shortDescription: z.string().optional(),
+    interface: z
+        .object({
+        displayName: z.string().optional(),
+        shortDescription: z.string().optional(),
+        iconSmall: z.string().optional(),
+        iconLarge: z.string().optional(),
+        brandColor: z.string().optional(),
+        defaultPrompt: z.string().optional(),
+    })
+        .optional(),
+    dependencies: z.object({ tools: z.array(z.object({ type: z.string(), value: z.string(), description: z.string().optional(), transport: z.string().optional(), command: z.string().optional(), url: z.string().optional() })).optional() }).optional(),
+    scope: z.string().optional(),
+})
+    .strict();
+const profileDocumentSchema = z
+    .object({
+    version: z.literal(1),
+    name: z.string().min(1),
+    skills: z.array(skillSelectionEntrySchema),
+})
+    .strict();
+/**
+ * Normalize a profile name before using it in its global filename. The output
+ * is deliberately narrow so a profile name can never become a path traversal.
+ */
+export function normalizeSkillProfileName(value) {
+    const normalized = value.trim().toLowerCase().replace(/[\s_]+/g, '-');
+    if (!profileNamePattern.test(normalized)) {
+        throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Invalid skill profile name.');
+    }
+    return normalized;
+}
+function canonicalSkillPath(value) {
+    if (!isAbsolute(value) || normalize(value) !== value) {
+        throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Skill paths must be canonical absolute paths.');
+    }
+    return value;
+}
+/**
+ * Validate a complete selection and return its canonical deterministic order.
+ * This is lexical only: resolving symlinks is I/O and belongs to a platform
+ * adapter before it constructs this domain value.
+ */
+export function createSkillSelection(entries) {
+    const paths = new Set();
+    const validated = entries.map((entry) => {
+        const parsed = skillSelectionEntrySchema.safeParse(entry);
+        if (!parsed.success) {
+            throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Invalid skill selection entry.');
+        }
+        const path = canonicalSkillPath(parsed.data.path);
+        if (paths.has(path)) {
+            throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Duplicate skill selection path.');
+        }
+        paths.add(path);
+        return { ...parsed.data, path };
+    });
+    return validated.sort((left, right) => left.path.localeCompare(right.path));
+}
+/**
+ * Apply an optional complete selection snapshot to a fresh catalog. Selection
+ * entry names are never used for matching: canonical paths are the identity.
+ * Without a snapshot, the catalog retains Codex-native enabled states.
+ */
+export function applySkillSelectionSnapshot(discovered, selection) {
+    const catalog = discovered.map((skill) => {
+        const parsed = availableSkillSchema.safeParse(skill);
+        if (!parsed.success) {
+            throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Invalid available skill.');
+        }
+        return { ...parsed.data, path: canonicalSkillPath(parsed.data.path) };
+    });
+    if (selection === undefined) {
+        return catalog;
+    }
+    const enabledByPath = new Map(createSkillSelection(selection).map((entry) => [entry.path, entry.enabled]));
+    return catalog.map((skill) => ({ ...skill, enabled: enabledByPath.get(skill.path) ?? false }));
+}
+/** Explicit session selection takes precedence over a workspace default. */
+export function selectEffectiveSkillSelection(input) {
+    if (input.explicit !== undefined)
+        return { source: 'explicit', selection: createSkillSelection(input.explicit) };
+    if (input.project !== undefined)
+        return { source: 'project', selection: createSkillSelection(input.project) };
+    return { source: 'native', selection: undefined };
+}
+/**
+ * Compile a complete, process-local `skills.config` map from fresh discovery.
+ * It neither writes configuration nor mutates the user Codex installation.
+ */
+export function compileSkillOverride(input) {
+    const effective = selectEffectiveSkillSelection(input);
+    if (effective.selection === undefined)
+        return { source: 'native', skillsConfig: undefined, warnings: [] };
+    const discoveredPaths = new Set(input.discovered.map((skill) => canonicalSkillPath(skill.path)));
+    const warnings = effective.selection
+        .filter((entry) => !discoveredPaths.has(entry.path))
+        .map((entry) => `Saved skill path is no longer discovered: ${entry.path}`);
+    const configured = applySkillSelectionSnapshot(input.discovered, effective.selection);
+    return {
+        source: effective.source,
+        skillsConfig: configured
+            .map((skill) => ({ path: skill.path, enabled: skill.enabled }))
+            .sort((left, right) => left.path.localeCompare(right.path)),
+        warnings,
+    };
+}
+/** Construct the single profile contract shared by global and project YAML files. */
+export function createSkillProfile(input) {
+    return { version: 1, name: normalizeSkillProfileName(input.name), skills: createSkillSelection(input.skills) };
+}
+/** Parse the version-1 YAML document without performing filesystem access. */
+export function parseSkillProfileYaml(source) {
+    const document = parseDocument(source, { prettyErrors: false, strict: true, uniqueKeys: true });
+    if (document.errors.length > 0) {
+        throw new SkillProfileError('INVALID_SKILL_PROFILE_YAML', 'Invalid skill profile YAML.');
+    }
+    const parsed = profileDocumentSchema.safeParse(document.toJS());
+    if (!parsed.success) {
+        throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Invalid skill profile document.');
+    }
+    return createSkillProfile(parsed.data);
+}
+/** Serialize the canonical version-1 YAML document in deterministic path order. */
+export function serializeSkillProfileYaml(profile) {
+    const canonical = createSkillProfile(profile);
+    return stringify({ version: 1, name: canonical.name, skills: canonical.skills });
+}

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+import { createSkillProfile, normalizeSkillProfileName } from '../model/skill-profile.js';
+import { SkillProfileError } from '../model/errors.js';
+import { problem } from '../../../platform/http/problem.js';
+const requestSchema = z.object({ version: z.literal(1), name: z.string(), skills: z.array(z.object({ name: z.string(), path: z.string(), enabled: z.boolean() }).strict()) }).strict();
+export function registerReplaceSkillProfile(app, deps) {
+    app.put('/api/skill-profiles/:name', async (request, reply) => {
+        const body = requestSchema.safeParse(request.body);
+        try {
+            const name = normalizeSkillProfileName(request.params.name);
+            if (!body.success || normalizeSkillProfileName(body.data.name) !== name)
+                return reply.code(400).type('application/problem+json').send(problem('INVALID_SKILL_PROFILE', 400, 'The route and body profile names must match.'));
+            const profile = createSkillProfile(body.data);
+            const existed = await deps.readGlobalProfile(name);
+            await deps.replaceGlobalProfile(profile);
+            return reply.code(existed ? 200 : 201).send({ ...profile, path: deps.profilePath(name) });
+        }
+        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 stored.'));
+            return reply.code(500).type('application/problem+json').send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'The skill profile could not be stored.', true));
+        }
+    });
+}

package/dist/server/server/platform/catalog/profile-command.js

@@ -11,9 +11,12 @@ const localAvailability = {
     codexProfileAvailable: () => !spawnSync('codex-profile', ['--version'], { stdio: 'ignore' }).error,
     gestaltHomeExists: () => existsSync(join(homedir(), '.codex-gestalt')),
 };
-export function profileAppServerCommand(_profile, availability = localAvailability) {
+export function profileAppServerCommand(_profile, availability = localAvailability, skillsConfig) {
     void _profile;
-    return availability.codexProfileAvailable() && availability.gestaltHomeExists()
+    const base = availability.codexProfileAvailable() && availability.gestaltHomeExists()
         ? { command: 'codex-profile', args: ['cli', 'gestalt', 'app-server', '--stdio'] }
         : { command: 'codex', args: ['app-server', '--stdio'] };
+    return skillsConfig === undefined
+        ? base
+        : { ...base, args: [...base.args, '--config', `skills.config = [${skillsConfig.map((entry) => `{ path = ${JSON.stringify(entry.path)}, enabled = ${entry.enabled} }`).join(', ')}]`] };
 }

package/dist/server/server/platform/codex/codex-process-launcher.js

@@ -7,7 +7,7 @@ import { spawn } from 'node:child_process';
 import { JsonRpcClient } from './json-rpc-client.js';
 import { profileAppServerCommand } from '../catalog/profile-command.js';
 export function launchCodexAppServer(input) {
-    const launch = profileAppServerCommand(input.profile);
+    const launch = profileAppServerCommand(input.profile, undefined, input.skillsConfig);
     const child = spawn(launch.command, launch.args, {
         cwd: input.cwd,
         shell: false,

package/dist/server/server/platform/codex/session-runtime.js

@@ -10,18 +10,20 @@ export class CodexSessionRuntime {
     onNotification;
     onServerRequest;
     onProcessExit;
-    constructor(launch, processes = new Map(), onNotification, onServerRequest, onProcessExit) {
+    resolveSkills;
+    constructor(launch, processes = new Map(), onNotification, onServerRequest, onProcessExit, resolveSkills) {
         this.launch = launch;
         this.processes = processes;
         this.onNotification = onNotification;
         this.onServerRequest = onServerRequest;
         this.onProcessExit = onProcessExit;
+        this.resolveSkills = resolveSkills;
     }
     pendingRequests = new Map();
     exitUnsubscribers = new Map();
     threadIds = new Map();
     async start(session, now, settings = {}) {
-        const process = this.launch({ profile: session.profile, cwd: session.workspacePath });
+        const process = this.launch({ profile: session.profile, cwd: session.workspacePath, skillsConfig: await this.resolveSkills?.(session.profile, session.workspacePath) });
         try {
             process.rpc.onNotification((notification) => this.onNotification?.(session.id, notification));
             process.rpc.onServerRequest((request) => this.holdServerRequest(session.id, request));
@@ -121,7 +123,7 @@ export class CodexSessionRuntime {
     async restore(session, now) {
         if (!session.threadId)
             throw new Error('CODEX_THREAD_ID_MISSING');
-        const process = this.launch({ profile: session.profile, cwd: session.workspacePath });
+        const process = this.launch({ profile: session.profile, cwd: session.workspacePath, skillsConfig: await this.resolveSkills?.(session.profile, session.workspacePath) });
         try {
             process.rpc.onNotification((notification) => this.onNotification?.(session.id, notification));
             process.rpc.onServerRequest((request) => this.holdServerRequest(session.id, request));

package/dist/server/server/platform/skills/codex-skill-catalog.js

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+import { resolve } from 'node:path';
+import { availableSkillSchema } from '../../features/skills/model/skill-profile.js';
+import { SkillProfileError } from '../../features/skills/model/errors.js';
+import { launchCodexAppServer } from '../codex/codex-process-launcher.js';
+const wireSkillSchema = z.object({
+    name: z.string(), description: z.string(), shortDescription: z.string().optional(),
+    interface: z.object({ displayName: z.string().optional(), shortDescription: z.string().optional(), iconSmall: z.string().optional(), iconLarge: z.string().optional(), brandColor: z.string().optional(), defaultPrompt: z.string().optional() }).optional(),
+    dependencies: z.object({ tools: z.array(z.object({ type: z.string(), value: z.string(), description: z.string().optional(), transport: z.string().optional(), command: z.string().optional(), url: z.string().optional() })).optional() }).optional(),
+    path: z.string(), scope: z.string().optional(), enabled: z.boolean(),
+});
+const resultSchema = z.object({ data: z.array(z.object({ cwd: z.string(), skills: z.array(wireSkillSchema), errors: z.array(z.unknown()) })) });
+/** Short-lived Codex app-server adapter: initialize, discover, and always terminate. */
+export class CodexSkillCatalog {
+    profile;
+    launch;
+    timeoutMs;
+    constructor(profile, launch = launchCodexAppServer, timeoutMs = 5_000) {
+        this.profile = profile;
+        this.launch = launch;
+        this.timeoutMs = timeoutMs;
+    }
+    async list(workspace) {
+        const canonicalWorkspace = resolve(workspace);
+        const server = this.launch({ profile: this.profile, cwd: canonicalWorkspace });
+        try {
+            await this.withTimeout(server.rpc.request('initialize', { clientInfo: { name: 'gestalt-mobile' } }));
+            const result = await this.withTimeout(server.rpc.request('skills/list', { cwds: [canonicalWorkspace], forceReload: true }));
+            const parsed = resultSchema.safeParse(result);
+            if (!parsed.success)
+                throw new SkillProfileError('INVALID_SKILL_DISCOVERY', 'Invalid Codex skill catalog response.');
+            const entry = parsed.data.data.find((candidate) => candidate.cwd === canonicalWorkspace);
+            if (!entry)
+                throw new SkillProfileError('INVALID_SKILL_DISCOVERY', 'Codex did not return the requested workspace catalog.');
+            const skills = entry.skills.map((skill) => {
+                const stable = availableSkillSchema.safeParse(skill);
+                if (!stable.success)
+                    throw new SkillProfileError('INVALID_SKILL_DISCOVERY', 'Invalid Codex skill metadata.');
+                return stable.data;
+            });
+            return {
+                skills,
+                errors: entry.errors.map((error) => ({ message: typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string' ? error.message : 'Codex skill discovery error.' })),
+            };
+        }
+        catch (error) {
+            if (error instanceof SkillProfileError)
+                throw error;
+            throw new SkillProfileError('INVALID_SKILL_DISCOVERY', 'Codex skill discovery failed.');
+        }
+        finally {
+            server.close();
+        }
+    }
+    async withTimeout(promise) {
+        let timer;
+        try {
+            return await Promise.race([
+                promise,
+                new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('timeout')), this.timeoutMs); }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+}

package/dist/server/server/platform/skills/filesystem-skill-profile-store.js

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, rename, rm, writeFile, lstat, readFile, realpath } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { normalizeSkillProfileName, parseSkillProfileYaml, serializeSkillProfileYaml, } from '../../features/skills/model/skill-profile.js';
+import { SkillProfileError } from '../../features/skills/model/errors.js';
+function missing(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+/** Filesystem adapter with injected home directory; no process-global home lookup. */
+export class FilesystemSkillProfileStore {
+    homeDirectory;
+    constructor(homeDirectory) {
+        this.homeDirectory = homeDirectory;
+    }
+    /** Absolute canonical location of one normalized global profile. */
+    globalProfilePath(name) {
+        return join(resolve(this.homeDirectory), '.gestalt', 'skill-profiles', `${normalizeSkillProfileName(name)}.yml`);
+    }
+    async listGlobalProfileNames() {
+        const root = await this.globalRoot();
+        try {
+            const entries = await readdir(root, { withFileTypes: true, encoding: 'utf8' });
+            return entries
+                .filter((entry) => entry.isFile() && entry.name.endsWith('.yml'))
+                .map((entry) => entry.name.slice(0, -4))
+                .filter((name) => {
+                try {
+                    return normalizeSkillProfileName(name) === name;
+                }
+                catch {
+                    return false;
+                }
+            })
+                .sort((left, right) => left.localeCompare(right));
+        }
+        catch (error) {
+            if (missing(error))
+                return [];
+            throw error;
+        }
+    }
+    async readGlobalProfile(name) {
+        const path = this.globalProfilePath(name);
+        return this.readProfile(path);
+    }
+    async replaceGlobalProfile(profile) {
+        const name = normalizeSkillProfileName(profile.name);
+        const root = await this.globalRoot();
+        await mkdir(root, { recursive: true, mode: 0o700 });
+        const destination = join(root, `${name}.yml`);
+        const temporary = join(root, `.${name}.${randomUUID()}.tmp`);
+        try {
+            await writeFile(temporary, serializeSkillProfileYaml(profile), { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            await rename(temporary, destination);
+        }
+        finally {
+            await rm(temporary, { force: true }).catch(() => undefined);
+        }
+    }
+    async readWorkspaceDefault(workspace) {
+        const root = await realpath(workspace);
+        const path = resolve(root, 'gestalt-skills.yml');
+        if (dirname(path) !== root) {
+            throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Workspace profile escaped its root.');
+        }
+        return this.readProfile(path);
+    }
+    async globalRoot() {
+        const home = resolve(this.homeDirectory);
+        const root = resolve(home, '.gestalt', 'skill-profiles');
+        if (!root.startsWith(`${home}/`)) {
+            throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Global profile root escaped home.');
+        }
+        return root;
+    }
+    async readProfile(path) {
+        try {
+            const stat = await lstat(path);
+            if (stat.isSymbolicLink() || !stat.isFile()) {
+                throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Profile must be a regular file.');
+            }
+            return parseSkillProfileYaml(await readFile(path, 'utf8'));
+        }
+        catch (error) {
+            if (missing(error))
+                return undefined;
+            throw error;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",
@@ -55,6 +55,7 @@
     "@fastify/static": "^10.1.0",
     "fastify": "^5.10.0",
     "ws": "^8.21.0",
+    "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {