gestalt-mobile 0.41.2 → 0.42.0

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');
@@ -466,7 +525,12 @@ export class AutopilotCoordinator {
                     {
                         sessionId,
                         type: 'autopilot.continuation-scheduled',
-                        payload: { controlId: scheduledControlId },
+                        payload: {
+                            controlId: scheduledControlId,
+                            ...(prior.checkpoints?.activeHandoffId
+                                ? { traceId: prior.checkpoints.activeHandoffId }
+                                : {}),
+                        },
                         occurredAt: now,
                     },
                 ]);
@@ -580,7 +644,12 @@ export class AutopilotCoordinator {
                         : pendingKind === 'terminalReviewAccepted'
                             ? 'org-plan.terminal-review-reported'
                             : 'org-plan.milestone-reported',
-                    payload: { turnId: state.checkpoints.pendingTurnId },
+                    payload: {
+                        turnId: state.checkpoints.pendingTurnId,
+                        ...(state.checkpoints.activeHandoffId
+                            ? { traceId: state.checkpoints.activeHandoffId }
+                            : {}),
+                    },
                     occurredAt,
                 },
             ]);
@@ -641,6 +710,7 @@ export class AutopilotCoordinator {
             ...(previous?.completionEpochs ?? []).filter((entry) => entry.target !== target),
             { target, epoch, reopened: false, completed: true },
         ];
+        const handoffId = `handoff-${key.slice(0, 24)}`;
         const checkpoints = {
             protocolVersion: 1,
             planIdentity: retained.identity,
@@ -651,6 +721,7 @@ export class AutopilotCoordinator {
                 : reportedL1Ids,
             acceptedKeys: boundedUnique([...acceptedKeys, key], 768),
             pendingTurnId: turnId,
+            activeHandoffId: handoffId,
             pendingKind: checkpoint.kind,
             checkpointHandoffFailed: false,
             terminalReviewAccepted: checkpoint.kind === 'terminalReviewAccepted' || previous?.terminalReviewAccepted === true,
@@ -687,10 +758,16 @@ export class AutopilotCoordinator {
                         l2Id: checkpoint.l2Id,
                         position: checkpoint.position,
                         turnId,
+                        traceId: handoffId,
                     }
                     : checkpoint.kind === 'l1Accepted'
-                        ? { l1Id: checkpoint.l1Id, position: checkpoint.position, turnId }
-                        : { turnId },
+                        ? {
+                            l1Id: checkpoint.l1Id,
+                            position: checkpoint.position,
+                            turnId,
+                            traceId: handoffId,
+                        }
+                        : { turnId, traceId: handoffId },
                 occurredAt,
             },
         ]);
@@ -885,15 +962,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);
@@ -959,7 +1048,17 @@ export class AutopilotCoordinator {
         const issuedControl = { ...priorControl, status: 'issued', updatedAt: now };
         const events = [
             ...this.snapshotEvents(next, issuedControl),
-            { sessionId, type: 'autopilot.control-issued', payload: { controlId }, occurredAt: now },
+            {
+                sessionId,
+                type: 'autopilot.control-issued',
+                payload: {
+                    controlId,
+                    ...(prior.checkpoints?.activeHandoffId
+                        ? { traceId: prior.checkpoints.activeHandoffId }
+                        : {}),
+                },
+                occurredAt: now,
+            },
         ];
         const control = this.deps.store.claimControlIssued
             ? this.deps.store.claimControlIssued(sessionId, controlId, now, next, events)
@@ -1033,6 +1132,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 +1147,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 +1329,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 +1365,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 +1386,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 +1473,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 +2001,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 +2084,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 +2105,7 @@ export class AutopilotCoordinator {
                             nextEvaluationAt: null,
                             updatedAt: this.deps.now(),
                         });
+                    }
                 }
                 catch (error) {
                     // Only an explicit app-server rejection is safe to retry. A lost
@@ -2055,8 +2168,19 @@ export class AutopilotCoordinator {
                         sessionId,
                         type: eventType,
                         payload: eventType === 'autopilot.turn-failed'
-                            ? { controlId, code: failureCode }
-                            : { controlId },
+                            ? {
+                                controlId,
+                                code: failureCode,
+                                ...(this.deps.store.find(sessionId)?.checkpoints?.activeHandoffId
+                                    ? { traceId: this.deps.store.find(sessionId).checkpoints.activeHandoffId }
+                                    : {}),
+                            }
+                            : {
+                                controlId,
+                                ...(this.deps.store.find(sessionId)?.checkpoints?.activeHandoffId
+                                    ? { traceId: this.deps.store.find(sessionId).checkpoints.activeHandoffId }
+                                    : {}),
+                            },
                         occurredAt,
                     },
                 ]
