gestalt-mobile 0.4.1 → 0.6.0

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

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { SkillProfileError } from '../model/errors.js';
+import { normalizeSkillProfileName } from '../model/skill-profile.js';
+import { problem } from '../../../platform/http/problem.js';
+/** Registers the profile-management deletion command; it has no session dependency. */
+export function registerDeleteSkillProfile(app, deps) {
+    app.delete('/api/skill-profiles/:name', async (request, reply) => {
+        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(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));
+        }
+    });
+}

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

@@ -7,7 +7,7 @@ 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();
+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) => {
@@ -20,7 +20,9 @@ export function registerListAvailableSkills(app, deps) {
                 deps.profiles.require(parsed.data.profile),
             ]);
             const [discovered, project] = await Promise.all([
-                deps.catalog(profile.name).list(workspace.realPath),
+                parsed.data.refresh
+                    ? deps.catalog.refresh(profile.name, workspace.realPath)
+                    : deps.catalog.list(profile.name, workspace.realPath),
                 deps.selections.readWorkspaceDefault(workspace.realPath),
             ]);
             const skills = project

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+import { launchCodexAppServer } from './codex-process-launcher.js';
+const modelSchema = z.object({ id: z.string().min(1) });
+const resultSchema = z.union([
+    z.object({ data: z.array(modelSchema) }),
+    z.object({ models: z.array(modelSchema) }),
+    z.object({ data: z.object({ models: z.array(modelSchema) }) }),
+]);
+/** Short-lived adapter for the Codex app-server model catalog. */
+export class CodexModelCatalog {
+    cwd;
+    launch;
+    timeoutMs;
+    constructor(cwd, launch = launchCodexAppServer, timeoutMs = 5_000) {
+        this.cwd = cwd;
+        this.launch = launch;
+        this.timeoutMs = timeoutMs;
+    }
+    async list() {
+        const server = this.launch({ profile: '', cwd: this.cwd });
+        try {
+            await this.withTimeout(server.rpc.request('initialize', {
+                clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
+                capabilities: null,
+            }));
+            const result = resultSchema.safeParse(await this.withTimeout(server.rpc.request('model/list', {})));
+            if (!result.success)
+                return [];
+            const models = 'models' in result.data
+                ? result.data.models
+                : Array.isArray(result.data.data)
+                    ? result.data.data
+                    : result.data.data.models;
+            return [...new Set(models.map((model) => model.id))].sort((left, right) => left.localeCompare(right));
+        }
+        catch {
+            return [];
+        }
+        finally {
+            server.close();
+        }
+    }
+    async withTimeout(promise) {
+        let timer;
+        try {
+            return await Promise.race([
+                promise,
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error('Codex model discovery timed out.')), this.timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+}

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

@@ -10,6 +10,7 @@ export function launchCodexAppServer(input) {
     const launch = profileAppServerCommand(input.profile, undefined, input.skillsConfig);
     const child = spawn(launch.command, launch.args, {
         cwd: input.cwd,
+        env: codexChildEnvironment(input.environment),
         shell: false,
         stdio: 'pipe',
     });
@@ -25,3 +26,10 @@ export function launchCodexAppServer(input) {
         },
     };
 }
+/** Prevents a relay's own ambient status path from reaching discovery-only children. */
+export function codexChildEnvironment(environment) {
+    const inherited = { ...process.env };
+    delete inherited.GESTALT_MOBILE_ORG_PLAN_STATUS_FILE;
+    delete inherited.GESTALT_MOBILE_ORG_PLAN_STATUS_DIRECTORY;
+    return { ...inherited, ...environment };
+}

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

@@ -11,19 +11,24 @@ export class CodexSessionRuntime {
     onServerRequest;
     onProcessExit;
     resolveSkills;
-    constructor(launch, processes = new Map(), onNotification, onServerRequest, onProcessExit, resolveSkills) {
+    planStatusSource;
+    onPlanStatus;
+    constructor(launch, processes = new Map(), onNotification, onServerRequest, onProcessExit, resolveSkills, planStatusSource, onPlanStatus) {
         this.launch = launch;
         this.processes = processes;
         this.onNotification = onNotification;
         this.onServerRequest = onServerRequest;
         this.onProcessExit = onProcessExit;
         this.resolveSkills = resolveSkills;
+        this.planStatusSource = planStatusSource;
+        this.onPlanStatus = onPlanStatus;
     }
     pendingRequests = new Map();
     exitUnsubscribers = new Map();
     threadIds = new Map();
+    planStatusLeases = new Map();
     async start(session, now, settings = {}) {
-        const process = this.launch({ profile: session.profile, cwd: session.workspacePath, skillsConfig: await this.resolveSkills?.(session.profile, session.workspacePath) });
+        const process = await this.launchForSession(session);
         try {
             process.rpc.onNotification((notification) => this.onNotification?.(session.id, notification));
             process.rpc.onServerRequest((request) => this.holdServerRequest(session.id, request));
@@ -46,6 +51,7 @@ export class CodexSessionRuntime {
         }
         catch (error) {
             process.close();
+            this.releasePlanStatus(session.id);
             throw error;
         }
     }
@@ -55,6 +61,7 @@ export class CodexSessionRuntime {
         this.processes.get(sessionId)?.close();
         this.processes.delete(sessionId);
         this.threadIds.delete(sessionId);
+        this.releasePlanStatus(sessionId);
     }
     async release(sessionId) {
         const process = this.processes.get(sessionId);
@@ -73,6 +80,8 @@ export class CodexSessionRuntime {
     stopAll() {
         for (const sessionId of [...this.processes.keys()])
             this.stop(sessionId);
+        for (const sessionId of [...this.planStatusLeases.keys()])
+            this.releasePlanStatus(sessionId);
     }
     resolveServerRequest(sessionId, requestId, result) {
         const key = `${sessionId}:${requestId}`;
@@ -90,6 +99,7 @@ export class CodexSessionRuntime {
         const result = (await process.rpc.request('turn/start', {
             threadId: session.threadId,
             input: [{ type: 'text', text, text_elements: [] }],
+            ...(session.model ? { model: session.model } : {}),
         }));
         if (!result.turn?.id)
             throw new Error('CODEX_TURN_ID_MISSING');
@@ -123,7 +133,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, skillsConfig: await this.resolveSkills?.(session.profile, session.workspacePath) });
+        const process = await this.launchForSession(session);
         try {
             process.rpc.onNotification((notification) => this.onNotification?.(session.id, notification));
             process.rpc.onServerRequest((request) => this.holdServerRequest(session.id, request));
@@ -142,6 +152,7 @@ export class CodexSessionRuntime {
         }
         catch (error) {
             process.close();
+            this.releasePlanStatus(session.id);
             throw error;
         }
     }
@@ -156,7 +167,37 @@ export class CodexSessionRuntime {
             this.processes.delete(sessionId);
             this.threadIds.delete(sessionId);
             this.exitUnsubscribers.delete(sessionId);
+            this.releasePlanStatus(sessionId);
             this.onProcessExit?.(sessionId);
         }) ?? (() => { }));
     }
+    async launchForSession(session) {
+        const lease = this.planStatusSource
+            ? await this.planStatusSource.open({ id: session.id, workspacePath: session.workspacePath }, (update) => this.onPlanStatus?.(session.id, update))
+            : undefined;
+        if (lease)
+            this.planStatusLeases.set(session.id, lease);
+        try {
+            return this.launch({
+                profile: session.profile,
+                cwd: session.workspacePath,
+                skillsConfig: await this.resolveSkills?.(session),
+                ...(lease
+                    ? {
+                        environment: {
+                            GESTALT_MOBILE_ORG_PLAN_STATUS_DIRECTORY: lease.statusDirectory,
+                        },
+                    }
+                    : {}),
+            });
+        }
+        catch (error) {
+            this.releasePlanStatus(session.id);
+            throw error;
+        }
+    }
+    releasePlanStatus(sessionId) {
+        this.planStatusLeases.get(sessionId)?.close();
+        this.planStatusLeases.delete(sessionId);
+    }
 }

package/dist/server/server/platform/persistence/migrate.js

@@ -3,7 +3,14 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-const schema = `CREATE TABLE IF NOT EXISTS relay_sessions (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, workspace_path TEXT NOT NULL, profile TEXT NOT NULL, thread_id TEXT, state TEXT NOT NULL, desired_state TEXT NOT NULL, active_turn_id TEXT, protocol_version TEXT, failure_count INTEGER NOT NULL DEFAULT 0, next_sequence INTEGER NOT NULL DEFAULT 1, created_at TEXT NOT NULL, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS pending_interactions (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, request_id TEXT NOT NULL, kind TEXT NOT NULL, payload_json TEXT NOT NULL, resolved_at TEXT, PRIMARY KEY (session_id, request_id)); CREATE TABLE IF NOT EXISTS session_events (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, sequence INTEGER NOT NULL, occurred_at TEXT NOT NULL, type TEXT NOT NULL, payload_json TEXT NOT NULL, PRIMARY KEY (session_id, sequence)); CREATE TABLE IF NOT EXISTS idempotency_results (scope TEXT NOT NULL, key TEXT NOT NULL, status_code INTEGER NOT NULL, body_json TEXT NOT NULL, PRIMARY KEY (scope, key));`;
+const schema = `CREATE TABLE IF NOT EXISTS relay_sessions (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, workspace_path TEXT NOT NULL, profile TEXT NOT NULL, model TEXT, branch TEXT, thread_id TEXT, state TEXT NOT NULL, desired_state TEXT NOT NULL, active_turn_id TEXT, protocol_version TEXT, failure_count INTEGER NOT NULL DEFAULT 0, effective_skill_selection_json TEXT, next_sequence INTEGER NOT NULL DEFAULT 1, created_at TEXT NOT NULL, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS pending_interactions (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, request_id TEXT NOT NULL, kind TEXT NOT NULL, payload_json TEXT NOT NULL, resolved_at TEXT, PRIMARY KEY (session_id, request_id)); CREATE TABLE IF NOT EXISTS session_events (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, sequence INTEGER NOT NULL, occurred_at TEXT NOT NULL, type TEXT NOT NULL, payload_json TEXT NOT NULL, PRIMARY KEY (session_id, sequence)); CREATE TABLE IF NOT EXISTS idempotency_results (scope TEXT NOT NULL, key TEXT NOT NULL, status_code INTEGER NOT NULL, body_json TEXT NOT NULL, PRIMARY KEY (scope, key));`;
 export function migrate(database) {
     database.exec(schema);
+    const columns = database.prepare('PRAGMA table_info(relay_sessions)').all();
+    if (!columns.some((column) => column.name === 'effective_skill_selection_json'))
+        database.exec('ALTER TABLE relay_sessions ADD COLUMN effective_skill_selection_json TEXT');
+    if (!columns.some((column) => column.name === 'model'))
+        database.exec('ALTER TABLE relay_sessions ADD COLUMN model TEXT');
+    if (!columns.some((column) => column.name === 'branch'))
+        database.exec('ALTER TABLE relay_sessions ADD COLUMN branch TEXT');
 }

package/dist/server/server/platform/persistence/sqlite-session-repository.js

@@ -3,6 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { createEffectiveSkillSelection, } from '../../features/sessions/model/relay-session.js';
 export class SqliteSessionRepository {
     db;
     constructor(db) {
@@ -10,8 +11,10 @@ export class SqliteSessionRepository {
     }
     save(session) {
         this.db
-            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,profile,thread_id,state,desired_state,active_turn_id,protocol_version,failure_count,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,profile=excluded.profile,thread_id=excluded.thread_id,state=excluded.state,desired_state=excluded.desired_state,active_turn_id=excluded.active_turn_id,protocol_version=excluded.protocol_version,failure_count=excluded.failure_count,updated_at=excluded.updated_at')
-            .run(session.id, session.workspaceId, session.workspacePath, session.profile, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.failureCount, session.createdAt, session.updatedAt);
+            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,profile,model,branch,thread_id,state,desired_state,active_turn_id,protocol_version,failure_count,effective_skill_selection_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,profile=excluded.profile,model=excluded.model,branch=excluded.branch,thread_id=excluded.thread_id,state=excluded.state,desired_state=excluded.desired_state,active_turn_id=excluded.active_turn_id,protocol_version=excluded.protocol_version,failure_count=excluded.failure_count,effective_skill_selection_json=excluded.effective_skill_selection_json,updated_at=excluded.updated_at')
+            .run(session.id, session.workspaceId, session.workspacePath, session.profile, session.model ?? null, session.branch ?? null, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.failureCount, session.effectiveSkillSelection === undefined
+            ? null
+            : JSON.stringify(session.effectiveSkillSelection), session.createdAt, session.updatedAt);
     }
     find(id) {
         const row = this.db.prepare('SELECT * FROM relay_sessions WHERE id = ?').get(id);
@@ -25,17 +28,23 @@ export class SqliteSessionRepository {
     }
 }
 function map(row) {
+    const effectiveSkillSelection = row.effective_skill_selection_json
+        ? createEffectiveSkillSelection(JSON.parse(row.effective_skill_selection_json))
+        : undefined;
     return {
         id: row.id,
         workspaceId: row.workspace_id,
         workspacePath: row.workspace_path,
         profile: row.profile,
+        ...(row.model === null ? {} : { model: row.model }),
+        ...(row.branch === null ? {} : { branch: row.branch }),
         threadId: row.thread_id,
         state: row.state,
         desiredState: row.desired_state,
         activeTurnId: row.active_turn_id,
         protocolVersion: row.protocol_version,
         failureCount: row.failure_count,
+        ...(effectiveSkillSelection === undefined ? {} : { effectiveSkillSelection }),
         pendingInteractions: [],
         createdAt: row.created_at,
         updatedAt: row.updated_at,

package/dist/server/server/platform/plans/filesystem-plan-status-source.js

@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { chmod, mkdir, readFile, readdir, rename, rm, stat, watch, writeFile, realpath, } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { basename, dirname, join } from 'node:path';
+import { parseSupervisedPlan } from '../../features/plans/application/parse-supervised-plan.js';
+import { isPlanPathWithinWorkspace } from '../../features/plans/application/parse-supervised-plan.js';
+const statusFileSuffix = '.plan-status.json';
+export class FilesystemPlanStatusSource {
+    dismissalDirectory;
+    dismissalFilesystem;
+    planReadFilesystem;
+    statusRemovalFilesystem;
+    leases = new Map();
+    activeStatusPaths = new Map();
+    constructor(dismissalDirectory, dismissalFilesystem = { writeFile, rename }, planReadFilesystem = { readFile, realpath }, statusRemovalFilesystem = { rm }) {
+        this.dismissalDirectory = dismissalDirectory;
+        this.dismissalFilesystem = dismissalFilesystem;
+        this.planReadFilesystem = planReadFilesystem;
+        this.statusRemovalFilesystem = statusRemovalFilesystem;
+    }
+    async open(session, listener) {
+        this.leases.get(session.id)?.close();
+        const statusDirectory = planStatusDirectoryPath(session.workspacePath, session.id);
+        await mkdir(this.dismissalDirectory, { recursive: true, mode: 0o700 });
+        await mkdir(statusDirectory, { recursive: true, mode: 0o700 });
+        if (process.platform !== 'win32') {
+            await Promise.all([
+                chmod(this.dismissalDirectory, 0o700),
+                chmod(statusDirectory, 0o700),
+            ]);
+        }
+        const lease = new ActiveLease(statusDirectory, session.id, session.workspacePath, listener, this.planReadFilesystem, (identity) => this.isDismissed(session.id, identity), (statusPath) => this.activeStatusPaths.set(session.id, statusPath), () => {
+            this.leases.delete(session.id);
+            this.activeStatusPaths.delete(session.id);
+        });
+        this.leases.set(session.id, lease);
+        await lease.start();
+        return lease;
+    }
+    closeAll() {
+        for (const lease of this.leases.values())
+            lease.close();
+        this.leases.clear();
+    }
+    async remove(sessionId, identity) {
+        const statusPath = this.activeStatusPaths.get(sessionId);
+        const signal = statusPath ? await this.readStatusForRollback(statusPath) : undefined;
+        if (statusPath)
+            await this.statusRemovalFilesystem.rm(statusPath, { force: true });
+        try {
+            if (identity)
+                await this.dismiss(sessionId, identity);
+        }
+        catch (error) {
+            if (signal !== undefined && statusPath)
+                await this.restoreStatus(statusPath, signal);
+            throw error;
+        }
+    }
+    async readStatusForRollback(statusPath) {
+        try {
+            return await this.planReadFilesystem.readFile(statusPath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
+    async restoreStatus(statusPath, signal) {
+        const candidate = join(dirname(statusPath), `.${randomUUID()}.status.tmp`);
+        try {
+            await writeFile(candidate, signal, { mode: 0o600 });
+            await rename(candidate, statusPath);
+        }
+        catch (error) {
+            await rm(candidate, { force: true }).catch(() => { });
+            throw error;
+        }
+    }
+    async dismiss(sessionId, identity) {
+        const path = this.dismissalPath(sessionId);
+        const dismissed = await this.dismissed(sessionId);
+        const next = new Set(dismissed).add(identity);
+        const candidate = join(this.dismissalDirectory, `.${randomUUID()}.dismissals.tmp`);
+        try {
+            await this.dismissalFilesystem.writeFile(candidate, JSON.stringify([...next]), { mode: 0o600 });
+            await this.dismissalFilesystem.rename(candidate, path);
+        }
+        catch (error) {
+            await rm(candidate, { force: true }).catch(() => { });
+            throw error;
+        }
+        this.dismissedBySession.set(sessionId, next);
+    }
+    async isDismissed(sessionId, identity) {
+        return (await this.dismissed(sessionId)).has(identity);
+    }
+    dismissedBySession = new Map();
+    async dismissed(sessionId) {
+        const cached = this.dismissedBySession.get(sessionId);
+        if (cached)
+            return cached;
+        try {
+            const values = JSON.parse(await this.planReadFilesystem.readFile(this.dismissalPath(sessionId), 'utf8'));
+            if (!Array.isArray(values) || values.some((value) => typeof value !== 'string'))
+                throw new Error();
+            const dismissed = new Set(values);
+            this.dismissedBySession.set(sessionId, dismissed);
+            return dismissed;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            const absent = new Set();
+            this.dismissedBySession.set(sessionId, absent);
+            return absent;
+        }
+    }
+    dismissalPath(sessionId) {
+        return join(this.dismissalDirectory, `${createHash('sha256').update(sessionId).digest('hex')}.dismissals.json`);
+    }
+}
+export function planStatusDirectoryPath(workspacePath, sessionId) {
+    const opaqueSessionId = createHash('sha256').update(sessionId).digest('hex');
+    return join(workspacePath, '.gestalt', 'status', opaqueSessionId);
+}
+export function planStatusFilePath(statusDirectory, canonicalPlanPath) {
+    const opaquePlanId = createHash('sha256').update(canonicalPlanPath).digest('hex');
+    return join(statusDirectory, `${opaquePlanId}${statusFileSuffix}`);
+}
+class ActiveLease {
+    statusDirectory;
+    sessionId;
+    workspacePath;
+    listener;
+    planReadFilesystem;
+    isDismissed;
+    onActiveStatusPath;
+    onClose;
+    watcher;
+    debounce;
+    closed = false;
+    activeStatusPath;
+    constructor(statusDirectory, sessionId, workspacePath, listener, planReadFilesystem, isDismissed, onActiveStatusPath, onClose) {
+        this.statusDirectory = statusDirectory;
+        this.sessionId = sessionId;
+        this.workspacePath = workspacePath;
+        this.listener = listener;
+        this.planReadFilesystem = planReadFilesystem;
+        this.isDismissed = isDismissed;
+        this.onActiveStatusPath = onActiveStatusPath;
+        this.onClose = onClose;
+    }
+    async start() {
+        await this.refreshLatest();
+        try {
+            this.watcher = watch(this.statusDirectory, { persistent: false });
+            void this.consumeChanges();
+        }
+        catch {
+            this.listener({ kind: 'unavailable', code: 'PLAN_STATUS_UNAVAILABLE' });
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.debounce)
+            clearTimeout(this.debounce);
+        void this.watcher?.return?.();
+        this.onClose();
+    }
+    async remove() {
+        if (this.activeStatusPath)
+            await rm(this.activeStatusPath, { force: true });
+    }
+    async consumeChanges() {
+        try {
+            for await (const event of this.watcher) {
+                if (this.closed)
+                    return;
+                if (!event.filename) {
+                    this.scheduleRefresh();
+                    continue;
+                }
+                const filename = basename(String(event.filename));
+                if (!filename.endsWith(statusFileSuffix))
+                    continue;
+                this.scheduleRefresh(join(this.statusDirectory, filename));
+            }
+        }
+        catch {
+            if (!this.closed)
+                this.listener({ kind: 'unavailable', code: 'PLAN_STATUS_UNAVAILABLE' });
+        }
+    }
+    pendingStatusPath;
+    scheduleRefresh(statusPath) {
+        this.pendingStatusPath = statusPath;
+        if (this.debounce)
+            clearTimeout(this.debounce);
+        this.debounce = setTimeout(() => {
+            this.debounce = undefined;
+            const pendingStatusPath = this.pendingStatusPath;
+            this.pendingStatusPath = undefined;
+            void (pendingStatusPath ? this.refresh(pendingStatusPath) : this.refreshLatest());
+        }, 25);
+    }
+    async refreshLatest() {
+        try {
+            const candidates = (await readdir(this.statusDirectory))
+                .filter((filename) => filename.endsWith(statusFileSuffix))
+                .map((filename) => join(this.statusDirectory, filename));
+            const signals = await Promise.all(candidates.map(async (statusPath) => {
+                const [source, metadata] = await Promise.all([
+                    this.planReadFilesystem.readFile(statusPath, 'utf8').catch(() => ''),
+                    stat(statusPath).catch(() => undefined),
+                ]);
+                return { statusPath, signal: parseSignal(source), modifiedAt: metadata?.mtimeMs ?? 0 };
+            }));
+            const latest = signals
+                .filter((candidate) => candidate.signal !== null)
+                .sort((left, right) => right.signal.updatedAt.localeCompare(left.signal.updatedAt) ||
+                right.modifiedAt - left.modifiedAt)[0];
+            if (latest)
+                await this.refresh(latest.statusPath, latest.signal);
+        }
+        catch {
+            if (!this.closed)
+                this.listener({ kind: 'unavailable', code: 'PLAN_STATUS_UNAVAILABLE' });
+        }
+    }
+    async refresh(statusPath, parsedSignal) {
+        try {
+            const signal = parsedSignal ?? parseSignal(await this.planReadFilesystem.readFile(statusPath, 'utf8'));
+            if (!signal)
+                throw new Error('INVALID_PLAN_STATUS');
+            const [planPath, workspacePath] = await Promise.all([
+                this.planReadFilesystem.realpath(signal.planPath),
+                this.planReadFilesystem.realpath(this.workspacePath),
+            ]);
+            if (!isPlanPathWithinWorkspace(planPath, workspacePath))
+                throw new Error('PATH_OUTSIDE_WORKSPACE');
+            const identity = createHash('sha256').update(planPath).digest('hex');
+            if (await this.isDismissed(identity))
+                return;
+            const result = parseSupervisedPlan({
+                source: await this.planReadFilesystem.readFile(planPath, 'utf8'),
+                planPath,
+                workspacePath,
+            });
+            if (result.kind === 'available') {
+                if (!this.closed && !(await this.isDismissed(identity)) && !this.closed) {
+                    const previousStatusPath = this.activeStatusPath;
+                    this.activeStatusPath = statusPath;
+                    this.onActiveStatusPath(statusPath);
+                    this.listener({ kind: 'updated', plan: result.plan, identity });
+                    if (previousStatusPath && previousStatusPath !== statusPath)
+                        await rm(previousStatusPath, { force: true }).catch(() => { });
+                }
+            }
+            else if (!this.closed) {
+                this.listener({ kind: 'unavailable', code: 'PLAN_STATUS_UNAVAILABLE' });
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' &&
+                this.activeStatusPath !== undefined &&
+                statusPath !== this.activeStatusPath)
+                return;
+            if (!this.closed)
+                this.listener({ kind: 'unavailable', code: 'PLAN_STATUS_UNAVAILABLE' });
+        }
+    }
+}
+function parseSignal(source) {
+    try {
+        const value = JSON.parse(source);
+        if (!value || typeof value !== 'object')
+            return null;
+        const signal = value;
+        if (signal.schemaVersion !== 1 || typeof signal.planPath !== 'string')
+            return null;
+        if (typeof signal.reason !== 'string' || !isRfc3339Utc(signal.updatedAt))
+            return null;
+        return { planPath: signal.planPath, updatedAt: signal.updatedAt };
+    }
+    catch {
+        return null;
+    }
+}
+function isRfc3339Utc(value) {
+    return (typeof value === 'string' &&
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(value) &&
+        !Number.isNaN(Date.parse(value)));
+}

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { resolve } from 'node:path';
+/** In-memory editor catalog: discovery runs only when the relay starts or a user refreshes it. */
+export class CachedSkillCatalog {
+    discover;
+    entries = new Map();
+    constructor(discover) {
+        this.discover = discover;
+    }
+    async list(profile, workspace) {
+        return (this.entries.get(this.key(profile, workspace)) ?? {
+            skills: [],
+            errors: [
+                {
+                    message: 'Skills are not cached for this workspace and Codex profile. Select Refresh skills to discover them.',
+                },
+            ],
+        });
+    }
+    async refresh(profile, workspace) {
+        try {
+            const result = await this.discover(profile, workspace);
+            this.entries.set(this.key(profile, workspace), result);
+            return result;
+        }
+        catch {
+            const result = {
+                skills: [],
+                errors: [{ message: 'Skill discovery failed. Select Refresh skills to try again.' }],
+            };
+            this.entries.set(this.key(profile, workspace), result);
+            return result;
+        }
+    }
+    key(profile, workspace) {
+        return `${profile}\u0000${resolve(workspace)}`;
+    }
+}