gestalt-mobile 0.8.0 → 0.10.0

package/dist/server/server/features/sessions/get-history/endpoint.js

@@ -9,7 +9,29 @@ export function registerGetHistory(app, deps) {
         const session = deps.find(request.params.id);
         if (!session)
             return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
-        const history = await deps.read(session);
+        let history;
+        try {
+            history = await deps.read(session);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'CODEX_SESSION_NOT_RUNNING')
+                return reply.code(409).type('application/problem+json').send({
+                    type: 'urn:gestalt-mobile:error:session-history-unavailable',
+                    title: 'Session history unavailable',
+                    status: 409,
+                    detail: 'GET /api/sessions/:id/history requires an active Codex session process. Open the session to restore it, then retry.',
+                    code: 'SESSION_HISTORY_UNAVAILABLE',
+                    retryable: true,
+                });
+            return reply.code(502).type('application/problem+json').send({
+                type: 'urn:gestalt-mobile:error:session-history-read-failed',
+                title: 'Session history read failed',
+                status: 502,
+                detail: 'GET /api/sessions/:id/history reached the relay, but Codex could not read this session history. The Codex process may have stopped during recovery; open the session again and inspect the running relay output if it persists.',
+                code: 'SESSION_HISTORY_READ_FAILED',
+                retryable: true,
+            });
+        }
         const items = toChatItems(history.turns);
         return reply.send({
             items,

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

@@ -7,11 +7,17 @@ import { buildResumeCommand } from '../application/resume-command.js';
 export function registerListRecentThreads(app, deps) {
     app.get('/api/sessions/recent-threads', async () => {
         const threads = await deps.list();
-        return threads.map(({ id, cwd, profile, recencyAt }) => ({
-            id,
-            cwd,
-            recencyAt,
-            resumeCommand: buildResumeCommand({ profile, threadId: id, workspacePath: cwd }),
-        }));
+        return threads.map(({ id, cwd, profile, recencyAt }) => {
+            const metadata = deps.metadata?.(id);
+            return {
+                id,
+                cwd,
+                recencyAt,
+                ...(metadata?.model === undefined ? {} : { model: metadata.model }),
+                ...(metadata?.skillProfile === undefined ? {} : { skillProfile: metadata.skillProfile }),
+                ...(metadata?.orgPlanFilename === undefined ? {} : { orgPlanFilename: metadata.orgPlanFilename }),
+                resumeCommand: buildResumeCommand({ profile, threadId: id, workspacePath: cwd }),
+            };
+        });
     });
 }

package/dist/server/server/features/sessions/restore-session/endpoint.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { idempotencyKey } from '../../../platform/http/idempotency.js';
+import { RelaySession } from '../model/relay-session.js';
 import { canRestore } from './use-case.js';
 export function registerRestoreSession(app, deps) {
     app.post('/api/sessions/:id/restore', async (request, reply) => {
@@ -18,10 +19,29 @@ export function registerRestoreSession(app, deps) {
             return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
         if (!canRestore(session))
             return reply.code(409).send({ code: 'SESSION_CANNOT_RESTORE' });
-        const restored = await deps.restore(session);
-        deps.save(restored);
+        const recovering = RelaySession.rehydrate(session).beginRecovery(new Date().toISOString()).snapshot;
+        deps.save(recovering);
+        let restored;
+        try {
+            restored = await deps.restore(session);
+        }
+        catch {
+            // The pre-I/O recovery marker must never strand a saved session: keep
+            // its original thread and inactive state available for a later Open.
+            deps.save(session);
+            return reply.code(502).send({ code: 'RESTORE_FAILED' });
+        }
+        const response = 'session' in restored
+            ? {
+                ...restored.session,
+                ...(restored.replacementCreated
+                    ? { recovery: { historyUnavailable: true, replacementCreated: true } }
+                    : {}),
+            }
+            : restored;
+        deps.save(response);
         if (key)
-            deps.idempotency?.put(scope, key, 200, JSON.stringify(restored));
-        return reply.send(restored);
+            deps.idempotency?.put(scope, key, 200, JSON.stringify(response));
+        return reply.send(response);
     });
 }

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

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { RelaySession } from '../model/relay-session.js';
+import { threadId } from '../model/value-objects.js';
+import { isMissingCodexThreadRollout } from '../../../platform/codex/json-rpc-client.js';
 export function canRestore(session) {
     return (session.threadId !== null &&
         (session.state === 'stopped' ||
@@ -15,3 +17,21 @@ export function restore(session, now) {
         throw new Error('SESSION_CANNOT_RESTORE');
     return RelaySession.rehydrate(session).beginRecovery(now).restore(now).snapshot;
 }
+/**
+ * The runtime may replace a thread only after a failed resume is confirmed to
+ * be the historical-rollout case.  This pure policy leaves persistence to the
+ * caller, so the original thread remains durable until thread/start succeeds.
+ */
+export function canRebindMissingRollout(session, error) {
+    return canRestore(session) && isMissingCodexThreadRollout(error);
+}
+export function rebindMissingRollout(session, error, replacementThreadId, now) {
+    if (!canRebindMissingRollout(session, error))
+        throw new Error('CODEX_ROLLOUT_REBIND_NOT_ALLOWED');
+    threadId(replacementThreadId);
+    return {
+        session: RelaySession.rehydrate(session).bindThread(replacementThreadId, now).snapshot,
+        historyUnavailable: true,
+        replacementCreated: true,
+    };
+}

package/dist/server/server/features/sessions/start-turn/endpoint.js

@@ -15,6 +15,7 @@ export function registerStartTurn(app, deps) {
             return reply.code(409).send({ code: 'SESSION_NOT_READY' });
         const started = await deps.start(session, text);
         deps.save(started);
+        deps.onStarted?.(started);
         return reply.code(202).send(started);
     });
 }

package/dist/server/server/platform/codex/json-rpc-client.js

@@ -4,6 +4,38 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { createInterface } from 'node:readline';
+export const CODEX_THREAD_NOT_FOUND = 'CODEX_THREAD_NOT_FOUND';
+export const CODEX_JSON_RPC_ERROR = 'CODEX_JSON_RPC_ERROR';
+/** A bounded representation of an app-server JSON-RPC failure. */
+export class CodexJsonRpcError extends Error {
+    code;
+    kind;
+    constructor(code, message, kind = classifyCodexJsonRpcError(code, message)) {
+        super(boundMessage(message));
+        this.code = code;
+        this.kind = kind;
+        this.name = 'CodexJsonRpcError';
+    }
+}
+/**
+ * Codex 0.146 reports a rollout removed by an upgrade as -32600.  Keep the
+ * message match deliberately narrow: other invalid-request responses must not
+ * be treated as permission to replace a durable thread.
+ */
+export function isMissingCodexThreadRollout(error) {
+    return error instanceof CodexJsonRpcError && error.kind === CODEX_THREAD_NOT_FOUND;
+}
+function classifyCodexJsonRpcError(code, message) {
+    return code === -32600 && /^no rollout found for thread id\b/i.test(message)
+        ? CODEX_THREAD_NOT_FOUND
+        : CODEX_JSON_RPC_ERROR;
+}
+function boundMessage(message) {
+    return message
+        .replace(/((?:authorization|token|api[_ -]?key|password)\s*[:=]\s*)\S+/gi, '$1[REDACTED]')
+        .replace(/(authentication failed:\s*).*/i, '$1[REDACTED]')
+        .slice(0, 256);
+}
 export class JsonRpcClient {
     output;
     sequence = 0;
@@ -59,8 +91,10 @@ export class JsonRpcClient {
             if (!pending)
                 return;
             this.pending.delete(message.id);
-            if (message.error)
-                pending.reject(message.error);
+            if (message.error) {
+                const error = message.error;
+                pending.reject(new CodexJsonRpcError(typeof error.code === 'number' ? error.code : undefined, typeof error.message === 'string' ? error.message : 'JSON_RPC_ERROR'));
+            }
             else
                 pending.resolve(message.result);
         }

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

@@ -6,6 +6,7 @@
 import { RelaySession, } from '../../features/sessions/model/relay-session.js';
 import { randomUUID } from 'node:crypto';
 import { createPlanMeasurementSnapshot, } from '../../features/plans/application/measurement-snapshot.js';
+import { canRebindMissingRollout, rebindMissingRollout, } from '../../features/sessions/restore-session/use-case.js';
 import { gestaltQuizDynamicTool } from '../../../shared/contracts/quiz.js';
 export class CodexSessionRuntime {
     launch;
@@ -43,22 +44,13 @@ export class CodexSessionRuntime {
                 clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
                 capabilities: { experimentalApi: true },
             });
-            const result = (await process.rpc.request('thread/start', {
-                cwd: session.workspacePath,
-                approvalPolicy: settings.approvalPolicy ?? 'on-request',
-                dynamicTools: [gestaltQuizDynamicTool],
-                ...(settings.model ? { model: settings.model } : {}),
-                ...(settings.sandbox ? { sandbox: settings.sandbox } : {}),
-            }));
-            if (!result.thread?.id)
-                throw new Error('CODEX_THREAD_ID_MISSING');
+            const startedThreadId = await this.startThread(process, session, settings);
             this.processes.set(session.id, process);
-            this.threadIds.set(session.id, result.thread.id);
-            return RelaySession.rehydrate(session).bindThread(result.thread.id, now).snapshot;
+            this.threadIds.set(session.id, startedThreadId);
+            return RelaySession.rehydrate(session).bindThread(startedThreadId, now).snapshot;
         }
         catch (error) {
-            process.close();
-            this.releasePlanStatus(session.id);
+            this.discardProcess(session.id, process);
             throw error;
         }
     }
@@ -68,6 +60,8 @@ export class CodexSessionRuntime {
         this.processes.get(sessionId)?.close();
         this.processes.delete(sessionId);
         this.threadIds.delete(sessionId);
+        this.clearPendingRequests(sessionId);
+        this.planMeasurementTokens.delete(sessionId);
         this.releasePlanStatus(sessionId);
     }
     async release(sessionId) {
@@ -156,6 +150,9 @@ export class CodexSessionRuntime {
         };
     }
     async restore(session, now) {
+        return (await this.restoreWithOutcome(session, now)).session;
+    }
+    async restoreWithOutcome(session, now) {
         if (!session.threadId)
             throw new Error('CODEX_THREAD_ID_MISSING');
         const process = await this.launchForSession(session);
@@ -167,18 +164,31 @@ export class CodexSessionRuntime {
                 clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
                 capabilities: { experimentalApi: true },
             });
-            await process.rpc.request('thread/resume', {
-                threadId: session.threadId,
-                cwd: session.workspacePath,
-                dynamicTools: [gestaltQuizDynamicTool],
-            });
+            let result;
+            try {
+                await process.rpc.request('thread/resume', {
+                    threadId: session.threadId,
+                    cwd: session.workspacePath,
+                    dynamicTools: [gestaltQuizDynamicTool],
+                });
+                result = {
+                    session: RelaySession.rehydrate(session).restore(now).snapshot,
+                    historyUnavailable: false,
+                    replacementCreated: false,
+                };
+            }
+            catch (error) {
+                if (!canRebindMissingRollout(session, error))
+                    throw error;
+                const replacementThreadId = await this.startThread(process, session, { model: session.model });
+                result = rebindMissingRollout(session, error, replacementThreadId, now);
+            }
             this.processes.set(session.id, process);
-            this.threadIds.set(session.id, session.threadId);
-            return RelaySession.rehydrate(session).restore(now).snapshot;
+            this.threadIds.set(session.id, result.session.threadId);
+            return result;
         }
         catch (error) {
-            process.close();
-            this.releasePlanStatus(session.id);
+            this.discardProcess(session.id, process);
             throw error;
         }
     }
@@ -192,12 +202,44 @@ export class CodexSessionRuntime {
         this.exitUnsubscribers.set(sessionId, process.onExit?.(() => {
             this.processes.delete(sessionId);
             this.threadIds.delete(sessionId);
+            this.clearPendingRequests(sessionId);
             this.planMeasurementTokens.delete(sessionId);
             this.exitUnsubscribers.delete(sessionId);
             this.releasePlanStatus(sessionId);
             this.onProcessExit?.(sessionId);
         }) ?? (() => { }));
     }
+    async startThread(process, session, settings = {}) {
+        const result = (await process.rpc.request('thread/start', this.threadStartParams(session, settings)));
+        if (typeof result.thread?.id !== 'string' || !result.thread.id) {
+            throw new Error('CODEX_THREAD_ID_MISSING');
+        }
+        return result.thread.id;
+    }
+    threadStartParams(session, settings) {
+        return {
+            cwd: session.workspacePath,
+            approvalPolicy: settings.approvalPolicy ?? 'on-request',
+            dynamicTools: [gestaltQuizDynamicTool],
+            ...(settings.model ? { model: settings.model } : {}),
+            ...(settings.sandbox ? { sandbox: settings.sandbox } : {}),
+        };
+    }
+    discardProcess(sessionId, process) {
+        this.exitUnsubscribers.get(sessionId)?.();
+        this.exitUnsubscribers.delete(sessionId);
+        process.close();
+        this.clearPendingRequests(sessionId);
+        this.planMeasurementTokens.delete(sessionId);
+        this.releasePlanStatus(sessionId);
+    }
+    clearPendingRequests(sessionId) {
+        const prefix = `${sessionId}:`;
+        for (const key of this.pendingRequests.keys()) {
+            if (key.startsWith(prefix))
+                this.pendingRequests.delete(key);
+        }
+    }
     async launchForSession(session) {
         const lease = this.planStatusSource
             ? await this.planStatusSource.open({ id: session.id, workspacePath: session.workspacePath }, (update) => this.onPlanStatus?.(session.id, update))

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

@@ -3,12 +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, 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));`;
+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, last_org_plan_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 === 'last_org_plan_json'))
+        database.exec('ALTER TABLE relay_sessions ADD COLUMN last_org_plan_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,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')
+            .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,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,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,last_org_plan_json=excluded.last_org_plan_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);
+            : JSON.stringify(session.effectiveSkillSelection), session.lastOrgPlan === undefined ? null : JSON.stringify(session.lastOrgPlan), session.createdAt, session.updatedAt);
     }
     find(id) {
         const row = this.db.prepare('SELECT * FROM relay_sessions WHERE id = ?').get(id);
@@ -31,6 +31,9 @@ function map(row) {
     const effectiveSkillSelection = row.effective_skill_selection_json
         ? createEffectiveSkillSelection(JSON.parse(row.effective_skill_selection_json))
         : undefined;
+    const lastOrgPlan = row.last_org_plan_json
+        ? JSON.parse(row.last_org_plan_json)
+        : undefined;
     return {
         id: row.id,
         workspaceId: row.workspace_id,
@@ -45,6 +48,7 @@ function map(row) {
         protocolVersion: row.protocol_version,
         failureCount: row.failure_count,
         ...(effectiveSkillSelection === undefined ? {} : { effectiveSkillSelection }),
+        ...(lastOrgPlan === undefined ? {} : { lastOrgPlan }),
         pendingInteractions: [],
         createdAt: row.created_at,
         updatedAt: row.updated_at,

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

@@ -5,6 +5,7 @@
  */
 import { chmod, mkdir, readFile, readdir, rename, rm, stat, watch, writeFile, realpath, } from 'node:fs/promises';
 import { createHash, randomUUID } from 'node:crypto';
+import { isPlanSignalReason } from '../../../shared/contracts/plan-signal.js';
 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';
@@ -298,9 +299,6 @@ function parseSignal(source) {
         return null;
     }
 }
-function isPlanSignalReason(value) {
-    return value === 'authoring-start' || value === 'work-start' || value === 'checkpoint' || value === 'update';
-}
 function isRfc3339Utc(value) {
     return (typeof value === 'string' &&
         /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(value) &&

package/dist/server/server/platform/plans/plan-measurement-refresh.js

@@ -38,6 +38,10 @@ export class PlanMeasurementRefresh {
         for (const sessionId of this.active.keys())
             this.stop(sessionId);
     }
+    refreshNow(sessionId) {
+        this.clearTimer(sessionId);
+        void this.refresh(sessionId);
+    }
     schedule(sessionId) {
         this.timers.set(sessionId, setTimeout(() => {
             this.timers.delete(sessionId);

package/dist/server/shared/contracts/plan-signal.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
+ */
+/** Every reason published by the bundled org-plan helper. */
+export const planSignalReasons = [
+    'authoring-start',
+    'work-start',
+    'checkpoint',
+    'update',
+    'supervision-start',
+    'resync',
+];
+export function isPlanSignalReason(value) {
+    return typeof value === 'string' && planSignalReasons.includes(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",
@@ -45,6 +45,7 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "test": "vitest run",
+    "test:open-profile-smoke": "tsx scripts/open-profile-smoke.ts",
     "test:watch": "vitest",
     "test:package": "node scripts/smoke-packed-cli.mjs",
     "test:e2e": "playwright test",