gestalt-mobile 0.42.0 → 0.43.0

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

@@ -18,14 +18,22 @@ import { WriterAcquisitionError, } from '../../features/sessions/application/wri
 import { isCodexThreadWriterBusy, isMissingCodexThreadRollout } from './json-rpc-client.js';
 import { resolvedServerRequestId } from './server-request.js';
 /** Sticky thread config keeps skill paths out of the app-server process argv. */
-export function threadSkillConfig(skillsConfig) {
-    return skillsConfig === undefined ? {} : { config: { skills: { config: skillsConfig } } };
+export function threadSkillConfig(skillsConfig, modelConfig = {}) {
+    return skillsConfig === undefined && !Object.keys(modelConfig).length
+        ? {}
+        : {
+            config: {
+                ...modelConfig,
+                ...(skillsConfig === undefined ? {} : { skills: { config: skillsConfig } }),
+            },
+        };
 }
 /** One private owner for every resource acquired for a live Codex child. */
 class SessionResource {
     sessionId;
     process;
     skillsConfig;
+    modelConfig;
     planStatusLease;
     planMeasurementToken;
     unregister;
@@ -44,10 +52,11 @@ class SessionResource {
     completedProcessActions = new Map();
     turnThreads = new Map();
     childThreads = new Set();
-    constructor(sessionId, process, skillsConfig, planStatusLease, planMeasurementToken, unregister, onDisposed) {
+    constructor(sessionId, process, skillsConfig, modelConfig, planStatusLease, planMeasurementToken, unregister, onDisposed) {
         this.sessionId = sessionId;
         this.process = process;
         this.skillsConfig = skillsConfig;
+        this.modelConfig = modelConfig;
         this.planStatusLease = planStatusLease;
         this.planMeasurementToken = planMeasurementToken;
         this.unregister = unregister;
@@ -92,13 +101,14 @@ export class CodexSessionRuntime {
     planMeasurementBaseUrl;
     maxPendingRequests;
     readerCwd;
+    resolveModelConfig;
     serverResponseListeners = new Set();
     constructor(launch, 
     // Kept as an ignored compatibility slot while callers migrate from the old
     // correlated-map constructor shape.  Live ownership is `sessions` only.
     _legacyProcesses = undefined, onNotification, onServerRequest, onProcessExit, resolveSkills, planStatusSource, onPlanStatus, planMeasurementBaseUrl, 
     // Compatibility slot: blocking app-server requests wait for explicit input.
-    _legacyRequestTimeoutMs = undefined, maxPendingRequests = 64, readerCwd) {
+    _legacyRequestTimeoutMs = undefined, maxPendingRequests = 64, readerCwd, resolveModelConfig) {
         this.launch = launch;
         this.onNotification = onNotification;
         this.onServerRequest = onServerRequest;
@@ -109,6 +119,7 @@ export class CodexSessionRuntime {
         this.planMeasurementBaseUrl = planMeasurementBaseUrl;
         this.maxPendingRequests = maxPendingRequests;
         this.readerCwd = readerCwd;
+        this.resolveModelConfig = resolveModelConfig;
         void _legacyProcesses;
         void _legacyRequestTimeoutMs;
     }
@@ -123,7 +134,7 @@ export class CodexSessionRuntime {
                 clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
                 capabilities: { experimentalApi: true },
             });
-            const startedThreadId = await this.startThread(resource.process, session, resource.skillsConfig);
+            const startedThreadId = await this.startThread(resource.process, session, resource.skillsConfig, resource.modelConfig);
             resource.threadId = startedThreadId;
             this.sessions.set(session.id, resource);
             await this.writePendingThreadName(session.id);
@@ -224,6 +235,9 @@ export class CodexSessionRuntime {
             input: [{ type: 'text', text, text_elements: [] }],
             ...(clientUserMessageId ? { clientUserMessageId } : {}),
             ...(session.model ? { model: session.model } : {}),
+            ...(session.modelSettings?.reasoningEffort
+                ? { effort: session.modelSettings.reasoningEffort }
+                : {}),
         }));
         resource.turnThreads.set(result, session.threadId);
         return RelaySession.rehydrate(session).startTurn(result, now).snapshot;
@@ -236,7 +250,12 @@ export class CodexSessionRuntime {
             threadId: childThreadId,
             input: [{ type: 'text', text, text_elements: [] }],
             clientUserMessageId,
-            ...(session.model ? { model: session.model } : {}),
+            ...(session.modelSettings?.executorModel
+                ? { model: session.modelSettings.executorModel }
+                : {}),
+            ...(session.modelSettings?.executorReasoningEffort
+                ? { effort: session.modelSettings.executorReasoningEffort }
+                : {}),
         }));
         if (resource.turnThreads.has(result) || resource.turnThreads.size < 256)
             resource.turnThreads.set(result, childThreadId);
@@ -677,7 +696,7 @@ export class CodexSessionRuntime {
                 await resource.process.rpc.request('thread/resume', {
                     threadId: session.threadId,
                     cwd: session.workspacePath,
-                    ...threadSkillConfig(resource.skillsConfig),
+                    ...threadSkillConfig(resource.skillsConfig, resource.modelConfig),
                     ...(session.executionPolicy?.approvalPolicy
                         ? { approvalPolicy: session.executionPolicy.approvalPolicy }
                         : {}),
@@ -699,7 +718,7 @@ export class CodexSessionRuntime {
             catch (error) {
                 if (!canRebindMissingRollout(session, error))
                     throw error;
-                const replacementThreadId = await this.startThread(resource.process, session, resource.skillsConfig);
+                const replacementThreadId = await this.startThread(resource.process, session, resource.skillsConfig, resource.modelConfig);
                 result = rebindMissingRollout(session, error, replacementThreadId, now);
             }
             resource.threadId = result.session.threadId;
@@ -767,13 +786,13 @@ export class CodexSessionRuntime {
                 reject(new Error('CODEX_SERVER_REQUEST_UNSUPPORTED'));
         });
     }
-    async startThread(process, session, skillsConfig) {
-        return decodeThreadStart(await process.rpc.request('thread/start', this.threadStartParams(session, skillsConfig)));
+    async startThread(process, session, skillsConfig, modelConfig = {}) {
+        return decodeThreadStart(await process.rpc.request('thread/start', this.threadStartParams(session, skillsConfig, modelConfig)));
     }
-    threadStartParams(session, skillsConfig) {
+    threadStartParams(session, skillsConfig, modelConfig = {}) {
         return {
             cwd: session.workspacePath,
-            ...threadSkillConfig(skillsConfig),
+            ...threadSkillConfig(skillsConfig, modelConfig),
             approvalPolicy: session.executionPolicy?.approvalPolicy ?? 'on-request',
             dynamicTools: [
                 gestaltQuizDynamicTool,
@@ -801,6 +820,7 @@ export class CodexSessionRuntime {
         try {
             const token = randomUUID();
             const skillsConfig = await this.resolveSkills?.(session);
+            const modelConfig = (await this.resolveModelConfig?.(session)) ?? {};
             const process = this.launch({
                 profile: session.profile,
                 cwd: session.workspacePath,
@@ -820,7 +840,7 @@ export class CodexSessionRuntime {
                     }
                     : {}),
             });
-            const resource = new SessionResource(session.id, process, skillsConfig, lease, token, [], () => {
+            const resource = new SessionResource(session.id, process, skillsConfig, modelConfig, lease, token, [], () => {
                 if (this.sessions.get(session.id) === resource)
                     this.sessions.delete(session.id);
             });

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

@@ -94,6 +94,105 @@ export class FilesystemWorkspaceFiles {
                 : { kind: 'unreadable' };
         }
     }
+    async exists(rootPath, requestedPath) {
+        const root = await this.canonicalDirectory(rootPath);
+        if (!root)
+            return false;
+        const target = resolve(root, requestedPath);
+        if (!within(root, target))
+            return false;
+        const path = relative(root, target).split(sep).join('/');
+        if (path !== '' && !validRelative(path))
+            return false;
+        const parent = await anchoredDirectory(root, dirnameRelative(path));
+        if (!parent)
+            return false;
+        try {
+            if (!(await stableAnchor(root, dirnameRelative(path), parent.path)))
+                return false;
+            const handle = await open(path ? join(parent.path, basename(path)) : `${parent.path}/.`, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            try {
+                const metadata = await handle.stat();
+                return ((metadata.isFile() || metadata.isDirectory()) &&
+                    within(root, await realpath(procPath(handle.fd))));
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch {
+            return false;
+        }
+        finally {
+            await parent.close();
+        }
+    }
+    async read(rootPath, requestedPath) {
+        const root = await this.canonicalDirectory(rootPath);
+        if (!root)
+            return { kind: 'unreadable' };
+        const target = resolve(root, requestedPath);
+        if (!within(root, target))
+            return { kind: 'unreadable' };
+        const path = relative(root, target).split(sep).join('/');
+        if (path !== '' && !validRelative(path))
+            return { kind: 'unreadable' };
+        const parentPath = dirnameRelative(path);
+        const parent = await anchoredDirectory(root, parentPath);
+        if (!parent)
+            return { kind: 'unreadable' };
+        try {
+            if (!(await stableAnchor(root, parentPath, parent.path)))
+                return { kind: 'unreadable' };
+            const handle = await open(path ? join(parent.path, basename(path)) : `${parent.path}/.`, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            try {
+                const metadata = await handle.stat();
+                if (!within(root, await realpath(procPath(handle.fd))))
+                    return { kind: 'unreadable' };
+                if (metadata.isDirectory())
+                    return { kind: 'available', preview: { kind: 'directory', path } };
+                if (!metadata.isFile())
+                    return { kind: 'unsupported' };
+                const limit = 1024 * 1024;
+                if (metadata.size > limit)
+                    return { kind: 'too-large' };
+                const buffer = Buffer.alloc(limit + 1);
+                let size = 0;
+                while (size < buffer.length) {
+                    const read = await handle.read(buffer, size, buffer.length - size, size);
+                    if (!read.bytesRead)
+                        break;
+                    size += read.bytesRead;
+                }
+                if (size > limit)
+                    return { kind: 'too-large' };
+                if (!(await stableAnchor(root, parentPath, parent.path)) ||
+                    !within(root, await realpath(procPath(handle.fd))))
+                    return { kind: 'unreadable' };
+                const bytes = buffer.subarray(0, size);
+                if (bytes.includes(0))
+                    return { kind: 'unsupported' };
+                try {
+                    const content = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+                    return { kind: 'available', preview: { kind: 'file', path, content, size } };
+                }
+                catch {
+                    return { kind: 'unsupported' };
+                }
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch (error) {
+            return {
+                kind: error.code === 'ENOENT' ? 'missing' : 'unreadable',
+            };
+        }
+        finally {
+            await parent.close();
+        }
+    }
     async copy(rootPath, input) {
         return this.transfer(rootPath, input, false);
     }

package/dist/server/server/platform/persistence/filesystem-session-defaults.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 { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { sessionDefaultsSchema, } from '../../../shared/contracts/session-defaults.js';
+export class FilesystemSessionDefaults {
+    directory;
+    path;
+    constructor(homeDirectory) {
+        this.directory = join(homeDirectory, '.gestalt');
+        this.path = join(this.directory, 'session-defaults.json');
+    }
+    async read() {
+        try {
+            return sessionDefaultsSchema.parse(JSON.parse(await readFile(this.path, 'utf8')));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    }
+    async save(defaults) {
+        const validated = sessionDefaultsSchema.parse(defaults);
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const temporary = `${this.path}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, `${JSON.stringify(validated, null, 2)}\n`, {
+                mode: 0o600,
+                flag: 'wx',
+            });
+            await rename(temporary, this.path);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }
+}

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

@@ -34,6 +34,8 @@ export function migrate(database) {
         database.exec('ALTER TABLE relay_sessions ADD COLUMN effective_skill_selection_json TEXT');
     if (!columns.some((column) => column.name === 'last_org_plan_json'))
         database.exec('ALTER TABLE relay_sessions ADD COLUMN last_org_plan_json TEXT');
+    if (!columns.some((column) => column.name === 'model_settings_json'))
+        database.exec('ALTER TABLE relay_sessions ADD COLUMN model_settings_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'))

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

@@ -11,10 +11,10 @@ export class SqliteSessionRepository {
     }
     save(session) {
         this.db
-            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,provider,profile,model,branch,sandbox,approval_policy,thread_id,state,desired_state,active_turn_id,protocol_version,attention_tool_capability,failure_count,effective_skill_selection_json,last_org_plan_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,provider=excluded.provider,profile=excluded.profile,model=excluded.model,branch=excluded.branch,sandbox=excluded.sandbox,approval_policy=excluded.approval_policy,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,attention_tool_capability=excluded.attention_tool_capability,failure_count=excluded.failure_count,effective_skill_selection_json=excluded.effective_skill_selection_json,last_org_plan_json=excluded.last_org_plan_json,updated_at=excluded.updated_at')
+            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,provider,profile,model,branch,sandbox,approval_policy,thread_id,state,desired_state,active_turn_id,protocol_version,attention_tool_capability,failure_count,effective_skill_selection_json,last_org_plan_json,model_settings_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,provider=excluded.provider,profile=excluded.profile,model=excluded.model,branch=excluded.branch,sandbox=excluded.sandbox,approval_policy=excluded.approval_policy,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,attention_tool_capability=excluded.attention_tool_capability,failure_count=excluded.failure_count,effective_skill_selection_json=excluded.effective_skill_selection_json,last_org_plan_json=excluded.last_org_plan_json,model_settings_json=excluded.model_settings_json,updated_at=excluded.updated_at')
             .run(session.id, session.workspaceId, session.workspacePath, session.provider, session.profile, session.model ?? null, session.branch ?? null, session.executionPolicy?.sandbox ?? null, session.executionPolicy?.approvalPolicy ?? null, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.attentionToolCapability ?? null, session.failureCount, session.effectiveSkillSelection === undefined
             ? null
-            : JSON.stringify(session.effectiveSkillSelection), session.lastOrgPlan === undefined ? null : JSON.stringify(session.lastOrgPlan), session.createdAt, session.updatedAt);
+            : JSON.stringify(session.effectiveSkillSelection), session.lastOrgPlan === undefined ? null : JSON.stringify(session.lastOrgPlan), session.modelSettings === undefined ? null : JSON.stringify(session.modelSettings), session.createdAt, session.updatedAt);
     }
     find(id) {
         const row = this.db.prepare('SELECT * FROM relay_sessions WHERE id = ?').get(id);
@@ -48,6 +48,11 @@ function map(row) {
         provider: row.provider === 'kimi' ? 'kimi' : 'codex',
         profile: row.profile,
         ...(row.model === null ? {} : { model: row.model }),
+        ...(row.model_settings_json
+            ? {
+                modelSettings: JSON.parse(row.model_settings_json),
+            }
+            : {}),
         ...(row.branch === null ? {} : { branch: row.branch }),
         ...(executionPolicy === undefined ? {} : { executionPolicy }),
         threadId: row.thread_id,

package/dist/server/server/platform/plans/filesystem-plan-archiver.js

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { constants } from 'node:fs';
+import { lstat, open, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { archiveOrgPlan } from './org-plan-archive-tag.js';
+/** Adds a standard Org file tag without moving the plan or changing its tasks. */
+export class FilesystemPlanArchiver {
+    beforePublish;
+    pending = new Map();
+    constructor(beforePublish = async () => { }) {
+        this.beforePublish = beforePublish;
+    }
+    async archive(workspacePath, planName) {
+        if (!isAbsolute(workspacePath) || !validPlanName(planName))
+            return { kind: 'missing' };
+        const key = `${workspacePath}\0${planName}`;
+        const active = this.pending.get(key);
+        if (active)
+            return active;
+        const request = this.write(workspacePath, planName).finally(() => this.pending.delete(key));
+        this.pending.set(key, request);
+        return request;
+    }
+    async write(workspacePath, planName) {
+        try {
+            const workspace = await realpath(workspacePath);
+            const path = resolve(workspace, ...planName.split('/'));
+            if ((await realpath(path)) !== path)
+                return { kind: 'unavailable' };
+            const parentPath = dirname(path);
+            const parent = await open(parentPath, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+            try {
+                // Anchor publishing to the checked directory, even if a parent is renamed.
+                const anchor = `/proc/self/fd/${parent.fd}`;
+                if ((await realpath(anchor)) !== parentPath)
+                    return { kind: 'unavailable' };
+                const target = join(anchor, basename(path));
+                const file = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+                let metadata;
+                let source;
+                try {
+                    metadata = await file.stat();
+                    if (!metadata.isFile() || metadata.size > 1_048_576)
+                        return { kind: 'unavailable' };
+                    source = await file.readFile('utf8');
+                    if (!sameFile(metadata, await file.stat()))
+                        return { kind: 'conflict' };
+                }
+                finally {
+                    await file.close();
+                }
+                const content = archiveOrgPlan(source);
+                if (content === source)
+                    return { kind: 'archived' };
+                const temporary = join(anchor, `.${randomUUID()}.archive`);
+                try {
+                    await writeFile(temporary, content, { flag: 'wx', mode: metadata.mode & 0o777 });
+                    await this.beforePublish();
+                    if ((await realpath(parentPath)) !== parentPath ||
+                        (await realpath(anchor)) !== parentPath ||
+                        !within(workspace, await realpath(anchor)))
+                        return { kind: 'unavailable' };
+                    if (!sameFile(metadata, await lstat(target)))
+                        return { kind: 'conflict' };
+                    await rename(temporary, target);
+                }
+                finally {
+                    await rm(temporary, { force: true });
+                }
+                return { kind: 'archived' };
+            }
+            finally {
+                await parent.close();
+            }
+        }
+        catch (error) {
+            return {
+                kind: error.code === 'ENOENT' ? 'missing' : 'unavailable',
+            };
+        }
+    }
+}
+function sameFile(before, after) {
+    return (after.isFile() &&
+        !after.isSymbolicLink() &&
+        before.dev === after.dev &&
+        before.ino === after.ino &&
+        before.size === after.size &&
+        before.mtimeMs === after.mtimeMs &&
+        before.ctimeMs === after.ctimeMs);
+}
+function within(root, path) {
+    const name = relative(root, path);
+    return name === '' || (!isAbsolute(name) && name !== '..' && !name.startsWith(`..${sep}`));
+}
+function validPlanName(name) {
+    const parts = name.split('/');
+    return (name.endsWith('.org') &&
+        !isAbsolute(name) &&
+        !name.includes('\\') &&
+        !name.includes('\0') &&
+        parts.slice(0, -1).includes('.gestalt') &&
+        parts.every((part) => part !== '' && part !== '.' && part !== '..' && part !== '.git'));
+}

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

@@ -3,44 +3,112 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { lstat, readdir, readFile, realpath, stat } from 'node:fs/promises';
-import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { lstat, readFile, realpath, stat } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { parseSupervisedPlan } from '../../features/plans/application/parse-supervised-plan.js';
+import { OrgPlanDiscovery } from './org-plan-discovery.js';
+import { isArchivedOrgPlan } from './org-plan-archive-tag.js';
 const maximumBytes = 1_048_576;
-/**
- * Passive access to every regular `.org` file below a workspace. Symlinks are
- * never followed. Supported supervised plans include a browser preview; other
- * Org files remain visible in the catalog without one.
- */
+/** Cached `.gestalt` Org discovery, with bounded parallel metadata checks. */
 export class FilesystemWorkspacePlanCatalog {
     filesystem;
-    constructor(filesystem = { lstat, readdir, readFile, realpath, stat }) {
+    discovery;
+    now;
+    caches = new Map();
+    constructor(filesystem = { lstat, readFile, realpath, stat }, discovery = new OrgPlanDiscovery(), now = Date.now) {
         this.filesystem = filesystem;
+        this.discovery = discovery;
+        this.now = now;
     }
-    async list(workspacePath) {
+    async list(workspacePath, refresh = false) {
         const workspace = await this.workspace(workspacePath);
         if (!workspace)
             return [];
-        const planNames = await this.discover(workspace);
-        const entries = [];
-        for (const planName of planNames) {
-            const candidate = await this.readCandidate(workspace, planName);
-            if (candidate.kind === 'missing')
-                continue;
-            if (candidate.kind === 'unavailable') {
-                entries.push(toFallbackEntry(planName));
-                continue;
-            }
-            const parsed = parseSupervisedPlan({
-                source: candidate.source,
-                planPath: candidate.canonicalPath,
-                workspacePath: workspace,
-            });
-            entries.push(parsed.kind === 'available'
-                ? toEntry(planName, parsed.plan)
-                : toFallbackEntry(planName, candidate.source));
+        let cache = this.caches.get(workspace);
+        if (!cache) {
+            cache = { entries: null, files: new Map(), refreshedAt: 0, request: null };
+            this.caches.set(workspace, cache);
         }
-        return entries;
+        if (cache.request)
+            return cache.request;
+        if (!refresh && cache.entries && this.now() - cache.refreshedAt < 1_000)
+            return cache.entries;
+        const current = cache;
+        current.request = this.refresh(workspace, current).finally(() => {
+            current.request = null;
+        });
+        return current.request;
+    }
+    async refresh(workspace, cache) {
+        const planNames = [...new Set(await this.discovery.list(workspace))]
+            .filter((name) => isPlanPath(name) && name.split('/').slice(0, -1).includes('.gestalt'))
+            .sort((left, right) => left.localeCompare(right));
+        const entries = new Array(planNames.length).fill(null);
+        const files = new Map();
+        let next = 0;
+        await Promise.all(Array.from({ length: Math.min(8, planNames.length) }, async () => {
+            while (next < planNames.length) {
+                const index = next++;
+                const name = planNames[index];
+                let signature;
+                try {
+                    const metadata = await this.filesystem.lstat(resolve(workspace, ...name.split('/')));
+                    if (!metadata.isFile() || metadata.isSymbolicLink())
+                        continue;
+                    signature = [
+                        metadata.dev,
+                        metadata.ino,
+                        metadata.size,
+                        metadata.mtimeMs,
+                        metadata.ctimeMs,
+                    ].join(':');
+                }
+                catch {
+                    continue;
+                }
+                const previous = cache.files.get(name);
+                if (previous?.signature === signature) {
+                    try {
+                        const canonical = await this.filesystem.realpath(resolve(workspace, ...name.split('/')));
+                        if (!isWithin(workspace, canonical) ||
+                            toPlanName(relative(workspace, canonical)) !== name)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    entries[index] = previous.entry;
+                    files.set(name, previous);
+                    continue;
+                }
+                const candidate = await this.readCandidate(workspace, name);
+                if (candidate.kind === 'missing')
+                    continue;
+                let entry;
+                if (candidate.kind === 'unavailable') {
+                    entry = toFallbackEntry(name);
+                }
+                else {
+                    const parsed = parseSupervisedPlan({
+                        source: candidate.source,
+                        planPath: candidate.canonicalPath,
+                        workspacePath: workspace,
+                    });
+                    entry =
+                        parsed.kind === 'available'
+                            ? toEntry(name, parsed.plan)
+                            : toFallbackEntry(name, candidate.source);
+                    if (isArchivedOrgPlan(candidate.source))
+                        entry = { ...entry, archived: true };
+                    files.set(name, { signature, entry });
+                }
+                entries[index] = entry;
+            }
+        }));
+        cache.files = files;
+        cache.entries = entries.filter((entry) => entry !== null);
+        cache.refreshedAt = this.now();
+        return cache.entries;
     }
     async read(workspacePath, planName) {
         if (!isPlanPath(planName))
@@ -62,46 +130,6 @@ export class FilesystemWorkspacePlanCatalog {
             return null;
         }
     }
-    async discover(workspace) {
-        const pending = [workspace];
-        const visited = new Set();
-        const plans = [];
-        while (pending.length > 0) {
-            const directory = pending.pop();
-            try {
-                const before = await this.filesystem.lstat(directory);
-                if (!before.isDirectory() || before.isSymbolicLink())
-                    continue;
-                const canonical = await this.filesystem.realpath(directory);
-                if (!isWithin(workspace, canonical))
-                    continue;
-                const metadata = await this.filesystem.stat(canonical);
-                if (!metadata.isDirectory() || visited.has(canonical))
-                    continue;
-                visited.add(canonical);
-                const children = await this.filesystem.readdir(canonical, {
-                    encoding: 'utf8',
-                    withFileTypes: true,
-                });
-                for (const child of children) {
-                    if (child.isSymbolicLink())
-                        continue;
-                    const childPath = join(canonical, child.name);
-                    if (child.isDirectory())
-                        pending.push(childPath);
-                    else if (child.isFile() && isPlanFilename(child.name)) {
-                        const planName = toPlanName(relative(workspace, childPath));
-                        if (isPlanPath(planName))
-                            plans.push(planName);
-                    }
-                }
-            }
-            catch {
-                // A disappearing or unreadable branch does not hide plans elsewhere.
-            }
-        }
-        return plans.sort((left, right) => left.localeCompare(right));
-    }
     async readFromWorkspace(workspace, planName) {
         const candidate = await this.readCandidate(workspace, planName);
         if (candidate.kind !== 'readable')

package/dist/server/server/platform/plans/org-plan-archive-tag.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function isArchivedOrgPlan(source) {
+    return [...source.matchAll(/^#\+FILETAGS:[ \t]*(.*)$/gim)].some((match) => match[1].split(/[:\s]+/).some((tag) => tag.toUpperCase() === 'ARCHIVE'));
+}
+export function archiveOrgPlan(source) {
+    if (isArchivedOrgPlan(source))
+        return source;
+    const existing = /^(#\+FILETAGS:[ \t]*)([^\r\n]*)(\r?)$/im;
+    if (existing.test(source))
+        return source.replace(existing, (_line, prefix, tags, carriage) => `${prefix}${tags.trimEnd()}${tags.trimEnd().endsWith(':') ? '' : ':'}ARCHIVE:${carriage}`);
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    return `#+FILETAGS: :ARCHIVE:${newline}${source}`;
+}