gestalt-mobile 0.17.1 → 0.17.3

package/dist/client/index.html

@@ -16,7 +16,7 @@ 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-DgD-0I3M.js"></script>
+    <script type="module" crossorigin src="/assets/index-Ba_4zoY1.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-e2lJ5XqL.css">
   </head>
   <body>

package/dist/server/server/composition.js

@@ -32,7 +32,7 @@ import { GitSummaryCache } from './platform/git/git-summary-cache.js';
 import { SessionSupervisor } from './platform/runtime/session-supervisor.js';
 import { mapWithConcurrency } from './platform/runtime/concurrency.js';
 import { RelaySession } from './features/sessions/model/relay-session.js';
-import { toPendingInteraction } from './platform/codex/server-request.js';
+import { resolvedServerRequestId, toPendingInteraction } from './platform/codex/server-request.js';
 import { isValidInteractionResponse, isValidQuizInteractionResponse, } from './features/sessions/interaction/response-validator.js';
 import { promoteRecentThread } from './features/sessions/promote-recent-thread/use-case.js';
 import { FilesystemSkillProfileStore } from './platform/skills/filesystem-skill-profile-store.js';
@@ -113,9 +113,25 @@ export async function composeRelayApp(options) {
     const gitSummaries = new GitSummaryCache(inspectGit);
     let recoverExitedSession = () => { };
     let planMeasurementRefresh;
+    const publishInteractionResolved = (sessionId, requestId, occurredAt, outcome) => {
+        const interaction = interactions
+            .snapshot(sessionId)
+            .find((item) => item.requestId === requestId);
+        events.publish(journal.append(sessionId, 'interaction.resolved', { requestId, turnId: interaction?.turnId ?? null, resolvedAt: occurredAt, outcome }, occurredAt));
+    };
+    const dismissPendingInteractions = (sessionId, occurredAt) => {
+        for (const interaction of interactions.list(sessionId)) {
+            if (interactions.resolve(sessionId, interaction.requestId, occurredAt, 'dismissed'))
+                publishInteractionResolved(sessionId, interaction.requestId, occurredAt, 'dismissed');
+        }
+    };
     const runtime = options.startAppServers
         ? new CodexSessionRuntime(options.launchAppServer ?? launchCodexAppServer, undefined, (sessionId, notification) => {
             const occurredAt = new Date().toISOString();
+            const resolvedRequestId = resolvedServerRequestId(notification);
+            if (resolvedRequestId &&
+                interactions.resolve(sessionId, resolvedRequestId, occurredAt, 'dismissed'))
+                publishInteractionResolved(sessionId, resolvedRequestId, occurredAt, 'dismissed');
             const currentSession = sessions.find(sessionId);
             const normalized = normalizeCodexNotification(sessionId, 0, occurredAt, notification, currentSession?.workspacePath, currentSession?.activeTurnId);
             if (!normalized)
@@ -148,7 +164,10 @@ export async function composeRelayApp(options) {
             sessions.save(updated);
             events.publish(journal.append(sessionId, 'interaction.requested', interaction, updated.updatedAt));
             return true;
-        }, (sessionId) => recoverExitedSession(sessionId), resolveSkills, planStatusSource, (sessionId, update) => {
+        }, (sessionId) => {
+            dismissPendingInteractions(sessionId, new Date().toISOString());
+            recoverExitedSession(sessionId);
+        }, resolveSkills, planStatusSource, (sessionId, update) => {
             supervisedPlans.accept(sessionId, update);
             planMeasurementRefresh?.accept(sessionId, update);
             if (update.kind === 'updated') {
@@ -291,15 +310,27 @@ export async function composeRelayApp(options) {
                 skillCatalog,
                 defaultSkillProfile: options.explicitSkillProfile,
                 activate: runtime
-                    ? async (session, settings) => runtime.start(session, new Date().toISOString(), settings)
+                    ? async (session, settings) => {
+                        const now = new Date().toISOString();
+                        dismissPendingInteractions(session.id, now);
+                        return runtime.start(session, now, settings);
+                    }
                     : undefined,
                 startTurn: runtime
                     ? async (session, text, clientUserMessageId) => runtime.startTurn(session, text, clientUserMessageId, new Date().toISOString())
                     : undefined,
                 ensureWriter: runtime
-                    ? (session) => runtime.ensureWriter(session, new Date().toISOString())
+                    ? (session) => {
+                        dismissPendingInteractions(session.id, new Date().toISOString());
+                        return runtime.ensureWriter(session, new Date().toISOString());
+                    }
+                    : undefined,
+                releaseWriter: runtime
+                    ? (id) => {
+                        dismissPendingInteractions(id, new Date().toISOString());
+                        return runtime.release(id);
+                    }
                     : undefined,
-                releaseWriter: runtime ? (id) => runtime.release(id) : undefined,
                 onTurnStarted: (session) => planMeasurementRefresh?.refreshNow(session.id),
                 models,
                 readHistory: runtime ? (session) => runtime.readHistory(session) : undefined,
@@ -325,17 +356,15 @@ export async function composeRelayApp(options) {
                 close: runtime
                     ? (id) => {
                         planMeasurementRefresh?.stop(id);
+                        dismissPendingInteractions(id, new Date().toISOString());
                         return runtime.release(id);
                     }
                     : undefined,
                 replyInteraction: runtime
-                    ? (sessionId, requestId, value) => runtime.resolveServerRequest(sessionId, requestId, value)
+                    ? (sessionId, requestId, value) => runtime.resolveServerRequest(sessionId, requestId, value) ? 'accepted' : 'cleared'
                     : undefined,
                 interactionResolved: (sessionId, requestId, occurredAt, outcome) => {
-                    const interaction = interactions
-                        .snapshot(sessionId)
-                        .find((item) => item.requestId === requestId);
-                    events.publish(journal.append(sessionId, 'interaction.resolved', { requestId, turnId: interaction?.turnId ?? null, resolvedAt: occurredAt, outcome }, occurredAt));
+                    publishInteractionResolved(sessionId, requestId, occurredAt, outcome);
                 },
             },
             sessionEvents: {
@@ -438,6 +467,8 @@ export async function composeRelayApp(options) {
     });
     app.addHook('onClose', async () => {
         planMeasurementRefresh?.stopAll();
+        for (const session of sessions.list())
+            dismissPendingInteractions(session.id, new Date().toISOString());
         runtime?.stopAll();
         planStatusSource.closeAll();
         database.close();

package/dist/server/server/features/sessions/respond-interaction/endpoint.js

@@ -18,8 +18,21 @@ export function registerRespondInteraction(app, deps) {
             return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
         if (deps.validate && !deps.validate(id, requestId, value))
             return reply.code(400).send({ code: 'INTERACTION_RESPONSE_INVALID' });
-        if (!deps.reply(id, requestId, value))
-            return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
+        const delivery = deps.reply(id, requestId, value);
+        if (delivery === false || delivery === 'unavailable')
+            return reply.code(409).send({ code: 'INTERACTION_DELIVERY_UNAVAILABLE' });
+        if (delivery === 'cleared') {
+            const resolvedAt = deps.now();
+            const outcome = 'dismissed';
+            if (deps.resolve(id, requestId, resolvedAt, outcome)) {
+                deps.resolved?.(id, requestId, resolvedAt, outcome);
+                return reply.code(202).send({ accepted: true, resolvedAt, outcome });
+            }
+            const raced = deps.alreadyResolved?.(id, requestId);
+            return raced
+                ? reply.code(202).send({ accepted: true, ...raced })
+                : reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
+        }
         const resolvedAt = deps.now();
         const outcome = safeOutcome(value);
         if (!deps.resolve(id, requestId, resolvedAt, outcome))

package/dist/server/server/features/skills/model/skill-profile.js

@@ -81,6 +81,36 @@ function canonicalSkillPath(value) {
     }
     return value;
 }
+/**
+ * Return the durable identity of a skill inside Codex's versioned plugin cache.
+ * The concrete version directory is installation state, while marketplace,
+ * plugin, and skill-relative path remain stable across plugin upgrades.
+ */
+function versionNeutralPluginSkillPath(value) {
+    const match = value.match(/^(.*[\\/]plugins[\\/]cache[\\/][^\\/]+[\\/][^\\/]+)[\\/][^\\/]+([\\/]skills[\\/].+[\\/]SKILL\.md)$/);
+    return match ? `${match[1]}${match[2]}` : undefined;
+}
+function rebindVersionedPluginSkills(discovered, selection) {
+    const discoveredPaths = new Set(discovered.map((skill) => canonicalSkillPath(skill.path)));
+    const discoveredByDurablePath = new Map();
+    for (const skill of discovered) {
+        const durablePath = versionNeutralPluginSkillPath(canonicalSkillPath(skill.path));
+        if (durablePath === undefined)
+            continue;
+        const matches = discoveredByDurablePath.get(durablePath) ?? [];
+        matches.push(skill);
+        discoveredByDurablePath.set(durablePath, matches);
+    }
+    return createSkillSelection(selection.map((entry) => {
+        if (discoveredPaths.has(entry.path))
+            return entry;
+        const durablePath = versionNeutralPluginSkillPath(entry.path);
+        if (durablePath === undefined)
+            return entry;
+        const matches = discoveredByDurablePath.get(durablePath) ?? [];
+        return matches.length === 1 ? { ...entry, path: matches[0].path } : entry;
+    }));
+}
 /**
  * Validate a complete selection and return its canonical deterministic order.
  * This is lexical only: resolving symlinks is I/O and belongs to a platform
@@ -137,11 +167,12 @@ export function compileSkillOverride(input) {
     const effective = selectEffectiveSkillSelection(input);
     if (effective.selection === undefined)
         return { source: 'native', skillsConfig: undefined, warnings: [] };
+    const reboundSelection = rebindVersionedPluginSkills(input.discovered, effective.selection);
     const discoveredPaths = new Set(input.discovered.map((skill) => canonicalSkillPath(skill.path)));
-    const warnings = effective.selection
+    const warnings = reboundSelection
         .filter((entry) => !discoveredPaths.has(entry.path))
         .map((entry) => `Saved skill path is no longer discovered: ${entry.path}`);
-    const configured = applySkillSelectionSnapshot(input.discovered, effective.selection);
+    const configured = applySkillSelectionSnapshot(input.discovered, reboundSelection);
     return {
         source: effective.source,
         skillsConfig: configured

package/dist/server/server/platform/codex/server-request.js

@@ -21,6 +21,15 @@ export function toPendingInteraction(input) {
     }[input.method];
     return kind ? { requestId: String(input.id), kind, payload: input.params } : null;
 }
+export function resolvedServerRequestId(input) {
+    if (input.method !== 'serverRequest/resolved' || !isRecord(input.params))
+        return null;
+    const requestId = input.params.requestId;
+    if (!((typeof requestId === 'string' && requestId.length > 0 && requestId.length <= 256) ||
+        (typeof requestId === 'number' && Number.isSafeInteger(requestId))))
+        return null;
+    return String(requestId);
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

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

@@ -11,6 +11,7 @@ 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';
+import { resolvedServerRequestId } from './server-request.js';
 /** One private owner for every resource acquired for a live Codex child. */
 class SessionResource {
     sessionId;
@@ -38,7 +39,6 @@ class SessionResource {
             return false;
         this.disposed = true;
         for (const pending of this.pendingRequests.values()) {
-            clearTimeout(pending.timer);
             pending.reject(new Error('CODEX_SERVER_REQUEST_CANCELLED'));
         }
         this.pendingRequests.clear();
@@ -65,13 +65,14 @@ export class CodexSessionRuntime {
     planStatusSource;
     onPlanStatus;
     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, readerCwd) {
+    _legacyProcesses = undefined, onNotification, onServerRequest, onProcessExit, resolveSkills, planStatusSource, onPlanStatus, planMeasurementBaseUrl, 
+    // Compatibility slot: blocking app-server requests wait for explicit input.
+    _legacyRequestTimeoutMs = undefined, maxPendingRequests = 64, readerCwd) {
         this.launch = launch;
         this.onNotification = onNotification;
         this.onServerRequest = onServerRequest;
@@ -80,10 +81,10 @@ export class CodexSessionRuntime {
         this.planStatusSource = planStatusSource;
         this.onPlanStatus = onPlanStatus;
         this.planMeasurementBaseUrl = planMeasurementBaseUrl;
-        this.requestTimeoutMs = requestTimeoutMs;
         this.maxPendingRequests = maxPendingRequests;
         this.readerCwd = readerCwd;
         void _legacyProcesses;
+        void _legacyRequestTimeoutMs;
     }
     sessions = new Map();
     historyReads = new Map();
@@ -138,7 +139,6 @@ export class CodexSessionRuntime {
         if (!resource || !pending)
             return false;
         resource.pendingRequests.delete(requestId);
-        clearTimeout(pending.timer);
         pending.resolve(result);
         return true;
     }
@@ -337,18 +337,17 @@ export class CodexSessionRuntime {
         }
     }
     holdServerRequest(resource, request) {
-        if (!resource.active || !this.onServerRequest?.(resource.sessionId, request)) {
-            return Promise.reject(new Error('CODEX_SERVER_REQUEST_UNSUPPORTED'));
-        }
+        if (!resource.active)
+            return Promise.reject(new Error('CODEX_SERVER_REQUEST_CANCELLED'));
         if (resource.pendingRequests.size >= this.maxPendingRequests)
             return Promise.reject(new Error('CODEX_SERVER_REQUEST_LIMIT'));
         const requestId = String(request.id);
+        if (resource.pendingRequests.has(requestId))
+            return Promise.reject(new Error('CODEX_SERVER_REQUEST_DUPLICATE'));
+        if (!this.onServerRequest?.(resource.sessionId, request))
+            return Promise.reject(new Error('CODEX_SERVER_REQUEST_UNSUPPORTED'));
         return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                if (resource.pendingRequests.delete(requestId))
-                    reject(new Error('CODEX_SERVER_REQUEST_TIMEOUT'));
-            }, this.requestTimeoutMs);
-            resource.pendingRequests.set(requestId, { resolve, reject, timer });
+            resource.pendingRequests.set(requestId, { resolve, reject });
         });
     }
     async startThread(process, session, settings = {}) {
@@ -394,8 +393,18 @@ export class CodexSessionRuntime {
                     this.sessions.delete(session.id);
             });
             const notificationUnsubscribe = process.rpc.onNotification((notification) => {
-                if (resource.active)
-                    this.onNotification?.(session.id, notification);
+                if (!resource.active)
+                    return;
+                const resolvedRequestId = resolvedServerRequestId(notification);
+                if (resolvedRequestId) {
+                    const pending = resource.pendingRequests.get(resolvedRequestId);
+                    resource.pendingRequests.delete(resolvedRequestId);
+                    // App-server has already cleared the request, so settle the local handler too.
+                    // The late JSON-RPC error response is harmless and prevents an orphaned promise.
+                    // The notification callback reconciles the durable interaction record.
+                    pending?.reject(new Error('CODEX_SERVER_REQUEST_CLEARED'));
+                }
+                this.onNotification?.(session.id, notification);
             });
             const requestUnsubscribe = process.rpc.onServerRequest((request) => this.holdServerRequest(resource, request));
             const exitUnsubscribe = process.onExit?.(() => {

package/dist/server/server/platform/persistence/sqlite-pending-interaction-store.js

@@ -4,7 +4,9 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 function safeInteractionOutcome(value) {
-    return value === 'approved' || value === 'denied' || value === 'answered' ? value : 'answered';
+    return value === 'approved' || value === 'denied' || value === 'answered' || value === 'dismissed'
+        ? value
+        : 'answered';
 }
 export class SqlitePendingInteractionStore {
     db;
@@ -13,7 +15,15 @@ export class SqlitePendingInteractionStore {
     }
     add(sessionId, interaction) {
         this.db
-            .prepare('INSERT INTO pending_interactions (session_id,request_id,kind,payload_json,turn_id,requested_at) VALUES (?,?,?,?,?,?)')
+            .prepare(`INSERT INTO pending_interactions (session_id,request_id,kind,payload_json,turn_id,requested_at)
+         VALUES (?,?,?,?,?,?)
+         ON CONFLICT(session_id,request_id) DO UPDATE SET
+           kind = excluded.kind,
+           payload_json = excluded.payload_json,
+           turn_id = excluded.turn_id,
+           requested_at = excluded.requested_at,
+           resolved_at = NULL,
+           outcome = NULL`)
             .run(sessionId, interaction.requestId, interaction.kind, JSON.stringify(interaction.payload), interaction.turnId ?? null, interaction.requestedAt ?? null);
     }
     resolve(sessionId, requestId, resolvedAt, outcome = 'answered') {

package/package.json

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