gestalt-mobile 0.41.0 → 0.41.1

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

@@ -789,13 +789,21 @@ describe('production composition', () => {
             beforeWriteDatabase.close();
             expect(beforeWrite.resolved_at).toBeNull();
             handle.responseSettled({ id: 811, outcome: 'resultWritten' });
-            await expect(checkpointResponse).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+            await expect(checkpointResponse).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
+            const replayResponse = handle.request(l2CheckpointCall(812, threadId, active.active_turn_id, planIdentity));
+            await vi.waitFor(() => expect(handle.pendingResponses.has(812)).toBe(true));
+            handle.responseSettled({ id: 812, outcome: 'resultWritten' });
+            await expect(replayResponse).resolves.toEqual(toOrgPlanCheckpointToolResponse('alreadyRecorded'));
             const afterWriteDatabase = new DatabaseSync(join(fixture.dataDir, 'relay.sqlite'));
             const afterWrite = afterWriteDatabase
                 .prepare('SELECT resolved_at FROM pending_interactions WHERE session_id = ? AND request_id = ?')
                 .get(fixture.sessionId, '811');
+            const checkpointEvents = afterWriteDatabase
+                .prepare("SELECT count(*) AS count FROM session_events WHERE session_id = ? AND type = 'org-plan.step-checkpointed'")
+                .get(fixture.sessionId);
             afterWriteDatabase.close();
             expect(afterWrite.resolved_at).toEqual(expect.any(String));
+            expect(checkpointEvents.count).toBe(1);
             expect(timers).toHaveLength(schedulesBeforeCheckpoint);
             expect(coordinator.snapshot(fixture.sessionId).health).not.toMatchObject({
                 phase: 'waitingForAgentEvent',
@@ -941,7 +949,7 @@ describe('production composition', () => {
             });
             const { handle, response } = await holdCheckpointRequest(fixture, timers, 812, true, true);
             handle.responseSettled({ id: 812, outcome: 'resultWritten' });
-            await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+            await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
             const database = new DatabaseSync(join(fixture.dataDir, 'relay.sqlite'));
             const checkpoint = database
                 .prepare("SELECT count(*) AS count FROM session_events WHERE session_id = ? AND type = 'org-plan.step-checkpointed'")
@@ -950,7 +958,7 @@ describe('production composition', () => {
             expect(checkpoint.count).toBe(1);
             await fixture.app.close();
         });
-        it('leaves an unsupported checkpoint exception before persistence inert', async () => {
+        it('returns a typed failed checkpoint result when persistence never occurs', async () => {
             let coordinator;
             const timers = [];
             const fixture = await createProductionAutopilotFixture({
@@ -969,8 +977,10 @@ describe('production composition', () => {
             vi.spyOn(coordinator, 'checkpointAccepted').mockImplementation(() => {
                 throw new Error('injected-before-checkpoint-persistence');
             });
-            const { response, startsBefore, writersBefore } = await holdCheckpointRequest(fixture, timers, 995, false);
-            await expect(response).rejects.toThrow('CODEX_SERVER_REQUEST_UNSUPPORTED');
+            const { handle, response, startsBefore, writersBefore } = await holdCheckpointRequest(fixture, timers, 995, false);
+            await vi.waitFor(() => expect(handle.pendingResponses.has(995)).toBe(true));
+            handle.responseSettled({ id: 995, outcome: 'resultWritten' });
+            await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('failed'));
             expect(coordinator.checkpointAccepted).not.toBe(original);
             expect(fixture.handles).toHaveLength(writersBefore);
             expect(fixture.handles
@@ -1139,7 +1149,7 @@ describe('production composition', () => {
             };
             if (scenario === 'resultWritten-before-timeout') {
                 handle.responseSettled({ id: 992, outcome: 'resultWritten' });
-                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
                 await new Promise((resolve) => setTimeout(resolve, 30));
                 expect(fixture.handles).toHaveLength(writersBefore);
                 expect(failures()).toBe(0);
@@ -1147,7 +1157,7 @@ describe('production composition', () => {
             else if (scenario === 'duplicate-settlement') {
                 handle.responseSettled({ id: 992, outcome: 'resultWritten' });
                 handle.responseSettled({ id: 992, outcome: 'resultWritten' });
-                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse());
+                await expect(response).resolves.toEqual(toOrgPlanCheckpointToolResponse('recorded'));
                 await new Promise((resolve) => setTimeout(resolve, 30));
                 expect(fixture.handles).toHaveLength(writersBefore);
                 expect(failures()).toBe(0);
@@ -1292,7 +1302,7 @@ describe('production composition', () => {
             expect(approvalTurn.statusCode).toBe(202);
             await approvalFixture.app.close();
         });
-        it('rejects a checkpoint delivered after its owning root final has closed', async () => {
+        it('returns failed for a checkpoint delivered after its owning root final has closed', async () => {
             const timers = [];
             const fixture = await createProductionAutopilotFixture({
                 autopilotSchedule: (callback) => {
@@ -1330,7 +1340,7 @@ describe('production composition', () => {
             const planIdentity = createHash('sha256')
                 .update(join(fixture.workspacePath, 'autopilot.org'))
                 .digest('hex');
-            await expect(handle.request(l2CheckpointCall(812, threadId, active.active_turn_id, planIdentity))).rejects.toThrow('CODEX_SERVER_REQUEST_UNSUPPORTED');
+            await expect(handle.request(l2CheckpointCall(812, threadId, active.active_turn_id, planIdentity))).resolves.toEqual(toOrgPlanCheckpointToolResponse('failed'));
             expect(timers).toHaveLength(timersAfterFinal);
             expect(fixture.handles
                 .flatMap((candidate) => candidate.requests)

package/dist/server/server/composition.js

@@ -741,7 +741,7 @@ export async function composeRelayApp(options) {
                     !identity ||
                     checkpoint.planIdentity !== identity ||
                     !rootOwned)
-                    return false;
+                    return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse('failed')) === true);
                 const valid = validOrgPlanCheckpoint({
                     checkpoint,
                     plan: retained,
@@ -749,17 +749,15 @@ export async function composeRelayApp(options) {
                     rootOwned,
                     hasActiveL1Writer: (position) => hasActiveL1Writer(activity.snapshot(sessionId, new Date().toISOString()), position),
                 });
-                if (!valid)
-                    return false;
-                if (!session.activeTurnId)
-                    return false;
-                let accepted = false;
+                if (!valid || !session.activeTurnId)
+                    return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse('failed')) === true);
+                let recordStatus = 'failed';
                 try {
-                    accepted = autopilot.checkpointAccepted(sessionId, checkpoint, session.activeTurnId, new Date().toISOString());
+                    recordStatus = autopilot.checkpointAccepted(sessionId, checkpoint, session.activeTurnId, new Date().toISOString());
                 }
                 catch {
                     if (!autopilot.checkpointHandoffFailed(sessionId, session.activeTurnId))
-                        return false;
+                        return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse('failed')) === true);
                     const interaction = {
                         ...rawInteraction,
                         turnId: session.activeTurnId,
@@ -769,8 +767,10 @@ export async function composeRelayApp(options) {
                     failCheckpointHandoff(sessionId, rawInteraction.requestId, session.activeTurnId);
                     return true;
                 }
-                if (!accepted)
-                    return false;
+                if (recordStatus === 'failed')
+                    return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse('failed')) === true);
+                if (recordStatus === 'alreadyRecorded')
+                    return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse('alreadyRecorded')) === true);
                 const interaction = {
                     ...rawInteraction,
                     turnId: session.activeTurnId,
@@ -779,7 +779,7 @@ export async function composeRelayApp(options) {
                 interactions.add(sessionId, interaction);
                 armCheckpointHandoffDeadline(sessionId, rawInteraction.requestId, session.activeTurnId);
                 try {
-                    runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse());
+                    runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse('recorded'));
                 }
                 catch {
                     // The accepted hold remains owned by the bounded deadline.

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

@@ -3,7 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-export const AUTOPILOT_PROMPT_VERSION = 'v10';
+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_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. */
@@ -11,7 +11,7 @@ export function autopilotExecutorLaunchPrompt(identity) {
     const launch = `Launch task_name ${identity.taskName} for canonical ${identity.canonicalPosition}; retain the canonical label in status and review output.`;
     if (identity.generation === 1)
         return `${AUTOPILOT_CONTINUATION_PROMPT} ${launch}`;
-    return `${AUTOPILOT_CONTINUATION_PROMPT} ${launch} This is replacement generation ${identity.generation}: 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 ${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.`;
 }
 export const defaultAutopilotPolicy = Object.freeze({
     quiescenceMs: 1_000,

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

@@ -7,7 +7,7 @@ import { deriveSessionStatus } from '../../sessions/session-status.js';
 import { createHash } from 'node:crypto';
 import { AUTOPILOT_WAIT_MAX_MS, AUTOPILOT_WAIT_MIN_MS, } from '../../../../shared/contracts/autopilot-wait-lease.js';
 import { autopilotSnapshot, disabledAutopilot, } from '../domain/autopilot-session.js';
-import { classifyExecutorOutcome, decideSupervisedLifecycle, executorIdentity, validStructuredBlock, checkpointTarget, } from '../domain/supervised-lifecycle.js';
+import { classifyExecutorOutcome, decideSupervisedLifecycle, executorIdentity, validStructuredBlock, checkpointTarget, executorAssignment, } from '../domain/supervised-lifecycle.js';
 import { classifyAgentActivity, decideAutopilot, executionComplete, } from './policy.js';
 import { consumeCheckpointBoundary, consumeObsoleteWait, consumeObservableWake, consumeWaitDeadline, recordAutomaticContinuation, recoverSafetyPause, registerProactiveWait as registerProtocolWait, reportProbe, semanticProgressKey, startSupervisionProtocol, } from '../domain/supervision-protocol.js';
 export class AutopilotCoordinator {
@@ -213,7 +213,7 @@ export class AutopilotCoordinator {
         const activity = this.deps.activity(sessionId);
         if (!retained || activity?.confidence !== 'fresh')
             return false;
-        const executor = this.currentExecutor(sessionId, retained.plan, state.consecutiveNoProgress, state.executor);
+        const executor = this.currentExecutor(sessionId, retained.plan, state.consecutiveNoProgress, state.executor, activity);
         return Boolean(executor && !this.authoritativeExecutorActive(state, retained.plan, activity));
     }
     /** Fails closed only for the currently active bounded probe. */
@@ -612,10 +612,10 @@ export class AutopilotCoordinator {
         const prior = this.deps.store.find(sessionId);
         const retained = this.deps.plan(sessionId);
         if (!prior || !retained || !turnId || checkpoint.planIdentity !== retained.identity)
-            return false;
+            return 'failed';
         const previous = prior.checkpoints;
         if (previous && previous.planIdentity !== retained.identity)
-            return false;
+            return 'failed';
         const reportedL1Ids = previous?.reportedL1Ids ?? [];
         const reportedL2Ids = previous?.reportedL2Ids ?? [];
         const canonicalPosition = checkpoint.kind === 'terminalReviewAccepted' ? 'terminal' : checkpoint.position;
@@ -631,12 +631,12 @@ export class AutopilotCoordinator {
             .digest('hex');
         const acceptedKeys = previous?.acceptedKeys ?? [];
         if (acceptedKeys.includes(key))
-            return previous?.pendingTurnId === turnId && previous.pendingKind === checkpoint.kind;
+            return 'alreadyRecorded';
         const l2Key = checkpoint.kind === 'l2Completed' ? JSON.stringify([checkpoint.l1Id, checkpoint.l2Id]) : null;
         if (checkpoint.kind === 'terminalReviewAccepted' && previous?.terminalReviewAccepted)
-            return false;
+            return 'alreadyRecorded';
         if (completionEpoch?.completed && !completionEpoch.reopened)
-            return false;
+            return 'alreadyRecorded';
         const completionEpochs = [
             ...(previous?.completionEpochs ?? []).filter((entry) => entry.target !== target),
             { target, epoch, reopened: false, completed: true },
@@ -655,7 +655,19 @@ export class AutopilotCoordinator {
             checkpointHandoffFailed: false,
             terminalReviewAccepted: checkpoint.kind === 'terminalReviewAccepted' || previous?.terminalReviewAccepted === true,
         };
-        const checkpointed = { ...prior, checkpoints, updatedAt: occurredAt };
+        const checkpointed = {
+            ...prior,
+            ...(checkpoint.kind === 'l1Accepted' && prior.executor?.assignment
+                ? {
+                    executor: {
+                        ...prior.executor,
+                        assignment: { ...prior.executor.assignment, state: 'closed' },
+                    },
+                }
+                : {}),
+            checkpoints,
+            updatedAt: occurredAt,
+        };
         this.persist({
             ...checkpointed,
             supervision: checkpointed.supervision
@@ -688,7 +700,7 @@ export class AutopilotCoordinator {
         this.cancelWaitTimer(sessionId);
         this.parkedSubscriptions.delete(sessionId);
         this.cancelTimer(sessionId);
-        return true;
+        return 'recorded';
     }
     /**
      * Records a failed checkpoint transport handoff without releasing its root
@@ -852,6 +864,12 @@ export class AutopilotCoordinator {
         this.activityEventKeys.set(sessionId, eventKey);
         if (this.semanticEvent(sessionId, 'agentActivityChanged'))
             return;
+        // `executorChanged` is an edge subscription, not a request to wait for a
+        // later generic reconciliation pass. Consume it from the same fresh
+        // activity snapshot that exposed the settled canonical executor.
+        if (this.executorWakeAlreadySatisfied(sessionId, prior, ['executorChanged']) &&
+            this.semanticEvent(sessionId, 'executorChanged'))
+            return;
         const disposition = classifyAgentActivity(activity);
         if (disposition === 'attention') {
             this.evaluate(sessionId);
@@ -1283,23 +1301,36 @@ export class AutopilotCoordinator {
                 l1.reviewStatus === 'REVIEWED' &&
                 (!reportedL1.has(l1.id) || epochNeedsReport(checkpointTarget('l1', l1.id)))));
     }
-    currentExecutor(sessionId, plan, continuationCount, persisted) {
+    currentExecutor(sessionId, plan, continuationCount, persisted, activity = this.deps.activity(sessionId)) {
         const stepIndex = plan.steps.findIndex((step) => step.id === plan.currentStepId || step.state === 'WIP');
         const index = stepIndex >= 0 ? stepIndex : plan.steps.findIndex((step) => step.state !== 'DONE');
         if (index < 0)
             return undefined;
         const step = plan.steps[index];
         const canonicalPosition = `L${index + 1}`;
-        const child = this.deps
-            .activity(sessionId)
-            ?.subagents.filter((candidate) => candidate.canonicalPosition === canonicalPosition)
-            .sort((left, right) => (right.continuationGeneration ?? 1) - (left.continuationGeneration ?? 1) ||
-            Date.parse(right.lastActivityAt) - Date.parse(left.lastActivityAt) ||
-            (left.threadId ?? left.id).localeCompare(right.threadId ?? right.id))[0];
+        const candidates = activity?.subagents.filter((candidate) => candidate.canonicalPosition === canonicalPosition) ?? [];
+        const assigned = persisted?.assignment?.canonicalPosition === canonicalPosition
+            ? persisted.assignment
+            : undefined;
+        const replacementChild = persisted?.replacement
+            ? candidates.find((candidate) => candidate.canonicalTaskName === persisted.replacement.canonicalTaskName &&
+                (candidate.continuationGeneration ?? 1) === persisted.replacement.generation &&
+                candidate.taskPath?.split('/').filter(Boolean).at(-1) ===
+                    persisted.replacement.taskName)
+            : undefined;
+        const child = replacementChild ??
+            (assigned
+                ? candidates.find((candidate) => candidate.canonicalTaskName === assigned.canonicalTaskName &&
+                    candidate.taskPath === assigned.taskPath &&
+                    (candidate.threadId ?? candidate.id) === assigned.threadId &&
+                    (candidate.continuationGeneration ?? 1) === assigned.generation)
+                : candidates
+                    .filter((candidate) => candidate.canonicalPosition === canonicalPosition)
+                    .sort((left, right) => (right.continuationGeneration ?? 1) - (left.continuationGeneration ?? 1) ||
+                    Date.parse(right.lastActivityAt) - Date.parse(left.lastActivityAt) ||
+                    (left.threadId ?? left.id).localeCompare(right.threadId ?? right.id))[0]);
         if (!child) {
-            if (persisted?.canonicalPosition !== canonicalPosition ||
-                persisted.outcome === 'cancelled' ||
-                persisted.outcome === 'failed')
+            if (persisted?.canonicalPosition !== canonicalPosition || persisted.outcome === 'cancelled')
                 return undefined;
             return {
                 ...persisted,
@@ -1308,16 +1339,20 @@ export class AutopilotCoordinator {
                 ownedProcesses: refreshPersistedProcesses(persisted.ownedProcesses, [], this.deps.now()),
             };
         }
-        // A roster entry for a newer generation is authoritative even when that
-        // generation is disconnected. Never fall back to an older persisted
-        // writer; incomplete owner metadata instead fences all continuation.
+        // Once adopted, a persisted assignment outranks every unrelated roster
+        // entry.  A new physical writer can enter only through the exact durable
+        // replacement authorization above.
         if (!child.taskPath || !child.canonicalTaskName)
             return undefined;
-        if (child.outcome === 'cancelled' || child.outcome === 'failed')
+        if (child.outcome === 'cancelled')
             return undefined;
         const activeL2 = step.children.find((candidate) => candidate.state === 'WIP');
+        const active = child.state === 'working' ||
+            child.state === 'awaitingAgent' ||
+            Boolean(child.ownedProcesses?.some((process) => process.state === 'running' || process.state === 'detached-active'));
         const outcome = classifyExecutorOutcome({
             objectiveComplete: step.state === 'DONE',
+            active,
             reportedOutcome: child.outcome,
         });
         return {
@@ -1346,6 +1381,15 @@ export class AutopilotCoordinator {
                     ? { resumeFailures: persisted.resumeFailures }
                     : {}),
             ...(persisted?.commands ? { commands: persisted.commands } : {}),
+            assignment: replacementChild || !assigned
+                ? executorAssignment({
+                    canonicalPosition,
+                    canonicalTaskName: child.canonicalTaskName,
+                    taskPath: child.taskPath,
+                    threadId: child.threadId ?? child.id,
+                    continuationGeneration: child.continuationGeneration ?? 1,
+                })
+                : assigned,
         };
     }
     /** A fresh roster may expose two physical writers for one canonical L1. */
@@ -1661,7 +1705,8 @@ export class AutopilotCoordinator {
         return conditions.some((condition) => this.semanticEvent(sessionId, condition));
     }
     freshExecutorIdentity(sessionId) {
-        const replacement = this.deps.store.find(sessionId)?.executor?.replacement;
+        const state = this.deps.store.find(sessionId);
+        const replacement = state?.executor?.replacement;
         if (replacement && this.validReplacement(sessionId, replacement))
             return replacement;
         const plan = this.deps.plan(sessionId)?.plan;
@@ -1672,11 +1717,22 @@ export class AutopilotCoordinator {
         if (index < 0)
             return undefined;
         const canonicalTaskName = `l${index + 1}`;
-        const generations = this.deps
+        // A root boundary starts a root turn, not a replacement executor.  The
+        // existing physical owner remains resumable through ordinary L2, review,
+        // and completion boundaries, regardless of its most recently observed
+        // continuation generation.  Only a durable replacement handoff above may
+        // authorize a generated physical task name.
+        if (state?.executor?.canonicalTaskName === canonicalTaskName &&
+            state.executor.outcome !== 'cancelled')
+            return undefined;
+        // Legacy roster observations establish a resumable owner but never
+        // authorize a generated name.  Only scheduleExecutorReplacement creates
+        // the exact durable replacement record consumed above.
+        if (this.deps
             .activity(sessionId)
-            ?.subagents.filter((child) => child.canonicalTaskName === canonicalTaskName)
-            .map((child) => child.continuationGeneration ?? 1) ?? [];
-        return executorIdentity(canonicalTaskName, Math.max(0, ...generations) + 1);
+            ?.subagents.some((child) => child.canonicalTaskName === canonicalTaskName))
+            return undefined;
+        return executorIdentity(canonicalTaskName, 1);
     }
     validReplacement(sessionId, replacement) {
         const retained = this.deps.plan(sessionId);
@@ -1693,16 +1749,24 @@ export class AutopilotCoordinator {
         const retained = this.deps.plan(sessionId);
         if (!current?.requestedEnabled || !retained || current.executor?.replacement)
             return;
-        const identity = executorIdentity(executor.canonicalTaskName, executor.continuationGeneration + 1);
+        const identity = executorIdentity(executor.canonicalTaskName, (executor.assignment?.generation ?? executor.continuationGeneration) + 1);
         const now = this.deps.now();
         const controlId = this.deps.nextControlId(sessionId, current.generation);
         const replacement = {
             ...executor,
             outcome: 'failed',
+            ...(executor.assignment
+                ? { assignment: { ...executor.assignment, state: 'unavailable' } }
+                : {}),
             replacement: {
                 ...identity,
                 planIdentity: retained.identity,
                 planFingerprint: fingerprint(retained.plan),
+                previous: executor.assignment
+                    ? { ...executor.assignment, state: 'unavailable' }
+                    : executorAssignment(executor, 'unavailable'),
+                reason: 'explicitExecutorRejection',
+                evidence: 'retry-limit-exhausted',
             },
             commands: executor.commands?.map((command) => ['scheduled', 'issued'].includes(command.status)
                 ? { ...command, status: 'superseded', updatedAt: now }

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

@@ -13,6 +13,19 @@ export const blockingResumeConditions = {
     externalState: 'externalStateChanged',
     materialAmbiguity: 'userGuidance',
 };
+export function executorAssignment(executor, state = 'resumable') {
+    const taskName = executor.taskPath.split('/').filter(Boolean).at(-1);
+    const identity = executorIdentity(executor.canonicalTaskName, executor.continuationGeneration);
+    return {
+        canonicalPosition: executor.canonicalPosition,
+        canonicalTaskName: executor.canonicalTaskName,
+        taskName: taskName || identity.taskName,
+        taskPath: executor.taskPath,
+        threadId: executor.threadId,
+        generation: identity.generation,
+        state,
+    };
+}
 export function checkpointTarget(kind, l1Id, l2Id) {
     return kind === 'l2'
         ? JSON.stringify([kind, l1Id, l2Id])
@@ -153,6 +166,8 @@ export function parsePersistedSupervisedLifecycle(value) {
     const resumeFailures = executorValue.resumeFailures === undefined
         ? 0
         : nonNegativeInteger(executorValue.resumeFailures);
+    const assignmentValue = executorValue.assignment === undefined ? undefined : record(executorValue.assignment);
+    const assignment = assignmentValue ? parseExecutorAssignment(assignmentValue) : undefined;
     const replacementValue = executorValue.replacement === undefined ? undefined : record(executorValue.replacement);
     const replacementGeneration = replacementValue && nonNegativeInteger(replacementValue.generation);
     const replacementTaskName = replacementValue && boundedText(replacementValue.taskName);
@@ -160,6 +175,12 @@ export function parsePersistedSupervisedLifecycle(value) {
     const replacementCanonicalPosition = replacementValue && boundedText(replacementValue.canonicalPosition);
     const replacementPlanIdentity = replacementValue && boundedText(replacementValue.planIdentity);
     const replacementPlanFingerprint = replacementValue && boundedText(replacementValue.planFingerprint);
+    const replacementPreviousValue = replacementValue && record(replacementValue.previous);
+    const replacementPrevious = replacementPreviousValue
+        ? parseExecutorAssignment(replacementPreviousValue)
+        : undefined;
+    const replacementReason = replacementValue && stringValue(replacementValue.reason, ['explicitExecutorRejection']);
+    const replacementEvidence = replacementValue && boundedText(replacementValue.evidence);
     if (!canonicalPosition ||
         !canonicalTaskName ||
         !taskPath ||
@@ -170,14 +191,32 @@ export function parsePersistedSupervisedLifecycle(value) {
         continuationGeneration === null ||
         continuationCount === null ||
         resumeFailures === null ||
+        (executorValue.assignment !== undefined && !assignment) ||
         (replacementValue &&
             (!replacementGeneration ||
                 !replacementTaskName ||
                 !replacementCanonicalTaskName ||
                 !replacementCanonicalPosition ||
                 !replacementPlanIdentity ||
-                !replacementPlanFingerprint)))
+                !replacementPlanFingerprint ||
+                (replacementValue.previous !== undefined && !replacementPrevious) ||
+                (replacementReason !== undefined && replacementReason !== 'explicitExecutorRejection') ||
+                (replacementValue.evidence !== undefined && !replacementEvidence))))
         return undefined;
+    if (replacementValue) {
+        try {
+            const identity = executorIdentity(replacementCanonicalTaskName, replacementGeneration);
+            if (identity.taskName !== replacementTaskName ||
+                identity.canonicalPosition !== replacementCanonicalPosition ||
+                (replacementPrevious &&
+                    (replacementPrevious.canonicalTaskName !== canonicalTaskName ||
+                        replacementPrevious.canonicalPosition !== canonicalPosition)))
+                return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     const commandsValue = executorValue.commands;
     if (commandsValue !== undefined && (!Array.isArray(commandsValue) || commandsValue.length > 32))
         return undefined;
@@ -268,6 +307,7 @@ export function parsePersistedSupervisedLifecycle(value) {
             continuationGeneration,
             continuationCount,
             ...(resumeFailures ? { resumeFailures } : {}),
+            ...(assignment ? { assignment } : {}),
             ...(replacementValue
                 ? {
                     replacement: {
@@ -277,6 +317,9 @@ export function parsePersistedSupervisedLifecycle(value) {
                         canonicalPosition: replacementCanonicalPosition,
                         planIdentity: replacementPlanIdentity,
                         planFingerprint: replacementPlanFingerprint,
+                        ...(replacementPrevious ? { previous: replacementPrevious } : {}),
+                        ...(replacementReason ? { reason: replacementReason } : {}),
+                        ...(replacementEvidence ? { evidence: replacementEvidence } : {}),
                     },
                 }
                 : {}),
@@ -396,19 +439,50 @@ function parseCheckpoints(value) {
         terminalReviewAccepted: value.terminalReviewAccepted,
     };
 }
+function parseExecutorAssignment(value) {
+    const canonicalPosition = boundedText(value.canonicalPosition);
+    const canonicalTaskName = boundedText(value.canonicalTaskName);
+    const taskName = boundedText(value.taskName);
+    const taskPath = boundedText(value.taskPath);
+    const threadId = boundedText(value.threadId);
+    const generation = nonNegativeInteger(value.generation);
+    const state = stringValue(value.state, ['resumable', 'closed', 'unavailable']);
+    if (!canonicalPosition ||
+        !canonicalTaskName ||
+        !taskName ||
+        !taskPath ||
+        !threadId ||
+        generation === null ||
+        generation < 1 ||
+        !state)
+        return undefined;
+    try {
+        const identity = executorIdentity(canonicalTaskName, generation);
+        return identity.canonicalPosition === canonicalPosition && identity.taskName === taskName
+            ? { canonicalPosition, canonicalTaskName, taskName, taskPath, threadId, generation, state }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function classifyExecutorOutcome(input) {
     if (input.objectiveComplete)
-        return { outcome: 'objective_complete' };
-    if (input.reportedOutcome === 'cancelled' || input.reportedOutcome === 'failed')
-        return { outcome: input.reportedOutcome };
+        return { classification: 'done', outcome: 'objective_complete' };
     const blocking = input.blockingReason && input.resumeCondition
         ? { reason: input.blockingReason, resumeCondition: input.resumeCondition }
         : undefined;
     if (input.reportedOutcome === 'blocked' && validStructuredBlock(blocking))
-        return { outcome: 'blocked', blocking };
+        return { classification: 'blocker', outcome: 'blocked', blocking };
+    if (input.active)
+        // Fresh activity outranks the previous turn's terminal transport status.
+        return { classification: 'ongoing', outcome: 'partial' };
+    if (input.reportedOutcome === 'cancelled' || input.reportedOutcome === 'failed')
+        return { classification: 'recoverableFailure', outcome: input.reportedOutcome };
     // A turn ending, a checkpoint, or free-form language about time/context is
-    // not objective state. Incomplete Org state remains mechanically partial.
-    return { outcome: 'partial' };
+    // not objective state. Incomplete, settled Org state is mechanically
+    // recoverable and must return to the same canonical executor.
+    return { classification: 'recoverableFailure', outcome: 'partial' };
 }
 export function decideSupervisedLifecycle(input) {
     if (input.explicitlyPausedOrCancelled || executionComplete(input.plan))

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

@@ -176,13 +176,33 @@ export function parseOrgPlanCheckpoint(value) {
     };
 }
 /** Acknowledgement deliberately contains no plan path, findings, or model text. */
-export function toOrgPlanCheckpointToolResponse() {
+export function toOrgPlanCheckpointToolResponse(status) {
+    const result = status === 'recorded'
+        ? {
+            status,
+            durable: true,
+            next: 'emitBoundaryFinalAndEndTurn',
+            allowFurtherTools: false,
+        }
+        : status === 'alreadyRecorded'
+            ? {
+                status,
+                durable: true,
+                next: 'continueFromDurableCheckpoint',
+                allowBoundaryFinal: false,
+            }
+            : {
+                status,
+                durable: false,
+                next: 'reconcileCheckpointState',
+                allowBoundaryFinal: false,
+            };
     return {
-        success: true,
+        success: status !== 'failed',
         contentItems: [
             {
                 type: 'inputText',
-                text: '{"accepted":true,"next":"emitBoundaryFinalAndEndTurn","allowFurtherTools":false}',
+                text: JSON.stringify(result),
             },
         ],
     };

package/package.json

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