gestalt-mobile 0.41.2 → 0.42.0

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

@@ -17,10 +17,15 @@ 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';
+/** Sticky thread config keeps skill paths out of the app-server process argv. */
+export function threadSkillConfig(skillsConfig) {
+    return skillsConfig === undefined ? {} : { config: { skills: { config: skillsConfig } } };
+}
 /** One private owner for every resource acquired for a live Codex child. */
 class SessionResource {
     sessionId;
     process;
+    skillsConfig;
     planStatusLease;
     planMeasurementToken;
     unregister;
@@ -39,9 +44,10 @@ class SessionResource {
     completedProcessActions = new Map();
     turnThreads = new Map();
     childThreads = new Set();
-    constructor(sessionId, process, planStatusLease, planMeasurementToken, unregister, onDisposed) {
+    constructor(sessionId, process, skillsConfig, planStatusLease, planMeasurementToken, unregister, onDisposed) {
         this.sessionId = sessionId;
         this.process = process;
+        this.skillsConfig = skillsConfig;
         this.planStatusLease = planStatusLease;
         this.planMeasurementToken = planMeasurementToken;
         this.unregister = unregister;
@@ -117,7 +123,7 @@ export class CodexSessionRuntime {
                 clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
                 capabilities: { experimentalApi: true },
             });
-            const startedThreadId = await this.startThread(resource.process, session);
+            const startedThreadId = await this.startThread(resource.process, session, resource.skillsConfig);
             resource.threadId = startedThreadId;
             this.sessions.set(session.id, resource);
             await this.writePendingThreadName(session.id);
@@ -671,6 +677,7 @@ export class CodexSessionRuntime {
                 await resource.process.rpc.request('thread/resume', {
                     threadId: session.threadId,
                     cwd: session.workspacePath,
+                    ...threadSkillConfig(resource.skillsConfig),
                     ...(session.executionPolicy?.approvalPolicy
                         ? { approvalPolicy: session.executionPolicy.approvalPolicy }
                         : {}),
@@ -692,7 +699,7 @@ export class CodexSessionRuntime {
             catch (error) {
                 if (!canRebindMissingRollout(session, error))
                     throw error;
-                const replacementThreadId = await this.startThread(resource.process, session);
+                const replacementThreadId = await this.startThread(resource.process, session, resource.skillsConfig);
                 result = rebindMissingRollout(session, error, replacementThreadId, now);
             }
             resource.threadId = result.session.threadId;
@@ -760,12 +767,13 @@ export class CodexSessionRuntime {
                 reject(new Error('CODEX_SERVER_REQUEST_UNSUPPORTED'));
         });
     }
-    async startThread(process, session) {
-        return decodeThreadStart(await process.rpc.request('thread/start', this.threadStartParams(session)));
+    async startThread(process, session, skillsConfig) {
+        return decodeThreadStart(await process.rpc.request('thread/start', this.threadStartParams(session, skillsConfig)));
     }
-    threadStartParams(session) {
+    threadStartParams(session, skillsConfig) {
         return {
             cwd: session.workspacePath,
+            ...threadSkillConfig(skillsConfig),
             approvalPolicy: session.executionPolicy?.approvalPolicy ?? 'on-request',
             dynamicTools: [
                 gestaltQuizDynamicTool,
@@ -792,10 +800,10 @@ export class CodexSessionRuntime {
             : undefined;
         try {
             const token = randomUUID();
+            const skillsConfig = await this.resolveSkills?.(session);
             const process = this.launch({
                 profile: session.profile,
                 cwd: session.workspacePath,
-                skillsConfig: await this.resolveSkills?.(session),
                 ...(lease || this.planMeasurementBaseUrl
                     ? {
                         environment: {
@@ -812,7 +820,7 @@ export class CodexSessionRuntime {
                     }
                     : {}),
             });
-            const resource = new SessionResource(session.id, process, lease, token, [], () => {
+            const resource = new SessionResource(session.id, process, skillsConfig, lease, token, [], () => {
                 if (this.sessions.get(session.id) === resource)
                     this.sessions.delete(session.id);
             });

package/dist/server/shared/contracts/org-plan-attention.js

@@ -41,6 +41,12 @@ export const gestaltOrgPlanAttentionDynamicTool = {
             summary: { type: 'string', minLength: 1, maxLength: 600 },
             requestedAction: { type: 'string', minLength: 1, maxLength: 600 },
             resumeCondition: { type: 'string', enum: orgPlanAttentionResumeConditions },
+            executorReplacement: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['canonicalTaskName'],
+                properties: { canonicalTaskName: { type: 'string', pattern: '^l[1-9][0-9]*$' } },
+            },
         },
         oneOf: orgPlanAttentionReasons.map((reason) => ({
             properties: {
@@ -66,19 +72,31 @@ export function parseOrgPlanAttention(value) {
             requestedAction: `Satisfy the ${value.resumeCondition} resume condition, then resume or disable Autopilot.`,
             resumeCondition: value.resumeCondition,
         };
-    if (keys.length !== 4)
+    if (keys.length !== 4 && keys.length !== 5)
+        return null;
+    if (keys.some((key) => ![
+        'reason',
+        'summary',
+        'requestedAction',
+        'resumeCondition',
+        'executorReplacement',
+    ].includes(key)))
         return null;
+    const executorReplacement = parseExecutorReplacement(value.executorReplacement);
     if (!isReason(value.reason) ||
         !isBoundedText(value.summary, 600) ||
         !isBoundedText(value.requestedAction, 600) ||
         !isResumeCondition(value.resumeCondition) ||
-        orgPlanAttentionResumeConditionByReason[value.reason] !== value.resumeCondition)
+        orgPlanAttentionResumeConditionByReason[value.reason] !== value.resumeCondition ||
+        (value.executorReplacement !== undefined && !executorReplacement) ||
+        (executorReplacement && value.reason !== 'permissionRequired'))
         return null;
     return {
         reason: value.reason,
         summary: value.summary,
         requestedAction: value.requestedAction,
         resumeCondition: value.resumeCondition,
+        ...(executorReplacement ? { executorReplacement } : {}),
     };
 }
 export function parseOrgPlanAttentionResponse(value) {
@@ -108,21 +126,32 @@ export function toOrgPlanAttentionAcknowledgement(acknowledgement = { accepted:
     };
 }
 export function isOrgPlanAttentionToolResponse(value) {
+    return parseOrgPlanAttentionToolResponse(value) !== null;
+}
+export function parseOrgPlanAttentionToolResponse(value) {
     if (!isRecord(value) || value.success !== true || !Array.isArray(value.contentItems))
-        return false;
+        return null;
     const item = value.contentItems[0];
     if (value.contentItems.length !== 1 ||
         !isRecord(item) ||
         item.type !== 'inputText' ||
         typeof item.text !== 'string')
-        return false;
+        return null;
     try {
-        return parseOrgPlanAttentionResponse(JSON.parse(item.text)) !== null;
+        return parseOrgPlanAttentionResponse(JSON.parse(item.text));
     }
     catch {
-        return false;
+        return null;
     }
 }
+function parseExecutorReplacement(value) {
+    if (!isRecord(value) || Object.keys(value).length !== 1)
+        return null;
+    return typeof value.canonicalTaskName === 'string' &&
+        /^l[1-9][0-9]*$/.test(value.canonicalTaskName)
+        ? { canonicalTaskName: value.canonicalTaskName }
+        : null;
+}
 function isReason(value) {
     return (typeof value === 'string' && orgPlanAttentionReasons.includes(value));
 }

package/dist/server/shared/contracts/org-plan-checkpoint.js

@@ -10,81 +10,14 @@ const record = (value) => typeof value === 'object' && value !== null && !Array.
 export const gestaltOrgPlanCheckpointDynamicTool = {
     type: 'function',
     name: GESTALT_ORG_PLAN_CHECKPOINT_TOOL_NAME,
-    description: 'Record a validated supervised Org Plan report boundary. This is not review authority and must only be called by the active root after the Org Plan helper has recorded the matching state.',
+    description: 'Record a validated supervised Org Plan report boundary. Send only the boundary kind; Mobile derives and validates all details from authoritative control state.',
     inputSchema: {
         type: 'object',
         additionalProperties: false,
-        required: ['version', 'kind', 'planIdentity'],
+        required: ['kind'],
         properties: {
-            version: { const: 1 },
             kind: { type: 'string', enum: ['l2Completed', 'l1Accepted', 'terminalReviewAccepted'] },
-            planIdentity: { type: 'string', minLength: 1, maxLength: 128 },
-            l1Id: { type: 'string', minLength: 1, maxLength: 128 },
-            l2Id: { type: 'string', minLength: 1, maxLength: 128 },
-            position: { type: 'string', pattern: '^L[1-9][0-9]*(\\.[1-9][0-9]*)?$', maxLength: 32 },
-            status: { const: 'DONE' },
-            verdict: { const: 'ACCEPT' },
-            commit: {
-                oneOf: [
-                    {
-                        type: 'object',
-                        additionalProperties: false,
-                        required: ['kind', 'subject', 'shortHash'],
-                        properties: {
-                            kind: { const: 'created' },
-                            subject: { type: 'string', minLength: 1, maxLength: 160 },
-                            shortHash: { type: 'string', pattern: '^[0-9a-f]{7,16}$' },
-                        },
-                    },
-                    {
-                        type: 'object',
-                        additionalProperties: false,
-                        required: ['kind'],
-                        properties: { kind: { const: 'notRequired' } },
-                    },
-                ],
-            },
-            findings: { type: 'string', minLength: 1, maxLength: 600 },
-            changes: { type: 'string', minLength: 1, maxLength: 600 },
-            files: { type: 'string', minLength: 1, maxLength: 600 },
-            tests: { type: 'string', minLength: 1, maxLength: 600 },
         },
-        oneOf: [
-            {
-                properties: { kind: { const: 'l2Completed' } },
-                required: ['l1Id', 'l2Id', 'position', 'status', 'changes', 'files', 'tests'],
-                not: {
-                    anyOf: [{ required: ['verdict'] }, { required: ['commit'] }, { required: ['findings'] }],
-                },
-            },
-            {
-                properties: { kind: { const: 'l1Accepted' } },
-                required: ['l1Id', 'position', 'verdict', 'commit'],
-                not: {
-                    anyOf: [
-                        { required: ['l2Id'] },
-                        { required: ['status'] },
-                        { required: ['changes'] },
-                        { required: ['files'] },
-                    ],
-                },
-            },
-            {
-                properties: { kind: { const: 'terminalReviewAccepted' } },
-                required: ['verdict'],
-                not: {
-                    anyOf: [
-                        { required: ['l1Id'] },
-                        { required: ['l2Id'] },
-                        { required: ['position'] },
-                        { required: ['status'] },
-                        { required: ['commit'] },
-                        { required: ['changes'] },
-                        { required: ['files'] },
-                    ],
-                },
-            },
-        ],
     },
 };
 export function parseOrgPlanCheckpoint(value) {

package/package.json

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