gestalt-mobile 0.5.0 → 0.6.0

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -67,6 +67,11 @@ export class RelaySession {
     bindThread(value, now) {
         return this.transition({ threadId: threadId(value), state: 'ready' }, 'ThreadBound', now);
     }
+    selectModel(value, now) {
+        if (this.value.state !== 'ready')
+            throw new DomainError('SESSION_NOT_READY');
+        return this.transition({ model: value }, 'ModelSelected', now);
+    }
     startTurn(value, now) {
         if (this.value.state === 'turnActive')
             throw new DomainError('SESSION_TURN_ACTIVE');

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

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

package/dist/server/server/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) });
+        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) });
+        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);
+    }
 }