@@ -2085,6 +2209,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 } : {}),
@@ -385,6 +390,11 @@ function parseCheckpoints(value) {
     const pendingTurnId = value.pendingTurnId === null ? null : boundedText(value.pendingTurnId);
     if (pendingTurnId === undefined)
         return undefined;
+    const activeHandoffId = value.activeHandoffId === undefined || value.activeHandoffId === null
+        ? null
+        : boundedText(value.activeHandoffId);
+    if (activeHandoffId === undefined)
+        return undefined;
     if (value.checkpointHandoffFailed !== undefined &&
         typeof value.checkpointHandoffFailed !== 'boolean')
         return undefined;
@@ -432,6 +442,7 @@ function parseCheckpoints(value) {
         reportedL1Ids,
         acceptedKeys,
         pendingTurnId,
+        ...(activeHandoffId ? { activeHandoffId } : {}),
         pendingKind: pendingKind,
         ...(value.checkpointHandoffFailed === undefined
             ? {}
@@ -537,7 +548,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/control-plane-trace/export-trace.js

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { DatabaseSync } from 'node:sqlite';
+const relevant = /^(?:org-plan\.|autopilot\.|agent\.activity\.|session\.status\.)/;
+function objectPayload(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function correlation(payload) {
+    for (const key of ['traceId', 'handoffId', 'controlId', 'turnId', 'requestId'])
+        if (typeof payload[key] === 'string' && payload[key])
+            return String(payload[key]);
+    return null;
+}
+function diagnose(events) {
+    const diagnoses = [];
+    if (!events.length)
+        return ['no control-plane events found for this session'];
+    const checkpointIndex = events.findLastIndex((event) => event.type.endsWith('-checkpointed'));
+    const currentHandoff = checkpointIndex < 0 ? events : events.slice(checkpointIndex);
+    const types = new Set(currentHandoff.map((event) => event.type));
+    if ([...types].some((type) => type.endsWith('-checkpointed')) &&
+        !types.has('autopilot.continuation-scheduled'))
+        diagnoses.push('checkpoint persisted, but no continuation was scheduled');
+    if (types.has('autopilot.continuation-scheduled') &&
+        !types.has('autopilot.control-issued') &&
+        !types.has('autopilot.executor-resumed'))
+        diagnoses.push('continuation scheduled, but no control or executor dispatch was observed');
+    if (types.has('autopilot.control-issued') &&
+        !types.has('autopilot.turn-started') &&
+        !types.has('autopilot.turn-failed'))
+        diagnoses.push('control issued, but no turn acceptance or failure was observed');
+    if (types.has('org-plan.checkpoint-handoff-failed'))
+        diagnoses.push('checkpoint response handoff failed; inspect the matching trace ID');
+    if (currentHandoff.some((event) => event.type === 'agent.activity.updated'))
+        diagnoses.push('backend agent projection was recorded; browser delivery still requires the client event cursor');
+    return diagnoses;
+}
+export function exportControlPlaneTrace(databasePath, sessionId, generatedAt = new Date().toISOString()) {
+    const database = new DatabaseSync(databasePath, { readOnly: true });
+    try {
+        const rows = database
+            .prepare('SELECT sequence,occurred_at,type,payload_json FROM session_events WHERE session_id = ? ORDER BY sequence')
+            .all(sessionId);
+        const events = rows
+            .filter((row) => relevant.test(row.type))
+            .map((row) => {
+            const payload = objectPayload(row.payload_json);
+            return {
+                sequence: row.sequence,
+                occurredAt: row.occurred_at,
+                type: row.type,
+                payload,
+                traceId: correlation(payload),
+            };
+        });
+        return { schemaVersion: 1, sessionId, generatedAt, events, diagnoses: diagnose(events) };
+    }
+    finally {
+        database.close();
+    }
+}
+export function formatControlPlaneTrace(trace) {
+    const lines = [
+        `Control-plane trace for ${trace.sessionId}`,
+        `Generated: ${trace.generatedAt}`,
+        '',
+    ];
+    for (const event of trace.events) {
+        const correlationLabel = event.traceId ? ` trace=${event.traceId}` : '';
+        lines.push(`${String(event.sequence).padStart(6)}  ${event.occurredAt}  ${event.type}${correlationLabel}`);
+    }
+    lines.push('', 'Diagnosis:');
+    if (!trace.diagnoses.length)
+        lines.push('  No incomplete control-plane transition detected.');
+    else
+        for (const diagnosis of trace.diagnoses)
+            lines.push(`  - ${diagnosis}`);
+    return `${lines.join('\n')}\n`;
+}

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/activity-facts.js

@@ -147,10 +147,12 @@ function collaborationAction(tool) {
         spawnAgent: 'spawn_agent',
         sendInput: 'send_input',
         resumeAgent: 'resume_agent',
+        followupTask: 'resume_agent',
         closeAgent: 'close_agent',
         spawn_agent: 'spawn_agent',
         send_input: 'send_input',
         resume_agent: 'resume_agent',
+        followup_task: 'resume_agent',
         close_agent: 'close_agent',
         wait: 'wait',
     }[tool];

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),