gestalt-mobile 0.41.1 → 0.41.3

package/dist/server/server/features/autopilot/application/service.js

@@ -321,9 +321,9 @@ export class AutopilotCoordinator {
             consecutiveNoProgress: 0,
             nextEvaluationAt: null,
             stopReason: null,
-            executor: undefined,
+            executor: !replacing && prior.state === 'attentionRequired' ? prior.executor : undefined,
             blocking: undefined,
-            supervision: recoverSafetyPause(consumeObsoleteWait(replacing
+            supervision: recoverSafetyPause(consumeObsoleteWait(replacing || prior.supervision?.outcome === 'attentionRequired'
                 ? startSupervisionProtocol(this.progressKey(sessionId))
                 : (prior.supervision ?? startSupervisionProtocol(this.progressKey(sessionId))), this.progressKey(sessionId)), this.progressKey(sessionId)),
             updatedAt: now,
@@ -332,6 +332,64 @@ export class AutopilotCoordinator {
         this.evaluate(sessionId);
         return this.snapshot(sessionId);
     }
+    /** Converts one typed human permission into one exact durable physical replacement. */
+    authorizeExecutorReplacement(sessionId, canonicalTaskName) {
+        const state = this.deps.store.find(sessionId);
+        const retained = this.deps.plan(sessionId);
+        if (!state ||
+            state.state !== 'attentionRequired' ||
+            state.blocking?.reason !== 'permissionRequired')
+            return { accepted: false, reason: 'attentionRequired' };
+        if (!retained ||
+            state.planIdentity !== retained.identity ||
+            state.planFingerprint !== fingerprint(retained.plan))
+            return { accepted: false, reason: 'planMismatch' };
+        const executor = state.executor;
+        if (!executor || executor.canonicalTaskName !== canonicalTaskName || executor.l1State !== 'WIP')
+            return { accepted: false, reason: 'executorNotAssigned' };
+        if (executor.replacement && this.validReplacement(sessionId, executor.replacement))
+            return { accepted: true, identity: executor.replacement };
+        const activity = this.deps.activity(sessionId);
+        if (activity?.confidence !== 'fresh' || this.executorTurnActive(executor, activity))
+            return { accepted: false, reason: 'executorStillActive' };
+        const previous = executor.assignment ?? executorAssignment(executor);
+        const identity = executorIdentity(canonicalTaskName, previous.generation + 1);
+        const now = this.deps.now();
+        this.persist({
+            ...state,
+            executor: {
+                ...executor,
+                outcome: 'failed',
+                assignment: { ...previous, state: 'unavailable' },
+                replacement: {
+                    ...identity,
+                    planIdentity: retained.identity,
+                    planFingerprint: fingerprint(retained.plan),
+                    previous: { ...previous, state: 'unavailable' },
+                    reason: 'humanPermissionGranted',
+                    evidence: 'typed-attention-approval',
+                },
+                commands: executor.commands?.map((command) => ['scheduled', 'issued'].includes(command.status)
+                    ? { ...command, status: 'superseded', updatedAt: now }
+                    : command),
+            },
+            updatedAt: now,
+        }, undefined, [
+            {
+                sessionId,
+                type: 'autopilot.executor-replacement-authorized',
+                payload: {
+                    canonicalTaskName,
+                    previousTaskName: previous.taskName,
+                    taskName: identity.taskName,
+                    generation: identity.generation,
+                    evidence: 'typed-attention-approval',
+                },
+                occurredAt: now,
+            },
+        ]);
+        return { accepted: true, identity };
+    }
     disable(sessionId) {
         const now = this.deps.now();
         const prior = this.deps.store.find(sessionId) ?? disabledAutopilot(sessionId, now);
@@ -421,6 +479,7 @@ export class AutopilotCoordinator {
                 if (this.deps.executorController &&
                     plan &&
                     !this.requiresRootBoundary(prior, plan) &&
+                    !this.executorDiagnosisRequired(prior) &&
                     this.currentExecutor(sessionId, plan, prior.consecutiveNoProgress, prior.executor)) {
                     this.enqueue(sessionId, async () => {
                         await this.enforceSupervisedLifecycle(sessionId, 'stateChanged');
@@ -885,15 +944,27 @@ export class AutopilotCoordinator {
             const cancelled = this.cancelScheduledControl(prior, now);
             const subagentsWorking = activity.aggregateSubagents === 'working' ||
                 activity.aggregateSubagents === 'awaitingAgent';
+            const supervision = subagentsWorking &&
+                Boolean(this.deps.session(sessionId)?.activeTurnId) &&
+                prior.supervision?.outcome === 'probeRequired'
+                ? reportProbe(prior.supervision, {
+                    id: `executor-actionable:${createHash('sha256')
+                        .update(this.progressKey(sessionId))
+                        .digest('hex')}`,
+                    kind: 'actionable',
+                })
+                : prior.supervision;
             if (cancelled ||
                 prior.state !== 'monitoring' ||
                 prior.nextEvaluationAt ||
-                (subagentsWorking && prior.consecutiveNoProgress > 0))
+                (subagentsWorking && prior.consecutiveNoProgress > 0) ||
+                supervision !== prior.supervision)
                 this.persist({
                     ...prior,
                     state: 'monitoring',
                     ...(cancelled ? { generation: prior.generation + 1, lastControlId: null } : {}),
                     ...(subagentsWorking ? { consecutiveNoProgress: 0 } : {}),
+                    ...(supervision ? { supervision } : {}),
                     nextEvaluationAt: null,
                     updatedAt: now,
                 }, cancelled);
@@ -1033,6 +1104,7 @@ export class AutopilotCoordinator {
             retained &&
             !current.executor?.replacement &&
             !this.requiresRootBoundary(current, retained.plan) &&
+            !this.executorDiagnosisRequired(current) &&
             this.currentExecutor(sessionId, retained.plan, current.consecutiveNoProgress, current.executor)) {
             const now = this.deps.now();
             const cancelled = this.cancelScheduledControl(current, now);
@@ -1047,7 +1119,12 @@ export class AutopilotCoordinator {
             await this.enforceSupervisedLifecycle(sessionId, 'stateChanged');
             return;
         }
-        const protocol = recordAutomaticContinuation(current.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId));
+        // Direct executor continuations account for their own accepted attempts.
+        // Once that bounded loop requests diagnosis, preserve the probe state for
+        // the root instead of counting the root control as another blind retry.
+        const protocol = this.executorDiagnosisRequired(current)
+            ? current.supervision
+            : recordAutomaticContinuation(current.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId));
         if (protocol.outcome === 'probeRequired') {
             this.persist({ ...current, supervision: protocol, updatedAt: this.deps.now() }, undefined, [
                 {
@@ -1224,6 +1301,8 @@ export class AutopilotCoordinator {
             case 'reinspect':
                 return false;
             case 'resumeExecutor':
+                if (this.executorDiagnosisRequired(this.deps.store.find(sessionId) ?? state))
+                    return false;
                 this.armExecutorContinuation(sessionId, decision.action.delayMs, decision.action.threadId, decision.action.generation, { kind: 'partial' });
                 return true;
             case 'monitorProcess': {
@@ -1258,7 +1337,7 @@ export class AutopilotCoordinator {
                         resultArtifact: processAction.resultArtifact,
                     });
                 if (consumed && executor)
-                    this.armExecutorContinuation(sessionId, this.deps.policy.executorContinuationBaseMs, executor.threadId, executor.continuationGeneration + 1, {
+                    this.armExecutorContinuation(sessionId, this.deps.policy.executorContinuationBaseMs, executor.threadId, executor.continuationGeneration + executor.continuationCount + 1, {
                         kind: 'processExited',
                         processId,
                         resultArtifact: processAction.resultArtifact,
@@ -1279,7 +1358,7 @@ export class AutopilotCoordinator {
                         reason: 'resourceBudget',
                     });
                 if (terminated && executor)
-                    this.armExecutorContinuation(sessionId, this.deps.policy.executorContinuationBaseMs, executor.threadId, executor.continuationGeneration + 1, { kind: 'processResourceLimit', processId });
+                    this.armExecutorContinuation(sessionId, this.deps.policy.executorContinuationBaseMs, executor.threadId, executor.continuationGeneration + executor.continuationCount + 1, { kind: 'processResourceLimit', processId });
                 else
                     this.armExecutorRefresh(sessionId, this.deps.policy.processPollMs);
                 return true;
@@ -1366,7 +1445,9 @@ export class AutopilotCoordinator {
             ownedProcesses: refreshPersistedProcesses(persisted?.canonicalPosition === canonicalPosition ? persisted.ownedProcesses : [], child.ownedProcesses ?? [], this.deps.now()),
             outcome: outcome.outcome,
             ...(outcome.blocking ? { blocking: outcome.blocking } : {}),
-            continuationGeneration: Math.max(child.continuationGeneration ?? 1, persisted?.canonicalPosition === canonicalPosition ? persisted.continuationGeneration : 1),
+            // The roster value and assignment identify the physical l<a>_gN slot.
+            // Logical follow-up attempts are tracked separately by continuationCount.
+            continuationGeneration: replacementChild || !assigned ? (child.continuationGeneration ?? 1) : assigned.generation,
             continuationCount: persisted?.canonicalPosition === canonicalPosition
                 ? persisted.continuationCount
                 : continuationCount,
@@ -1892,23 +1973,24 @@ export class AutopilotCoordinator {
         const armedChild = this.deps
             .activity(sessionId)
             ?.subagents.find((child) => (child.threadId ?? child.id) === threadId);
-        const fence = state && retained
+        const commandExecutor = state?.executor;
+        const fence = state && retained && commandExecutor
             ? {
                 sessionGeneration: state.generation,
                 planIdentity: retained.identity,
                 planFingerprint: fingerprint(retained.plan),
                 canonicalPosition: armedChild?.canonicalPosition ?? state.executor?.canonicalPosition ?? null,
                 executorThreadId: threadId,
-                executorGeneration: generation - 1,
+                // The roster generation identifies the physical l<a>_gN slot.
+                // A canonical executor can accept many logical follow-up turns, so
+                // never derive this ownership fence from the follow-up sequence.
+                executorGeneration: commandExecutor.assignment?.generation ?? commandExecutor.continuationGeneration,
                 supervisionOutcome: state.supervision?.outcome ?? null,
                 checkpoint: JSON.stringify(state.checkpoints ?? null),
                 boundaryState: state.state,
             }
             : null;
-        if (!fence || this.deps.session(sessionId)?.activeTurnId)
-            return;
-        const commandExecutor = state?.executor;
-        if (!commandExecutor)
+        if (!commandExecutor || !fence || this.deps.session(sessionId)?.activeTurnId)
             return;
         const requested = this.executorCommand(fence, commandExecutor, generation, trigger);
         const command = this.scheduleExecutorCommand(sessionId, requested);
@@ -1974,17 +2056,19 @@ export class AutopilotCoordinator {
                         trigger: trigger.kind,
                     });
                     const latest = this.deps.store.find(sessionId);
-                    if (latest?.requestedEnabled)
+                    if (latest?.requestedEnabled) {
+                        const progressKey = this.progressKey(sessionId);
+                        const supervision = recordAutomaticContinuation(latest.supervision ?? startSupervisionProtocol(progressKey), progressKey);
                         this.persist({
                             ...latest,
                             state: 'monitoring',
+                            supervision,
                             consecutiveNoProgress: latest.consecutiveNoProgress + 1,
                             ...(latest.executor
                                 ? {
                                     executor: {
                                         ...latest.executor,
                                         outcome: 'partial',
-                                        continuationGeneration: generation,
                                         continuationCount: latest.executor.continuationCount + 1,
                                         lastActivityAt: this.deps.now(),
                                     },
@@ -1993,6 +2077,7 @@ export class AutopilotCoordinator {
                             nextEvaluationAt: null,
                             updatedAt: this.deps.now(),
                         });
+                    }
                 }
                 catch (error) {
                     // Only an explicit app-server rejection is safe to retry. A lost
@@ -2085,6 +2170,9 @@ export class AutopilotCoordinator {
                 child.state === 'awaitingAgent' ||
                 child.ownedProcesses?.some((process) => process.state === 'running' || process.state === 'detached-active')));
     }
+    executorDiagnosisRequired(state) {
+        return state.supervision?.outcome === 'probeRequired';
+    }
     executorTurnActive(executor, activity) {
         if (activity?.confidence !== 'fresh')
             return false;

package/dist/server/server/features/autopilot/domain/supervised-lifecycle.js

@@ -179,7 +179,8 @@ export function parsePersistedSupervisedLifecycle(value) {
     const replacementPrevious = replacementPreviousValue
         ? parseExecutorAssignment(replacementPreviousValue)
         : undefined;
-    const replacementReason = replacementValue && stringValue(replacementValue.reason, ['explicitExecutorRejection']);
+    const replacementReason = replacementValue &&
+        stringValue(replacementValue.reason, ['explicitExecutorRejection', 'humanPermissionGranted']);
     const replacementEvidence = replacementValue && boundedText(replacementValue.evidence);
     if (!canonicalPosition ||
         !canonicalTaskName ||
@@ -200,7 +201,8 @@ export function parsePersistedSupervisedLifecycle(value) {
                 !replacementPlanIdentity ||
                 !replacementPlanFingerprint ||
                 (replacementValue.previous !== undefined && !replacementPrevious) ||
-                (replacementReason !== undefined && replacementReason !== 'explicitExecutorRejection') ||
+                (replacementReason !== undefined &&
+                    !['explicitExecutorRejection', 'humanPermissionGranted'].includes(replacementReason)) ||
                 (replacementValue.evidence !== undefined && !replacementEvidence))))
         return undefined;
     if (replacementValue) {
@@ -304,7 +306,10 @@ export function parsePersistedSupervisedLifecycle(value) {
             ownedProcesses,
             outcome,
             ...(executorBlocking ? { blocking: executorBlocking } : {}),
-            continuationGeneration,
+            // Earlier releases incremented this value after every follow-up, even
+            // though the roster derives it from the immutable physical task name. A
+            // durable assignment is authoritative during reconciliation.
+            continuationGeneration: assignment?.generation ?? continuationGeneration,
             continuationCount,
             ...(resumeFailures ? { resumeFailures } : {}),
             ...(assignment ? { assignment } : {}),
@@ -537,7 +542,7 @@ export function decideSupervisedLifecycle(input) {
         action: {
             kind: 'resumeExecutor',
             threadId: input.executor.threadId,
-            generation: input.executor.continuationGeneration + 1,
+            generation: input.executor.continuationGeneration + input.executor.continuationCount + 1,
             delayMs,
         },
     };

package/dist/server/server/features/org-plan-attention/resolve/endpoint.js

@@ -34,9 +34,11 @@ export function registerResolveOrgPlanAttention(app, deps) {
                 ? 'ATTENTION_OPERATION_STALE'
                 : outcome.kind === 'legacyUnsupported'
                     ? 'ATTENTION_LEGACY_UNSUPPORTED'
-                    : outcome.kind === 'writerCleared'
-                        ? 'ATTENTION_WRITER_CLEARED'
-                        : 'ATTENTION_WRITER_UNAVAILABLE';
+                    : outcome.kind === 'replacementRejected'
+                        ? 'EXECUTOR_REPLACEMENT_NOT_AUTHORIZED'
+                        : outcome.kind === 'writerCleared'
+                            ? 'ATTENTION_WRITER_CLEARED'
+                            : 'ATTENTION_WRITER_UNAVAILABLE';
         return reply.code(outcome.kind === 'noActive' ? 404 : 409).send({ code });
     });
 }

package/dist/server/server/features/org-plan-checkpoint/application/validate.js

@@ -3,8 +3,13 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+/** Terminal roster entries remain visible and are not active implementation writers. */
+export function hasActiveL1Writer(snapshot, position) {
+    return snapshot.subagents.some((child) => child.canonicalPosition === position &&
+        ['working', 'awaitingAgent', 'awaitingHuman'].includes(child.state));
+}
 /** Expands a host-owned compact boundary signal from authoritative plan state. */
-export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity) {
+export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity, publicationReason = null) {
     if (kind === 'terminalReviewAccepted')
         return {
             version: 1,
@@ -12,8 +17,16 @@ export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity) {
             planIdentity,
             verdict: 'ACCEPT',
         };
-    const selected = plan.steps.find((step) => step.id === plan.currentStepId) ??
-        [...plan.steps].reverse().find((step) => step.state === 'DONE' || step.state === 'WIP');
+    const reviewedId = publicationReason?.match(/^review:([^:]{1,128}):REVIEWED$/)?.[1];
+    const selected = kind === 'l1Accepted'
+        ? ((reviewedId
+            ? plan.steps.find((step) => step.id === reviewedId && step.state === 'DONE' && step.reviewStatus === 'REVIEWED')
+            : undefined) ??
+            [...plan.steps]
+                .reverse()
+                .find((step) => step.state === 'DONE' && step.reviewStatus === 'REVIEWED'))
+        : (plan.steps.find((step) => step.id === plan.currentStepId) ??
+            [...plan.steps].reverse().find((step) => step.state === 'DONE' || step.state === 'WIP'));
     if (!selected)
         return null;
     const l1Position = `L${plan.steps.indexOf(selected) + 1}`;
@@ -44,25 +57,80 @@ export function resolveOrgPlanCheckpointSignal(kind, plan, planIdentity) {
     };
 }
 export function validOrgPlanCheckpoint(input) {
+    return validateOrgPlanCheckpoint(input).valid;
+}
+export function validateOrgPlanCheckpoint(input) {
     const { checkpoint, plan, planIdentity, rootOwned } = input;
-    if (!rootOwned || checkpoint.planIdentity !== planIdentity)
-        return false;
+    if (!rootOwned)
+        return { valid: false, reasonCode: 'rootNotOwner' };
+    if (checkpoint.planIdentity !== planIdentity)
+        return { valid: false, reasonCode: 'planIdentityMismatch' };
     if (checkpoint.kind === 'terminalReviewAccepted')
-        return plan.steps.every((step) => step.state === 'DONE' && step.reviewStatus === 'REVIEWED');
+        return plan.steps.every((step) => step.state === 'DONE' && step.reviewStatus === 'REVIEWED')
+            ? { valid: true }
+            : { valid: false, reasonCode: 'terminalReviewIncomplete' };
     const l1 = plan.steps.find((step) => step.id === checkpoint.l1Id);
     if (!l1)
-        return false;
+        return { valid: false, reasonCode: 'l1NotFound' };
     const position = `L${plan.steps.indexOf(l1) + 1}`;
     if (checkpoint.kind === 'l2Completed') {
         const l2 = l1.children.find((step) => step.id === checkpoint.l2Id);
         if (!l2)
-            return false;
-        return (checkpoint.position === `${position}.${l1.children.indexOf(l2) + 1}` &&
-            l2.state === 'DONE' &&
-            l1.reviewStatus === 'UNREVIEWED');
+            return { valid: false, reasonCode: 'l2NotFound' };
+        const expectedPosition = `${position}.${l1.children.indexOf(l2) + 1}`;
+        if (checkpoint.position !== expectedPosition)
+            return {
+                valid: false,
+                reasonCode: 'checkpointPositionMismatch',
+                expected: { position: expectedPosition },
+                observed: { position: checkpoint.position },
+            };
+        if (l2.state !== 'DONE')
+            return {
+                valid: false,
+                reasonCode: 'l2NotDone',
+                expected: { l2State: 'DONE' },
+                observed: { l2State: l2.state },
+            };
+        return l1.reviewStatus === 'UNREVIEWED'
+            ? { valid: true }
+            : { valid: false, reasonCode: 'l1AlreadyReviewed' };
     }
-    return (checkpoint.position === position &&
-        l1.state === 'DONE' &&
-        l1.reviewStatus === 'REVIEWED' &&
-        !input.hasActiveL1Writer(position));
+    if (checkpoint.position !== position)
+        return {
+            valid: false,
+            reasonCode: 'checkpointPositionMismatch',
+            expected: { position },
+            observed: { position: checkpoint.position },
+        };
+    if (l1.state !== 'DONE')
+        return {
+            valid: false,
+            reasonCode: 'l1NotDone',
+            expected: { l1State: 'DONE' },
+            observed: { l1State: l1.state },
+        };
+    if (l1.reviewStatus !== 'REVIEWED')
+        return {
+            valid: false,
+            reasonCode: 'l1NotReviewed',
+            expected: { reviewStatus: 'REVIEWED' },
+            observed: { reviewStatus: l1.reviewStatus ?? null },
+        };
+    const incompleteChild = l1.children.find((child) => child.state !== 'DONE');
+    if (incompleteChild)
+        return {
+            valid: false,
+            reasonCode: 'l1ChildrenIncomplete',
+            expected: { childrenDone: true },
+            observed: { childrenDone: false, childState: incompleteChild.state },
+        };
+    if (input.hasActiveL1Writer(position))
+        return {
+            valid: false,
+            reasonCode: 'executorStillActive',
+            expected: { executorTerminal: true },
+            observed: { executorTerminal: false },
+        };
+    return { valid: true };
 }

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

@@ -8,7 +8,11 @@ export class SupervisedPlanRegistry {
     plans = new Map();
     accept(sessionId, update) {
         if (update.kind === 'updated')
-            this.plans.set(sessionId, { plan: update.plan, identity: update.identity });
+            this.plans.set(sessionId, {
+                plan: update.plan,
+                identity: update.identity,
+                publicationReason: update.reason,
+            });
     }
     find(sessionId) {
         return this.plans.get(sessionId)?.plan ?? null;
@@ -16,6 +20,9 @@ export class SupervisedPlanRegistry {
     identity(sessionId) {
         return this.plans.get(sessionId)?.identity ?? null;
     }
+    publicationReason(sessionId) {
+        return this.plans.get(sessionId)?.publicationReason ?? null;
+    }
     clear(sessionId) {
         this.plans.delete(sessionId);
     }

package/dist/server/server/features/skills/list-available/endpoint.js

@@ -40,7 +40,8 @@ export function registerListAvailableSkills(app, deps) {
             return {
                 source: project ? 'project' : 'native',
                 errors: discovered.errors.map(({ message }) => ({ message })),
-                skills: [...skills]
+                skills: skills
+                    .filter((skill) => !isAlwaysAdvertisedSkill(skill))
                     .sort((left, right) => left.path.localeCompare(right.path))
                     .map((skill) => ({
                     name: skill.name,

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

@@ -56,7 +56,10 @@ export const availableSkillSchema = z
     .strict();
 /** Gestalt workflow skills are session infrastructure, not optional profile entries. */
 export function isAlwaysAdvertisedSkill(skill) {
-    return skill.name.startsWith('gestalt:');
+    return isGestaltSkillName(skill.name);
+}
+export function isGestaltSkillName(name) {
+    return name.startsWith('gestalt:');
 }
 const profileDocumentSchema = z
     .object({
@@ -195,8 +198,6 @@ export function reconcileSkillSelectionSnapshot(discovered, selection) {
  */
 export function compileSkillOverride(input) {
     const effective = selectEffectiveSkillSelection(input);
-    if (effective.selection === undefined)
-        return { source: 'native', skillsConfig: undefined, warnings: [] };
     const reconciled = reconcileSkillSelectionSnapshot(input.discovered, effective.selection);
     return {
         source: effective.source,
@@ -211,7 +212,10 @@ export function createSkillProfile(input) {
     return {
         version: 1,
         name: normalizeSkillProfileName(input.name),
-        skills: createSkillSelection(input.skills),
+        // Gestalt skills are mandatory thread infrastructure. Legacy profiles are
+        // normalized on read so they cannot pin a stale plugin-cache version or
+        // expose a meaningless enable/disable control in the editor.
+        skills: createSkillSelection(input.skills.filter((skill) => !isGestaltSkillName(skill.name))),
     };
 }
 /** Parse the version-1 YAML document without performing filesystem access. */

package/dist/server/server/platform/catalog/profile-command.js

@@ -3,16 +3,6 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-export function profileAppServerCommand(skillsConfig) {
-    const base = { command: 'codex', args: ['app-server', '--stdio'] };
-    return skillsConfig === undefined
-        ? base
-        : {
-            ...base,
-            args: [
-                ...base.args,
-                '--config',
-                `skills.config = [${skillsConfig.map((entry) => `{ path = ${JSON.stringify(entry.path)}, enabled = ${entry.enabled} }`).join(', ')}]`,
-            ],
-        };
+export function profileAppServerCommand() {
+    return { command: 'codex', args: ['app-server', '--stdio'] };
 }

package/dist/server/server/platform/codex/codex-process-launcher.js

@@ -7,7 +7,7 @@ import { spawn } from 'node:child_process';
 import { JsonRpcClient } from './json-rpc-client.js';
 import { profileAppServerCommand } from '../catalog/profile-command.js';
 export function launchCodexAppServer(input) {
-    const launch = profileAppServerCommand(input.skillsConfig);
+    const launch = profileAppServerCommand();
     const child = spawn(launch.command, launch.args, {
         cwd: input.cwd,
         env: codexChildEnvironment(input.environment),

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/server/platform/persistence/sqlite-pending-interaction-store.js

@@ -17,16 +17,22 @@ export class SqlitePendingInteractionStore {
     constructor(db) {
         this.db = db;
     }
-    add(sessionId, interaction) {
+    add(sessionId, interaction, initialResolutionState = 'active') {
         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,resolution_state)
+         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, operation_key = NULL,
-           resolution_state = 'active'
+           resolution_state = excluded.resolution_state
          WHERE pending_interactions.kind != 'orgPlanAttention'`)
-            .run(sessionId, interaction.requestId, interaction.kind, JSON.stringify(interaction.payload), interaction.turnId ?? null, interaction.requestedAt ?? null);
+            .run(sessionId, interaction.requestId, interaction.kind, JSON.stringify(interaction.payload), interaction.turnId ?? null, interaction.requestedAt ?? null, initialResolutionState);
+    }
+    resolutionState(sessionId, requestId) {
+        const row = this.db
+            .prepare('SELECT resolution_state FROM pending_interactions WHERE session_id = ? AND request_id = ? AND resolved_at IS NULL')
+            .get(sessionId, requestId);
+        return row?.resolution_state ?? null;
     }
     resolve(sessionId, requestId, resolvedAt, outcome = 'answered') {
         return (this.db
@@ -56,7 +62,7 @@ export class SqlitePendingInteractionStore {
     /** Persist the in-flight delivery boundary before the app-server is notified. */
     beginDelivery(sessionId, requestId, operationKey) {
         return (this.db
-            .prepare("UPDATE pending_interactions SET resolution_state = 'delivering' WHERE session_id = ? AND request_id = ? AND operation_key = ? AND resolved_at IS NULL AND resolution_state IN ('active','delivering')")
+            .prepare("UPDATE pending_interactions SET resolution_state = 'delivering' WHERE session_id = ? AND request_id = ? AND operation_key = ? AND resolved_at IS NULL AND resolution_state IN ('active','acknowledged','delivering')")
             .run(sessionId, requestId, operationKey).changes === 1);
     }
     /** A local writer outage is retryable only by the already-claimed key. */