npm - gestalt-mobile - Versions diffs - 0.16.3 → 0.16.4 - Mend

gestalt-mobile 0.16.3 → 0.16.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/client/index.html CHANGED Viewed

@@ -16,8 +16,8 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-DWHYFaoK.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BotpWcLh.css">
+    <script type="module" crossorigin src="/assets/index-bKzoif3G.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D9v-aHYI.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/composition.js CHANGED Viewed

@@ -162,7 +162,7 @@ export async function composeRelayApp(options) {
                 }
                 events.publish(journal.append(sessionId, 'plan.updated', { plan: update.plan, reason: update.reason }, occurredAt));
             }
-        }, options.planMeasurementBaseUrl)
+        }, options.planMeasurementBaseUrl, 30_000, 64, root)
         : null;
     if (runtime && planMeasurementHelperPath) {
         planMeasurementRefresh = new PlanMeasurementRefresh(async (sessionId) => {
@@ -189,7 +189,14 @@ export async function composeRelayApp(options) {
             if (session)
                 saveSession(RelaySession.rehydrate(session).requireAttention(new Date().toISOString()).snapshot);
         });
-        recoverExitedSession = (sessionId) => supervisor.recover(sessionId);
+        // An exited child has released our writer.  Do not repeatedly resume a
+        // durable thread: another Codex client may acquire it between callbacks.
+        recoverExitedSession = (sessionId) => {
+            supervisor.cancel(sessionId);
+            const session = sessions.find(sessionId);
+            if (session)
+                saveSession(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+        };
     }
     let authorization;
     if (passkeyAuthEnabled) {
@@ -285,6 +292,10 @@ export async function composeRelayApp(options) {
                 startTurn: runtime
                     ? async (session, text, clientUserMessageId) => runtime.startTurn(session, text, clientUserMessageId, new Date().toISOString())
                     : undefined,
+                ensureWriter: runtime
+                    ? (session) => runtime.ensureWriter(session, new Date().toISOString())
+                    : undefined,
+                releaseWriter: runtime ? (id) => runtime.release(id) : undefined,
                 onTurnStarted: (session) => planMeasurementRefresh?.refreshNow(session.id),
                 models,
                 readHistory: runtime ? (session) => runtime.readHistory(session) : undefined,
@@ -301,7 +312,7 @@ export async function composeRelayApp(options) {
                         now: () => new Date().toISOString(),
                         list: () => sessions.list(),
                         save: saveSession,
-                        restore: (session) => runtime.restore(session, new Date().toISOString()),
+                        read: (session) => runtime.readHistory(session),
                     })
                     : undefined,
                 release: (session) => RelaySession.rehydrate(session).release(new Date().toISOString()).snapshot,
@@ -402,25 +413,18 @@ export async function composeRelayApp(options) {
         database.close();
         throw error;
     }
-    const restoreActiveSessions = async () => {
-        if (!runtime)
-            return;
-        await mapWithConcurrency(sessions
-            .list()
-            .filter((session) => session.desiredState === 'active' && session.threadId !== null), 2, async (session) => {
-            try {
-                saveSession(await runtime.restore(session, new Date().toISOString()));
-            }
-            catch {
-                saveSession(RelaySession.rehydrate(session).requireAttention(new Date().toISOString()).snapshot);
-            }
+    const detachActiveSessions = async () => {
+        await mapWithConcurrency(sessions.list().filter((session) => session.threadId !== null), 2, async (session) => {
+            if (session.desiredState === 'active')
+                saveSession(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+            await runtime?.watchPlanStatus(session);
         });
     };
     app.addHook('onListen', async () => {
         const profile = (await options.profiles.list()).find((item) => item.state === 'ok')?.name;
         if (profile)
             await editorSkillCatalog.refresh(profile, root);
-        await restoreActiveSessions();
+        await detachActiveSessions();
     });
     app.addHook('onClose', async () => {
         planMeasurementRefresh?.stopAll();

package/dist/server/server/features/sessions/application/writer-acquisition.js ADDED Viewed

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class WriterAcquisitionError extends Error {
+    kind;
+    constructor(kind) {
+        super(kind);
+        this.kind = kind;
+        this.name = 'WriterAcquisitionError';
+    }
+}
+export function writerAcquisitionProblem(kind) {
+    switch (kind) {
+        case 'writerBusy':
+            return {
+                status: 409,
+                code: 'SESSION_WRITER_BUSY',
+                retryable: true,
+                detail: 'This thread is active in another Codex client. Release it there, then retry.',
+            };
+        case 'rolloutMissing':
+            return {
+                status: 409,
+                code: 'SESSION_ROLLOUT_MISSING',
+                retryable: false,
+                detail: 'This stored thread is no longer available.',
+            };
+        case 'workspaceUnavailable':
+            return {
+                status: 409,
+                code: 'SESSION_WORKSPACE_UNAVAILABLE',
+                retryable: true,
+                detail: 'The session workspace is unavailable.',
+            };
+        case 'runtimeDependencyFailed':
+            return {
+                status: 502,
+                code: 'SESSION_RUNTIME_DEPENDENCY_FAILED',
+                retryable: true,
+                detail: 'A required Codex runtime dependency is unavailable.',
+            };
+        case 'protocolIncompatible':
+            return {
+                status: 503,
+                code: 'CODEX_PROTOCOL_INCOMPATIBLE',
+                retryable: false,
+                detail: 'The installed Codex runtime is incompatible with this relay.',
+            };
+        case 'runtimeUnavailable':
+            return {
+                status: 503,
+                code: 'SESSION_RUNTIME_UNAVAILABLE',
+                retryable: true,
+                detail: 'The Codex runtime is unavailable. Retry shortly.',
+            };
+    }
+}

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

@@ -6,6 +6,14 @@
 import { DomainError } from './errors.js';
 import { createSkillSelection, normalizeSkillProfileName, } from '../../skills/model/skill-profile.js';
 import { interactionId, profileName, sessionId, threadId, turnId, workspaceId, workspacePath, } from './value-objects.js';
+/** A durable thread can be read even when this relay has no live writer. */
+export function isSessionReadable(session) {
+    return session.threadId !== null;
+}
+/** Writer ownership is deliberately transient: only a live relay state implies it. */
+export function relayOwnsWriter(session) {
+    return session.state === 'ready' || session.state === 'turnActive';
+}
 export function createEffectiveSkillSelection(input) {
     return {
         ...(input.selectedProfileName === undefined

package/dist/server/server/features/sessions/promote-recent-thread/endpoint.js CHANGED Viewed

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { z } from 'zod';
+import { RecentThreadHistoryUnavailable } from './use-case.js';
 const requestSchema = z.object({
     threadId: z.string().min(1),
     cwd: z.string().startsWith('/'),
@@ -20,9 +21,14 @@ export function registerPromoteRecentThread(app, deps) {
             return reply.code(202).send(await deps.promote(thread));
         }
         catch (error) {
+            const historyUnavailable = error instanceof RecentThreadHistoryUnavailable;
             return reply.code(409).send({
-                code: 'RECENT_THREAD_OPEN_FAILED',
-                detail: error instanceof Error ? error.message : 'Could not open the recent session.',
+                code: historyUnavailable
+                    ? 'RECENT_THREAD_HISTORY_UNAVAILABLE'
+                    : 'RECENT_THREAD_OPEN_FAILED',
+                detail: historyUnavailable
+                    ? 'The selected thread history is currently unavailable. Retry after Codex is available.'
+                    : 'The selected thread could not be opened. Retry shortly.',
             });
         }
     });

package/dist/server/server/features/sessions/promote-recent-thread/use-case.js CHANGED Viewed

@@ -4,10 +4,38 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { RelaySession } from '../model/relay-session.js';
+export class RecentThreadHistoryUnavailable extends Error {
+    constructor() {
+        super('RECENT_THREAD_HISTORY_UNAVAILABLE');
+    }
+}
+const inFlightPromotions = new Map();
 export async function promoteRecentThread(thread, deps) {
+    const key = `${thread.profile}:${thread.cwd}:${thread.id}`;
+    const ongoing = inFlightPromotions.get(key);
+    if (ongoing)
+        return ongoing;
+    const operation = promote(thread, deps);
+    inFlightPromotions.set(key, operation);
+    try {
+        return await operation;
+    }
+    finally {
+        if (inFlightPromotions.get(key) === operation)
+            inFlightPromotions.delete(key);
+    }
+}
+async function promote(thread, deps) {
     const existing = deps.list().find((session) => session.threadId === thread.id);
-    if (existing?.state === 'ready' || existing?.state === 'turnActive')
+    if (existing) {
+        try {
+            await deps.read(existing);
+        }
+        catch {
+            throw new RecentThreadHistoryUnavailable();
+        }
         return existing;
+    }
     const now = deps.now();
     const imported = existing ??
         RelaySession.fromExistingThread({
@@ -18,9 +46,13 @@ export async function promoteRecentThread(thread, deps) {
             threadId: thread.id,
             now,
         }).snapshot;
-    if (!existing)
-        deps.save(imported);
-    const active = await deps.restore(imported);
-    deps.save(active);
-    return active;
+    // Validate first: an unavailable thread must never leave an imported stub.
+    try {
+        await deps.read(imported);
+    }
+    catch {
+        throw new RecentThreadHistoryUnavailable();
+    }
+    deps.save(imported);
+    return imported;
 }

package/dist/server/server/features/sessions/register-routes.js CHANGED Viewed

@@ -60,6 +60,8 @@ export function registerSessionRoutes(app, deps) {
             registerStartTurn(app, {
                 find: sessions.find,
                 start: sessions.startTurn,
+                ensureWriter: sessions.ensureWriter,
+                releaseWriter: sessions.releaseWriter,
                 save: sessions.save,
                 onStarted: sessions.onTurnStarted,
                 idempotency: sessions.idempotency,

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

@@ -4,8 +4,11 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { createHash } from 'node:crypto';
+import { RelaySession } from '../model/relay-session.js';
+import { WriterAcquisitionError, writerAcquisitionProblem, } from '../application/writer-acquisition.js';
 export function registerStartTurn(app, deps) {
     const inflight = new Map();
+    const sessionOperations = new Map();
     // Durable idempotency results are session-scoped and replay for as long as the
     // store retains them; a reused key with a different prompt is rejected.
     // Text is capped at 100,000 characters; leave room for JSON encoding only.
@@ -16,7 +19,7 @@ export function registerStartTurn(app, deps) {
         const text = request.body.text?.trim() ?? '';
         if (text.length > 100_000)
             return reply.code(400).send({ code: 'TURN_INPUT_TOO_LONG' });
-        if (!text || session.state !== 'ready')
+        if (!text)
             return reply.code(409).send({ code: 'SESSION_NOT_READY' });
         const key = request.headers['idempotency-key'];
         if (typeof key === 'string' && key && deps.idempotency) {
@@ -28,15 +31,31 @@ export function registerStartTurn(app, deps) {
             const inflightKey = `${scope}:${key}`;
             const operation = inflight.get(inflightKey) ??
                 (async () => {
-                    const started = await deps.start(session, text, key);
-                    deps.save(started);
-                    deps.onStarted?.(started);
-                    const result = {
-                        statusCode: 202,
-                        body: JSON.stringify({ fingerprint, response: started }),
-                    };
-                    deps.idempotency.put(scope, key, result.statusCode, result.body);
-                    return result;
+                    return serializeSession(sessionOperations, session.id, async () => {
+                        const current = deps.find(session.id);
+                        if (!current)
+                            return { statusCode: 404, body: JSON.stringify({ code: 'SESSION_NOT_FOUND' }) };
+                        const durable = deps.idempotency.get(scope, key);
+                        if (durable)
+                            return durable;
+                        if (current.state === 'turnActive')
+                            return { statusCode: 409, body: JSON.stringify({ code: 'SESSION_TURN_ACTIVE' }) };
+                        let started;
+                        try {
+                            started = await startWithWriter(deps, current, text, key);
+                        }
+                        catch (error) {
+                            if (error instanceof StartTurnProblem)
+                                return error.result;
+                            throw error;
+                        }
+                        const result = {
+                            statusCode: 202,
+                            body: JSON.stringify({ fingerprint, response: started }),
+                        };
+                        deps.idempotency.put(scope, key, result.statusCode, result.body);
+                        return result;
+                    });
                 })();
             inflight.set(inflightKey, operation);
             try {
@@ -46,14 +65,113 @@ export function registerStartTurn(app, deps) {
                 inflight.delete(inflightKey);
             }
         }
-        const started = await deps.start(session, text);
+        return serializeSession(sessionOperations, session.id, async () => {
+            const current = deps.find(session.id);
+            if (!current)
+                return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+            if (current.state === 'turnActive')
+                return reply.code(409).send({ code: 'SESSION_TURN_ACTIVE' });
+            try {
+                return reply
+                    .code(202)
+                    .send(await startWithWriter(deps, current, text, typeof key === 'string' ? key : undefined));
+            }
+            catch (error) {
+                if (error instanceof StartTurnProblem)
+                    return reply.code(error.result.statusCode).send(JSON.parse(error.result.body));
+                throw error;
+            }
+        });
+    });
+}
+async function startWithWriter(deps, session, text, key) {
+    const writable = await ensureWriter(deps, session);
+    if ('body' in writable)
+        throw new StartTurnProblem(writable);
+    try {
+        if (writable.session !== session)
+            deps.save(writable.session);
+    }
+    catch (error) {
+        await cleanupAcquiredWriter(deps, writable.session, session);
+        throw error;
+    }
+    try {
+        const started = await deps.start(writable.session, text, key);
         deps.save(started);
         deps.onStarted?.(started);
-        return reply.code(202).send(started);
+        return started;
+    }
+    catch (error) {
+        if (writable.session !== session)
+            await cleanupAcquiredWriter(deps, writable.session, session);
+        throw error;
+    }
+}
+class StartTurnProblem extends Error {
+    result;
+    constructor(result) {
+        super('START_TURN_PROBLEM');
+        this.result = result;
+    }
+}
+async function serializeSession(operations, sessionId, operation) {
+    const prior = operations.get(sessionId) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
     });
+    operations.set(sessionId, current);
+    await prior;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (operations.get(sessionId) === current)
+            operations.delete(sessionId);
+    }
+}
+/** Cleanup is best effort: never replace the original start/persistence error. */
+async function cleanupAcquiredWriter(deps, acquired, original) {
+    try {
+        await deps.releaseWriter?.(acquired.id);
+    }
+    catch {
+        // Process loss is already a valid release outcome.
+    }
+    try {
+        deps.save(original);
+    }
+    catch {
+        // The original I/O failure remains the observable failure.
+    }
+}
+async function ensureWriter(deps, session) {
+    if (!deps.ensureWriter) {
+        if (session.state === 'ready')
+            return { session, replacementCreated: false };
+        return failure('runtimeUnavailable');
+    }
+    try {
+        return await deps.ensureWriter(session);
+    }
+    catch (error) {
+        if (error instanceof WriterAcquisitionError &&
+            error.kind === 'writerBusy' &&
+            session.state !== 'stopped')
+            deps.save(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+        return failure(error instanceof WriterAcquisitionError ? error.kind : 'runtimeUnavailable');
+    }
+}
+function failure(kind) {
+    const problem = writerAcquisitionProblem(kind);
+    return { statusCode: problem.status, body: JSON.stringify(problem) };
 }
 function replay(result, fingerprint, reply) {
     const cached = JSON.parse(result.body);
+    if (cached.fingerprint === undefined)
+        return reply.code(result.statusCode).send(cached);
     if (cached.fingerprint !== fingerprint)
         return reply.code(409).send({ code: 'IDEMPOTENCY_KEY_REUSED' });
     return reply.code(result.statusCode).send(cached.response);

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

@@ -6,6 +6,7 @@
 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';
+export const CODEX_THREAD_WRITER_BUSY = 'CODEX_THREAD_WRITER_BUSY';
 /** A bounded representation of an app-server JSON-RPC failure. */
 export class CodexJsonRpcError extends Error {
     code;
@@ -25,10 +26,19 @@ export class CodexJsonRpcError extends Error {
 export function isMissingCodexThreadRollout(error) {
     return error instanceof CodexJsonRpcError && error.kind === CODEX_THREAD_NOT_FOUND;
 }
+/** Compatibility shim for the confirmed Codex 0.146 active-writer response. */
+export function isCodexThreadWriterBusy(error) {
+    return error instanceof CodexJsonRpcError && error.kind === CODEX_THREAD_WRITER_BUSY;
+}
 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;
+    if (code !== -32600)
+        return CODEX_JSON_RPC_ERROR;
+    if (/^no rollout found for thread id\b/i.test(message))
+        return CODEX_THREAD_NOT_FOUND;
+    // Fixture-backed exact protocol wording: do not broaden this into a heuristic.
+    if (/^thread .* already has an active writer$/i.test(message))
+        return CODEX_THREAD_WRITER_BUSY;
+    return CODEX_JSON_RPC_ERROR;
 }
 function boundMessage(message) {
     return message

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

@@ -9,6 +9,8 @@ import { createPlanMeasurementSnapshot, } from '../../features/plans/application
 import { canRebindMissingRollout, rebindMissingRollout, } from '../../features/sessions/restore-session/use-case.js';
 import { gestaltQuizDynamicTool } from '../../../shared/contracts/quiz.js';
 import { threadPlanName } from './thread-plan-name.js';
+import { WriterAcquisitionError, } from '../../features/sessions/application/writer-acquisition.js';
+import { isCodexThreadWriterBusy, isMissingCodexThreadRollout } from './json-rpc-client.js';
 /** One private owner for every resource acquired for a live Codex child. */
 class SessionResource {
     sessionId;
@@ -65,10 +67,11 @@ export class CodexSessionRuntime {
     planMeasurementBaseUrl;
     requestTimeoutMs;
     maxPendingRequests;
+    readerCwd;
     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, requestTimeoutMs = 30_000, maxPendingRequests = 64) {
+    _legacyProcesses = undefined, onNotification, onServerRequest, onProcessExit, resolveSkills, planStatusSource, onPlanStatus, planMeasurementBaseUrl, requestTimeoutMs = 30_000, maxPendingRequests = 64, readerCwd) {
         this.launch = launch;
         this.onNotification = onNotification;
         this.onServerRequest = onServerRequest;
@@ -79,9 +82,12 @@ export class CodexSessionRuntime {
         this.planMeasurementBaseUrl = planMeasurementBaseUrl;
         this.requestTimeoutMs = requestTimeoutMs;
         this.maxPendingRequests = maxPendingRequests;
+        this.readerCwd = readerCwd;
         void _legacyProcesses;
     }
     sessions = new Map();
+    historyReads = new Map();
+    writerAcquisitions = new Map();
     async start(session, now, settings = {}) {
         const resource = await this.createResource(session);
         try {
@@ -120,6 +126,12 @@ export class CodexSessionRuntime {
         for (const resource of [...this.sessions.values()])
             resource.dispose();
     }
+    /** Keeps a detached session's supervised-plan status observable without launching Codex. */
+    async watchPlanStatus(session) {
+        if (!this.planStatusSource)
+            return;
+        await this.planStatusSource.open({ id: session.id, workspacePath: session.workspacePath }, (update) => this.onPlanStatus?.(session.id, update));
+    }
     resolveServerRequest(sessionId, requestId, result) {
         const resource = this.sessions.get(sessionId);
         const pending = resource?.pendingRequests.get(requestId);
@@ -142,6 +154,35 @@ export class CodexSessionRuntime {
         }));
         return RelaySession.rehydrate(session).startTurn(result, now).snapshot;
     }
+    /** The sole authoritative in-process ownership probe.  It never launches a child. */
+    ownsWriter(sessionId) {
+        return this.sessions.get(sessionId)?.active === true;
+    }
+    async ensureWriter(session, now) {
+        if (this.ownsWriter(session.id))
+            return { session, replacementCreated: false };
+        const inflight = this.writerAcquisitions.get(session.id);
+        if (inflight)
+            return inflight;
+        const acquisition = this.acquireWriter(session, now);
+        this.writerAcquisitions.set(session.id, acquisition);
+        try {
+            return await acquisition;
+        }
+        finally {
+            if (this.writerAcquisitions.get(session.id) === acquisition)
+                this.writerAcquisitions.delete(session.id);
+        }
+    }
+    async acquireWriter(session, now) {
+        try {
+            const restored = await this.restoreWithOutcome(session, now);
+            return { session: restored.session, replacementCreated: restored.replacementCreated };
+        }
+        catch (error) {
+            throw classifyWriterAcquisitionFailure(error);
+        }
+    }
     async interruptTurn(session, turnId) {
         const resource = this.sessions.get(session.id);
         if (!resource || !session.threadId)
@@ -170,13 +211,44 @@ export class CodexSessionRuntime {
         return Boolean(token && authorization === `Bearer ${token}`);
     }
     async readHistory(session) {
-        const resource = this.sessions.get(session.id);
-        if (!resource || !session.threadId)
-            throw new Error('CODEX_SESSION_NOT_RUNNING');
-        const result = decodeThreadRead(await resource.process.rpc.request('thread/read', {
-            threadId: session.threadId,
-            includeTurns: true,
-        }));
+        if (!session.threadId)
+            throw new Error('CODEX_THREAD_ID_MISSING');
+        const owned = this.sessions.get(session.id);
+        if (owned)
+            return this.decodeHistory(owned.process, session.threadId);
+        const existing = this.historyReads.get(session.id);
+        if (existing)
+            return existing;
+        const read = this.readDetachedHistory(session);
+        this.historyReads.set(session.id, read);
+        try {
+            return await read;
+        }
+        finally {
+            if (this.historyReads.get(session.id) === read)
+                this.historyReads.delete(session.id);
+        }
+    }
+    async readDetachedHistory(session) {
+        // A reader is intentionally not a SessionResource: it owns no subscriptions,
+        // runtime registration, plan lease, or writer state and is closed on every path.
+        const process = this.launch({
+            profile: session.profile,
+            cwd: this.readerCwd ?? session.workspacePath,
+        });
+        try {
+            await process.rpc.request('initialize', {
+                clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
+                capabilities: { experimentalApi: true },
+            });
+            return await this.decodeHistory(process, session.threadId);
+        }
+        finally {
+            process.close();
+        }
+    }
+    async decodeHistory(process, threadId) {
+        const result = decodeThreadRead(await process.rpc.request('thread/read', { threadId, includeTurns: true }));
         const rawTurns = result;
         const activeTurn = rawTurns.find((turn) => turn.status === 'inProgress' && typeof turn.id === 'string');
         return {
@@ -343,6 +415,20 @@ export class CodexSessionRuntime {
 function isMethodNotFound(error) {
     return Boolean(error && typeof error === 'object' && error.code === -32601);
 }
+function classifyWriterAcquisitionFailure(error) {
+    if (isCodexThreadWriterBusy(error))
+        return new WriterAcquisitionError('writerBusy');
+    if (isMissingCodexThreadRollout(error))
+        return new WriterAcquisitionError('rolloutMissing');
+    if (isMethodNotFound(error))
+        return new WriterAcquisitionError('protocolIncompatible');
+    const code = error instanceof Error ? error.message : '';
+    if (code === 'ENOENT' || code === 'CODEX_THREAD_ID_MISSING')
+        return new WriterAcquisitionError('workspaceUnavailable');
+    if (/MCP|DEPENDENCY|SKILL/i.test(code))
+        return new WriterAcquisitionError('runtimeDependencyFailed');
+    return new WriterAcquisitionError('runtimeUnavailable');
+}
 function rateLimitWindows(value) {
     const limits = asRecord(value)?.rateLimits;
     if (!Array.isArray(limits))

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.16.3",
+  "version": "0.16.4",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",