gestalt-mobile 0.35.0 → 0.35.2

package/dist/server/server/features/autopilot/domain/autopilot-session.js

@@ -3,6 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { checkpointHandoffRecoveryMessage } from '../../../../shared/contracts/autopilot-recovery.js';
 import { observableWakeConditions, } from './supervision-protocol.js';
 export function disabledAutopilot(sessionId, now) {
     return {
@@ -45,46 +46,51 @@ export function autopilotSnapshot(state, retryLimit, facts = {
     // installed wait lease into a false idle signal.
     const liveContinuation = parkedWait || scheduled || rootWorking || facts.executorActive || facts.reconciling;
     const healthy = state.requestedEnabled &&
+        !state.checkpoints?.checkpointHandoffFailed &&
         facts.planMatches &&
         !['attentionRequired', 'safetyPaused'].includes(supervision) &&
         !['attentionRequired', 'safetyPaused', 'completed', 'disabled'].includes(state.state) &&
         liveContinuation;
-    const phase = state.state === 'disabled'
-        ? 'off'
-        : state.state === 'completed'
-            ? 'complete'
-            : state.state === 'attentionRequired'
-                ? 'needsYou'
-                : state.state === 'safetyPaused' || supervision === 'safetyPaused'
-                    ? 'safetyPaused'
-                    : healthy && (parkedWait || facts.executorActive)
-                        ? 'waitingForAgentEvent'
-                        : healthy && scheduled
-                            ? 'continuationScheduled'
-                            : healthy && (supervision === 'probeRequired' || facts.reconciling)
-                                ? 'checkingState'
-                                : healthy && rootWorking
-                                    ? 'rootWorking'
-                                    : 'degraded';
-    const nextExpectedAction = phase === 'rootWorking'
-        ? 'Wait for the root turn to settle.'
-        : phase === 'continuationScheduled'
-            ? 'Run the scheduled continuation.'
-            : phase === 'waitingForAgentEvent'
-                ? parkedWait
-                    ? 'Wait for a subscribed agent or process event.'
-                    : 'Wait for the active executor or owned process to settle.'
-                : phase === 'checkingState'
-                    ? 'Reconcile supervised execution state.'
-                    : phase === 'needsYou'
-                        ? 'Respond to the pending attention request.'
-                        : phase === 'complete'
-                            ? 'No further plan action is required.'
-                            : phase === 'off'
-                                ? 'Enable Autopilot to supervise an incomplete plan.'
-                                : phase === 'safetyPaused'
-                                    ? 'Resume manually after reviewing the safety pause.'
-                                    : 'Restore a valid continuation before relying on Autopilot.';
+    const phase = state.checkpoints?.checkpointHandoffFailed
+        ? 'checkpointRecovery'
+        : state.state === 'disabled'
+            ? 'off'
+            : state.state === 'completed'
+                ? 'complete'
+                : state.state === 'attentionRequired'
+                    ? 'needsYou'
+                    : state.state === 'safetyPaused' || supervision === 'safetyPaused'
+                        ? 'safetyPaused'
+                        : healthy && (parkedWait || facts.executorActive)
+                            ? 'waitingForAgentEvent'
+                            : healthy && scheduled
+                                ? 'continuationScheduled'
+                                : healthy && (supervision === 'probeRequired' || facts.reconciling)
+                                    ? 'checkingState'
+                                    : healthy && rootWorking
+                                        ? 'rootWorking'
+                                        : 'degraded';
+    const nextExpectedAction = phase === 'checkpointRecovery'
+        ? checkpointHandoffRecoveryMessage
+        : phase === 'rootWorking'
+            ? 'Wait for the root turn to settle.'
+            : phase === 'continuationScheduled'
+                ? 'Run the scheduled continuation.'
+                : phase === 'waitingForAgentEvent'
+                    ? parkedWait
+                        ? 'Wait for a subscribed agent or process event.'
+                        : 'Wait for the active executor or owned process to settle.'
+                    : phase === 'checkingState'
+                        ? 'Reconcile supervised execution state.'
+                        : phase === 'needsYou'
+                            ? 'Respond to the pending attention request.'
+                            : phase === 'complete'
+                                ? 'No further plan action is required.'
+                                : phase === 'off'
+                                    ? 'Enable Autopilot to supervise an incomplete plan.'
+                                    : phase === 'safetyPaused'
+                                        ? 'Resume manually after reviewing the safety pause.'
+                                        : 'Restore a valid continuation before relying on Autopilot.';
     return {
         state: state.state,
         enabled: state.requestedEnabled,

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

@@ -13,6 +13,44 @@ export const blockingResumeConditions = {
     externalState: 'externalStateChanged',
     materialAmbiguity: 'userGuidance',
 };
+export function checkpointTarget(kind, l1Id, l2Id) {
+    return kind === 'l2'
+        ? JSON.stringify([kind, l1Id, l2Id])
+        : kind === 'l1'
+            ? JSON.stringify([kind, l1Id])
+            : JSON.stringify([kind]);
+}
+function canonicalCheckpointTarget(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    try {
+        const target = JSON.parse(value);
+        if (!Array.isArray(target) ||
+            !['l1', 'l2', 'terminal'].includes(target[0]) ||
+            !target.every((part) => typeof part === 'string'))
+            return undefined;
+        if ((target[0] === 'l1' && target.length !== 2) ||
+            (target[0] === 'l2' && target.length !== 3) ||
+            (target[0] === 'terminal' && target.length !== 1))
+            return undefined;
+        if (!target.slice(1).every((part) => boundedText(part)))
+            return undefined;
+        return JSON.stringify(target);
+    }
+    catch {
+        const legacy = value.split(':');
+        return legacy[0] === 'l1' && legacy.length === 2 && boundedText(legacy[1])
+            ? checkpointTarget('l1', legacy[1])
+            : legacy[0] === 'l2' &&
+                legacy.length === 3 &&
+                boundedText(legacy[1]) &&
+                boundedText(legacy[2])
+                ? checkpointTarget('l2', legacy[1], legacy[2])
+                : value === 'terminal'
+                    ? checkpointTarget('terminal')
+                    : undefined;
+    }
+}
 export function validStructuredBlock(value) {
     return Boolean(value && blockingResumeConditions[value.reason] === value.resumeCondition);
 }
@@ -112,6 +150,16 @@ export function parsePersistedSupervisedLifecycle(value) {
     ]);
     const continuationGeneration = nonNegativeInteger(executorValue.continuationGeneration);
     const continuationCount = nonNegativeInteger(executorValue.continuationCount);
+    const resumeFailures = executorValue.resumeFailures === undefined
+        ? 0
+        : nonNegativeInteger(executorValue.resumeFailures);
+    const replacementValue = executorValue.replacement === undefined ? undefined : record(executorValue.replacement);
+    const replacementGeneration = replacementValue && nonNegativeInteger(replacementValue.generation);
+    const replacementTaskName = replacementValue && boundedText(replacementValue.taskName);
+    const replacementCanonicalTaskName = replacementValue && boundedText(replacementValue.canonicalTaskName);
+    const replacementCanonicalPosition = replacementValue && boundedText(replacementValue.canonicalPosition);
+    const replacementPlanIdentity = replacementValue && boundedText(replacementValue.planIdentity);
+    const replacementPlanFingerprint = replacementValue && boundedText(replacementValue.planFingerprint);
     if (!canonicalPosition ||
         !canonicalTaskName ||
         !taskPath ||
@@ -120,7 +168,84 @@ export function parsePersistedSupervisedLifecycle(value) {
         !lastActivityAt ||
         !outcome ||
         continuationGeneration === null ||
-        continuationCount === null)
+        continuationCount === null ||
+        resumeFailures === null ||
+        (replacementValue &&
+            (!replacementGeneration ||
+                !replacementTaskName ||
+                !replacementCanonicalTaskName ||
+                !replacementCanonicalPosition ||
+                !replacementPlanIdentity ||
+                !replacementPlanFingerprint)))
+        return undefined;
+    const commandsValue = executorValue.commands;
+    if (commandsValue !== undefined && (!Array.isArray(commandsValue) || commandsValue.length > 32))
+        return undefined;
+    const commands = (commandsValue ?? []).flatMap((candidate) => {
+        const command = record(candidate);
+        const commandId = command && boundedText(command.commandId);
+        const status = command &&
+            stringValue(command.status, [
+                'scheduled',
+                'issued',
+                'accepted',
+                'failed',
+                'cancelled',
+                'superseded',
+            ]);
+        const planIdentity = command && boundedText(command.planIdentity);
+        const planFingerprint = command && boundedText(command.planFingerprint);
+        const commandPosition = command && boundedText(command.canonicalPosition);
+        const commandTaskName = command && boundedText(command.canonicalTaskName);
+        const commandTaskPath = command && boundedText(command.taskPath);
+        const commandThreadId = command && boundedText(command.threadId);
+        const generation = command && nonNegativeInteger(command.generation);
+        const attempt = command?.attempt === undefined ? 0 : command && nonNegativeInteger(command.attempt);
+        const trigger = command && stringValue(command.trigger, ['partial', 'processExited', 'processResourceLimit']);
+        const processActionValue = command && record(command.processAction);
+        const processActionKind = processActionValue &&
+            stringValue(processActionValue.kind, ['transfer', 'consume', 'terminate']);
+        const processActionKey = processActionValue && boundedText(processActionValue.processKey);
+        const createdAt = command && boundedText(command.createdAt);
+        const updatedAt = command && boundedText(command.updatedAt);
+        return commandId &&
+            status &&
+            planIdentity &&
+            planFingerprint &&
+            commandPosition &&
+            commandTaskName &&
+            commandTaskPath &&
+            commandThreadId &&
+            typeof generation === 'number' &&
+            typeof attempt === 'number' &&
+            trigger &&
+            createdAt &&
+            updatedAt &&
+            (!processActionValue || (processActionKind && processActionKey))
+            ? [
+                {
+                    commandId,
+                    status,
+                    planIdentity,
+                    planFingerprint,
+                    canonicalPosition: commandPosition,
+                    canonicalTaskName: commandTaskName,
+                    taskPath: commandTaskPath,
+                    threadId: commandThreadId,
+                    generation,
+                    ...(attempt ? { attempt } : {}),
+                    trigger,
+                    ...(processActionValue && processActionKind && processActionKey
+                        ? { processAction: { kind: processActionKind, processKey: processActionKey } }
+                        : {}),
+                    createdAt,
+                    updatedAt,
+                },
+            ]
+            : [];
+    });
+    if (commands.length !== (commandsValue ?? []).length ||
+        new Set(commands.map((command) => command.commandId)).size !== commands.length)
         return undefined;
     const executorBlockingValue = record(executorValue.blocking);
     const executorBlocking = executorBlockingValue
@@ -142,6 +267,20 @@ export function parsePersistedSupervisedLifecycle(value) {
             ...(executorBlocking ? { blocking: executorBlocking } : {}),
             continuationGeneration,
             continuationCount,
+            ...(resumeFailures ? { resumeFailures } : {}),
+            ...(replacementValue
+                ? {
+                    replacement: {
+                        generation: replacementGeneration,
+                        taskName: replacementTaskName,
+                        canonicalTaskName: replacementCanonicalTaskName,
+                        canonicalPosition: replacementCanonicalPosition,
+                        planIdentity: replacementPlanIdentity,
+                        planFingerprint: replacementPlanFingerprint,
+                    },
+                }
+                : {}),
+            ...(commands.length ? { commands } : {}),
         },
         ...(blocking ? { blocking } : {}),
         ...(supervision ? { supervision } : {}),
@@ -152,6 +291,31 @@ function parseCheckpoints(value) {
     const planIdentity = boundedText(value.planIdentity);
     if (value.protocolVersion !== 1 || !planIdentity)
         return undefined;
+    const rawCompletionEpochs = value.completionEpochs ?? [];
+    if (!Array.isArray(rawCompletionEpochs) || rawCompletionEpochs.length > 640)
+        return undefined;
+    const completionEpochs = rawCompletionEpochs.flatMap((candidate) => {
+        const epoch = record(candidate);
+        const target = epoch && canonicalCheckpointTarget(epoch.target);
+        return target &&
+            typeof epoch.epoch === 'number' &&
+            Number.isSafeInteger(epoch.epoch) &&
+            epoch.epoch >= 0 &&
+            typeof epoch.reopened === 'boolean' &&
+            (epoch.completed === undefined || typeof epoch.completed === 'boolean')
+            ? [
+                {
+                    target,
+                    epoch: epoch.epoch,
+                    reopened: epoch.reopened,
+                    completed: epoch.completed ?? true,
+                },
+            ]
+            : [];
+    });
+    if (completionEpochs.length !== rawCompletionEpochs.length ||
+        new Set(completionEpochs.map((epoch) => epoch.target)).size !== completionEpochs.length)
+        return undefined;
     const rawReportedL2Ids = value.reportedL2Ids ?? [];
     if (!Array.isArray(rawReportedL2Ids) || rawReportedL2Ids.length > 512)
         return undefined;
@@ -178,6 +342,9 @@ function parseCheckpoints(value) {
     const pendingTurnId = value.pendingTurnId === null ? null : boundedText(value.pendingTurnId);
     if (pendingTurnId === undefined)
         return undefined;
+    if (value.checkpointHandoffFailed !== undefined &&
+        typeof value.checkpointHandoffFailed !== 'boolean')
+        return undefined;
     if (typeof value.terminalReviewAccepted !== 'boolean')
         return undefined;
     const pendingKind = value.pendingKind === undefined
@@ -190,14 +357,42 @@ function parseCheckpoints(value) {
     if (pendingKind !== null &&
         !['l2Completed', 'l1Accepted', 'terminalReviewAccepted'].includes(String(pendingKind)))
         return undefined;
+    const legacyTargets = [
+        ...reportedL1Ids.map((id) => checkpointTarget('l1', id)),
+        ...reportedL2Ids.flatMap((id) => {
+            try {
+                const parsed = JSON.parse(id);
+                return Array.isArray(parsed) &&
+                    parsed.length === 2 &&
+                    parsed.every((part) => typeof part === 'string')
+                    ? [checkpointTarget('l2', parsed[0], parsed[1])]
+                    : [];
+            }
+            catch {
+                return [];
+            }
+        }),
+    ];
+    if (legacyTargets.length !== reportedL1Ids.length + reportedL2Ids.length)
+        return undefined;
+    const legacyEpochs = value.completionEpochs === undefined
+        ? legacyTargets.map((target) => ({ target, epoch: 0, reopened: false, completed: true }))
+        : completionEpochs;
+    if (value.completionEpochs !== undefined &&
+        !legacyTargets.every((target) => completionEpochs.some((epoch) => epoch.target === target)))
+        return undefined;
     return {
         protocolVersion: 1,
         planIdentity,
+        completionEpochs: legacyEpochs,
         reportedL2Ids,
         reportedL1Ids,
         acceptedKeys,
         pendingTurnId,
         pendingKind: pendingKind,
+        ...(value.checkpointHandoffFailed === undefined
+            ? {}
+            : { checkpointHandoffFailed: value.checkpointHandoffFailed }),
         terminalReviewAccepted: value.terminalReviewAccepted,
     };
 }

package/dist/server/server/features/autopilot/domain/supervision-protocol.js

@@ -15,6 +15,59 @@ export const observableWakeConditions = [
     'processLimitBreached',
     'agentActivityChanged',
 ];
+/**
+ * The durable protocol owns wait state, while the coordinator owns the live
+ * timer/subscription handles.  Keeping this matrix here makes every lifecycle
+ * boundary explicit before either owner mutates its half of a continuation.
+ */
+export const lifecycleBoundaries = [
+    'checkpointPersisted',
+    'matchingRootFinal',
+    'proactiveWaitRegistered',
+    'waitDeadline',
+    'manualOff',
+    'manualInterruption',
+    'explicitRecovery',
+    'planReplacement',
+    'attention',
+    'terminal',
+];
+const cancelledAtEveryBoundary = new Set([
+    'checkpointPersisted',
+    'matchingRootFinal',
+    'proactiveWaitRegistered',
+    'waitDeadline',
+    'manualOff',
+    'manualInterruption',
+    'explicitRecovery',
+    'planReplacement',
+    'attention',
+    'terminal',
+]);
+/**
+ * Resolves ownership of work that existed immediately before a boundary.
+ * `arm` is intentionally limited to the root-final handoff: it never revives
+ * the timer which was cancelled at checkpoint persistence.
+ */
+export function lifecycleBoundaryDisposition(boundary, work) {
+    if (work === 'rootTimer')
+        return boundary === 'matchingRootFinal'
+            ? 'arm'
+            : cancelledAtEveryBoundary.has(boundary)
+                ? 'cancel'
+                : 'preserve';
+    if (work === 'executorTimer')
+        return cancelledAtEveryBoundary.has(boundary) ? 'cancel' : 'preserve';
+    if (work === 'waitLease')
+        return boundary === 'proactiveWaitRegistered' ? 'preserve' : 'consume';
+    if (work === 'pendingCheckpoint')
+        return boundary === 'checkpointPersisted' || boundary === 'matchingRootFinal'
+            ? 'preserve'
+            : 'cancel';
+    return boundary === 'manualInterruption' || boundary === 'explicitRecovery'
+        ? 'preserve'
+        : 'cancel';
+}
 /**
  * A canonical, durable representation rather than a clock- or transcript-derived score.
  * The string is intentionally opaque to callers; compare it only for equality.
@@ -31,9 +84,31 @@ export function semanticProgressKey(facts) {
         ownedProcesses: [...facts.ownedProcesses]
             .map(({ id, state, ownerGeneration }) => ({ id, state, ownerGeneration }))
             .sort(compareBy('id')),
+        childActivity: canonicalChildActivity(facts.childActivity),
         agentActivity: latestAgentActivity(facts.agentActivity),
     });
 }
+function canonicalChildActivity(children) {
+    return [...children]
+        .map((child) => ({
+        id: child.id,
+        threadId: child.threadId,
+        taskName: child.taskName,
+        position: child.position,
+        generation: child.generation,
+        state: child.state,
+        outcome: child.outcome,
+        ownedProcesses: [...child.ownedProcesses]
+            .map(({ id, state, ownership }) => ({ id, state, ownership }))
+            .sort((left, right) => canonicalCompare(left, right))
+            .slice(0, 32),
+    }))
+        .sort((left, right) => canonicalCompare(left, right))
+        .slice(0, 64);
+}
+function canonicalCompare(left, right) {
+    return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
 function latestAgentActivity(observations) {
     const latest = new Map();
     for (const observation of observations) {
@@ -169,6 +244,29 @@ export function consumeWaitDeadline(state, leaseId, observedAt) {
         lastReportId: state.lastReportId,
     };
 }
+/**
+ * A persisted Org checkpoint supersedes every pre-boundary wait episode.
+ * Checkpoint delivery is authoritative progress even when the old lease was
+ * waiting for a different executor or process event.
+ */
+export function consumeCheckpointBoundary(state, progressKey) {
+    return consumeObsoleteWait(state, progressKey);
+}
+/** Consumes a stale wait durably, without allowing it to outlive its owner. */
+export function consumeObsoleteWait(state, progressKey) {
+    if (state.outcome === 'attentionRequired' || state.outcome === 'safetyPaused')
+        return {
+            ...state,
+            progressKey,
+            probeKey: null,
+            waitLease: null,
+            retryKey: null,
+        };
+    return {
+        ...startSupervisionProtocol(progressKey),
+        lastReportId: state.lastReportId,
+    };
+}
 /** Manual recovery is the only transition out of durable safety pause. */
 export function recoverSafetyPause(state, progressKey) {
     return state.outcome === 'safetyPaused' ? startSupervisionProtocol(progressKey) : state;

package/dist/server/server/platform/codex/json-rpc-client.js

@@ -52,6 +52,7 @@ export class JsonRpcClient {
     pending = new Map();
     notifications = new Set();
     serverRequests = new Set();
+    serverResponseSettlements = new Set();
     failure = null;
     constructor(input, output) {
         this.output = output;
@@ -80,6 +81,22 @@ export class JsonRpcClient {
         this.serverRequests.add(listener);
         return () => this.serverRequests.delete(listener);
     }
+    onServerResponseSettled(listener) {
+        this.serverResponseSettlements.add(listener);
+        return () => this.serverResponseSettlements.delete(listener);
+    }
+    writeServerResponse(id, response, outcome) {
+        const line = `${JSON.stringify({ jsonrpc: '2.0', id, ...response })}\n`;
+        try {
+            this.output.write(line, (error) => {
+                const settled = error ? 'writeFailed' : outcome;
+                this.serverResponseSettlements.forEach((listener) => listener({ id, outcome: settled }));
+            });
+        }
+        catch {
+            this.serverResponseSettlements.forEach((listener) => listener({ id, outcome: 'writeFailed' }));
+        }
+    }
     receive(line) {
         try {
             const message = JSON.parse(line);
@@ -93,8 +110,8 @@ export class JsonRpcClient {
                 if (!listener)
                     return;
                 void Promise.resolve(listener({ id: message.id, method: message.method, params: message.params }))
-                    .then((result) => this.output.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result })}\n`))
-                    .catch((error) => this.output.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, error: { message: error instanceof Error ? error.message : 'REQUEST_FAILED' } })}\n`));
+                    .then((result) => this.writeServerResponse(message.id, { result }, 'resultWritten'))
+                    .catch((error) => this.writeServerResponse(message.id, { error: { message: error instanceof Error ? error.message : 'REQUEST_FAILED' } }, 'errorWritten'));
                 return;
             }
             const pending = this.pending.get(message.id);