gestalt-mobile 0.41.2 → 0.41.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-9uZwieND.js"></script>
+    <script type="module" crossorigin src="/assets/index-BRly-q56.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D57mr3B1.css">
   </head>
   <body>

package/dist/server/server/composition.contracts.js

@@ -12,7 +12,7 @@ import { join } from 'node:path';
 import { describe, expect, it, onTestFinished, vi } from 'vitest';
 import WebSocket from 'ws';
 import { composeRelayApp } from './composition.js';
-import { AUTOPILOT_CONTINUATION_PROMPT } from './features/autopilot/application/policy.js';
+import { autopilotExecutorLaunchPrompt } from './features/autopilot/application/policy.js';
 import { CodexJsonRpcError } from './platform/codex/json-rpc-client.js';
 import { SqliteAuthorizationStore } from './platform/auth/sqlite-authorization-store.js';
 import { authorizationSessionId, authorizedDeviceId, localOwnerId, webAuthnCredentialId, } from './features/auth/domain/identifiers.js';
@@ -497,7 +497,12 @@ describe('production composition', () => {
                 input: [
                     {
                         type: 'text',
-                        text: `${AUTOPILOT_CONTINUATION_PROMPT} Launch task_name l1 for canonical L1; retain the canonical label in status and review output.`,
+                        text: autopilotExecutorLaunchPrompt({
+                            canonicalTaskName: 'l1',
+                            canonicalPosition: 'L1',
+                            generation: 1,
+                            taskName: 'l1',
+                        }),
                         text_elements: [],
                     },
                 ],
@@ -1455,7 +1460,7 @@ describe('production composition', () => {
                 .filter((request) => request.method === 'turn/start')).toHaveLength(startsAfterFinal);
             await fixture.app.close();
         });
-        it('production attention request requires explicit re-enable and a complete plan transitions to completed', async () => {
+        it('production attention approval resumes Autopilot and a complete plan transitions to completed', async () => {
             const fixture = await createProductionAutopilotFixture();
             const handle = fixture.handles.find((candidate) => candidate.request);
             expect((await fixture.app.inject({
@@ -1474,15 +1479,6 @@ describe('production composition', () => {
                 url: `/api/sessions/${fixture.sessionId}/attention/810/resolve`,
                 payload: { operationKey: 'resume-attention', action: 'resume' },
             })).statusCode).toBe(202);
-            await new Promise((resolve) => setTimeout(resolve, 25));
-            expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
-                autopilot: { state: 'attentionRequired', enabled: false },
-            });
-            expect((await fixture.app.inject({
-                method: 'PUT',
-                url: `/api/sessions/${fixture.sessionId}/autopilot`,
-                payload: { enabled: true },
-            })).statusCode).toBe(200);
             await vi.waitFor(async () => expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
                 autopilot: { enabled: true, state: expect.stringMatching(/monitoring|backoff/) },
             }));
@@ -1770,7 +1766,7 @@ describe('production composition', () => {
             // rejected child continuation; it must never target the dead child.
             expect((starts[3]?.params).threadId).not.toBe('child-1');
             expect((starts[3]?.params).input?.[0]?.text).toContain('Launch task_name l1_g2 for canonical L1');
-            expect((starts[3]?.params).input?.[0]?.text).toContain('explicit model selected by the supervisor');
+            expect((starts[3]?.params).input?.[0]?.text).toContain('agent_type org-plan-executor and reasoning_effort high');
             // Capacity recovery is allowed only for the active root control. It
             // recycles that writer but must retain the one durable g2 handoff.
             const rootHandle = fixture.handles.find((candidate) => candidate.requests.some((request) => request.method === 'turn/start' &&

package/dist/server/server/composition.js

@@ -66,7 +66,7 @@ import { AutopilotCoordinator } from './features/autopilot/application/service.j
 import { deriveSessionStatus } from './features/sessions/session-status.js';
 import { AUTOPILOT_CONTINUATION_PROMPT, AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT, autopilotExecutorLaunchPrompt, defaultAutopilotPolicy, } from './features/autopilot/application/policy.js';
 import { createRelyingPartyConfig } from './config.js';
-import { parseOrgPlanAttention, toOrgPlanAttentionAcknowledgement, } from '../shared/contracts/org-plan-attention.js';
+import { parseOrgPlanAttention, parseOrgPlanAttentionToolResponse, toOrgPlanAttentionAcknowledgement, } from '../shared/contracts/org-plan-attention.js';
 import { autopilotWaitLeaseToolResponse, } from '../shared/contracts/autopilot-wait-lease.js';
 import { agentCapacityRecoveryToolResponse } from '../shared/contracts/agent-capacity-recovery.js';
 import { pwaIconUrl } from './features/pwa/register-routes.js';
@@ -400,8 +400,6 @@ export async function composeRelayApp(options) {
                 explicit: session.effectiveSkillSelection.skills,
             }).skillsConfig;
         const project = await skillProfiles.readWorkspaceDefault(session.workspacePath);
-        if (!options.explicitSkillProfile && !project)
-            return undefined;
         return compileSkillOverride({
             discovered: catalog.skills,
             explicit: options.explicitSkillProfile?.skills,
@@ -1433,6 +1431,10 @@ export async function composeRelayApp(options) {
                             const interaction = interactions.find(sessionId, requestId);
                             if (!interaction || interaction.kind !== 'orgPlanAttention')
                                 return { kind: 'noActive' };
+                            const decision = parseOrgPlanAttentionToolResponse(response);
+                            const attention = parseOrgPlanAttention(interaction.payload);
+                            if (!decision || !attention)
+                                return { kind: 'staleOperation' };
                             const claim = interactions.claimOperation(sessionId, requestId, operationKey);
                             if (claim === 'resolved') {
                                 const resolved = interactions.resolved(sessionId, requestId);
@@ -1448,12 +1450,23 @@ export async function composeRelayApp(options) {
                             if (acknowledged) {
                                 if (!interactions.beginDelivery(sessionId, requestId, operationKey))
                                     return { kind: 'staleOperation' };
+                                if (decision.action === 'resume' && attention.executorReplacement) {
+                                    const authorization = autopilot.authorizeExecutorReplacement(sessionId, attention.executorReplacement.canonicalTaskName);
+                                    if (!authorization.accepted) {
+                                        interactions.retryDelivery(sessionId, requestId, operationKey);
+                                        return { kind: 'replacementRejected' };
+                                    }
+                                }
                                 const resolvedAt = new Date().toISOString();
                                 if (!interactions.settleOperation(sessionId, requestId, operationKey, resolvedAt, 'answered'))
                                     return { kind: 'staleOperation' };
                                 const accepted = { kind: 'accepted', resolvedAt };
                                 idempotency.put(scope, operationKey, 202, JSON.stringify({ kind: 'replayed', resolvedAt }));
                                 publishAttentionSettlement(sessionId, requestId, resolvedAt, 'answered');
+                                if (decision.action === 'disableAutopilot')
+                                    autopilot.disable(sessionId);
+                                else
+                                    autopilot.enable(sessionId);
                                 return accepted;
                             }
                             // A durable capability belongs to the session/thread, not the
@@ -1465,6 +1478,13 @@ export async function composeRelayApp(options) {
                                 return { kind: 'writerUnavailable' };
                             if (!interactions.beginDelivery(sessionId, requestId, operationKey))
                                 return { kind: 'staleOperation' };
+                            if (decision.action === 'resume' && attention.executorReplacement) {
+                                const authorization = autopilot.authorizeExecutorReplacement(sessionId, attention.executorReplacement.canonicalTaskName);
+                                if (!authorization.accepted) {
+                                    interactions.retryDelivery(sessionId, requestId, operationKey);
+                                    return { kind: 'replacementRejected' };
+                                }
+                            }
                             const writer = runtime.attentionWriterState(sessionId, requestId);
                             if (writer === 'unavailable') {
                                 interactions.retryDelivery(sessionId, requestId, operationKey);
@@ -1488,6 +1508,10 @@ export async function composeRelayApp(options) {
                             const accepted = { kind: 'accepted', resolvedAt };
                             idempotency.put(scope, operationKey, 202, JSON.stringify({ kind: 'replayed', resolvedAt }));
                             publishAttentionSettlement(sessionId, requestId, resolvedAt, 'answered');
+                            if (decision.action === 'disableAutopilot')
+                                autopilot.disable(sessionId);
+                            else
+                                autopilot.enable(sessionId);
                             return accepted;
                         })();
                         attentionResolutionOperations.set(key, operation);

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

@@ -3,15 +3,15 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-export const AUTOPILOT_PROMPT_VERSION = 'v11';
-export const AUTOPILOT_CONTINUATION_PROMPT = 'Inspect the active supervised Org Plan. Refer to every L1 as L<a> and each nested L2 as L<a>.<b>, using one-based positions. Spawn exactly one executor per L1 and pass the exact literal task_name l<a>: l1 for L1, l2 for L2, and so on. Never create an L2-specific task name or append a title, role, nickname, plan name, or generated label. A validated DONE L2 and an accepted L1 are mandatory answer boundaries. The corresponding gestalt_org_plan_checkpoint call must be the last tool call of that root turn: immediately emit exactly one boundary final and end the turn, without followup_task, review, executor launch, or later milestone work. Roll up commentary, files, verification, and commands since the previous boundary into that one answer; all later milestone activity belongs to a new root turn. On this later Autopilot turn, resume the same executor after an L2 boundary or launch the next executor after an accepted-L1 boundary. Treat a status question as an interruption: answer briefly, then perform the applicable continuation in the same turn. Before sending any blocker response or yielding because progress cannot continue safely, call gestalt_org_plan_attention for the matching decision-table blocker; never rely on blocker prose as the signal. Do not call it for routine progress or a recoverable failure. Before yielding for known long work, call gestalt_autopilot_wait_lease version 2 with relevant observable wake conditions and a bounded maxWaitMs; it is one episode, so reassess before registering another in a later turn. Yield only when its response contains accepted:true; accepted:false means no continuation was registered and requires same-turn supervision. For GitHub PR CI, start an owned gh pr checks --watch process and lease processExited plus processResultAvailable while it runs. When the Autopilot probe is active, register the compatible wait lease, declare genuine attention, or immediately do actionable work; never acknowledge waiting in prose. Do not send a status-only response.';
+export const AUTOPILOT_PROMPT_VERSION = 'v13';
+export const AUTOPILOT_CONTINUATION_PROMPT = 'Inspect the active supervised Org Plan. Refer to every L1 as L<a> and each nested L2 as L<a>.<b>, using one-based positions. Spawn exactly one executor per L1 and pass the exact literal task_name l<a>: l1 for L1, l2 for L2, and so on. Never create an L2-specific task name or append a title, role, nickname, plan name, or generated label. A validated DONE L2 and an accepted L1 are mandatory answer boundaries. The corresponding gestalt_org_plan_checkpoint call must be the last tool call of that root turn: immediately emit exactly one boundary final and end the turn, without followup_task, review, executor launch, or later milestone work. An accepted L1 always ends the root turn with a chat answer: never continue into the next L1 or emit post-acceptance documentation as commentary. Roll up commentary, files, verification, and commands since the previous boundary into that one answer; all later milestone activity belongs to a new root turn. On this later Autopilot turn, resume the same executor after an L2 boundary or launch exactly one fresh canonical executor for the next L1 after an accepted-L1 boundary. Treat a status question as an interruption: answer briefly, then perform the applicable continuation in the same turn. Before sending any blocker response or yielding because progress cannot continue safely, call gestalt_org_plan_attention for the matching decision-table blocker; never rely on blocker prose as the signal. When explicit human permission is required for a physical executor replacement, include executorReplacement with the exact canonicalTaskName; Mobile alone computes and persists the physical generation. Do not call attention for routine progress or a recoverable failure. Before yielding for known long work, call gestalt_autopilot_wait_lease version 2 with relevant observable wake conditions and a bounded maxWaitMs; it is one episode, so reassess before registering another in a later turn. Yield only when its response contains accepted:true; accepted:false means no continuation was registered and requires same-turn supervision. For GitHub PR CI, start an owned gh pr checks --watch process and lease processExited plus processResultAvailable while it runs. When the Autopilot probe is active, register the compatible wait lease, declare genuine attention, or immediately do actionable work; never acknowledge waiting in prose. Do not send a status-only response.';
 export const AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT = 'Continue the same assigned Org L1 from its durable state. A prior turn ending did not complete the objective. Consume any supplied process result and take the next legal L2 action. Whenever an L2 reaches DONE, return its concise structured evidence and end the executor turn so the root can publish that mandatory answer boundary. Also report at the L1 review boundary or through structured attention.';
 /** Builds a physical launch instruction while keeping durable L1 identity canonical. */
 export function autopilotExecutorLaunchPrompt(identity) {
-    const launch = `Launch task_name ${identity.taskName} for canonical ${identity.canonicalPosition}; retain the canonical label in status and review output.`;
+    const launch = `Launch task_name ${identity.taskName} for canonical ${identity.canonicalPosition} with agent_type org-plan-executor and reasoning_effort high; the profile selects gpt-5.6-terra by default, so do not override its model. Retain the canonical label in status and review output.`;
     if (identity.generation === 1)
         return `${AUTOPILOT_CONTINUATION_PROMPT} ${launch}`;
-    return `${AUTOPILOT_CONTINUATION_PROMPT} ${launch} This exact replacement generation ${identity.generation} is durably authorized by Mobile; do not infer another generation from this prompt or the roster; the durable ${identity.canonicalTaskName} slot may remain reserved. Do not reuse that task_name or attempt to change an existing agent's model in place. Interrupt the previous physical executor if it is still running, then spawn ${identity.taskName} with agent_type worker and an explicit model selected by the supervisor. Transfer sole ${identity.canonicalPosition} ownership and continue from its durable Org Plan and worktree state.`;
+    return `${AUTOPILOT_CONTINUATION_PROMPT} ${launch} This exact replacement generation ${identity.generation} is durably authorized by Mobile; do not infer another generation from this prompt or the roster; the durable ${identity.canonicalTaskName} slot may remain reserved. Do not reuse that task_name or attempt to change an existing agent's model in place. Interrupt the previous physical executor if it is still running, then spawn the authorized ${identity.taskName}. Transfer sole ${identity.canonicalPosition} ownership and continue from its durable Org Plan and worktree state.`;
 }
 export const defaultAutopilotPolicy = Object.freeze({
     quiescenceMs: 1_000,

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/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);
             });