gestalt-mobile 0.37.0 → 0.37.1

package/dist/server/server/composition.js

@@ -149,18 +149,18 @@ export async function composeRelayApp(options) {
         reconcile: async (sessionId) => {
             const session = sessions.find(sessionId);
             if (!session)
-                return;
+                return false;
             // Kimi sessions own no child-process projection; one detached history
             // read supplies the whole reconciliation, mirroring the codex tail.
             if (session.provider === 'kimi') {
                 if (!kimiRuntime)
-                    return;
+                    return false;
                 const history = await kimiRuntime.readHistory(session);
                 // Forget may commit while the detached history reader is still in
                 // flight. Revalidate ownership before handing its result to the
                 // registry, whose publisher intentionally keeps the journal strict.
                 if (!sessions.find(sessionId))
-                    return;
+                    return false;
                 const occurredAt = new Date().toISOString();
                 activity.observe({
                     sessionId,
@@ -169,16 +169,22 @@ export async function composeRelayApp(options) {
                     ...(session.threadId ? { threadId: session.threadId } : {}),
                     ...(history.activeTurnId ? { turnId: history.activeTurnId } : {}),
                 });
-                return;
+                return true;
             }
             if (!runtime)
-                return;
+                return false;
             const history = await runtime.readHistory(session);
-            // Forget may commit while the detached history reader is still in
-            // flight. Revalidate ownership before handing its result to the
-            // registry, whose publisher intentionally keeps the journal strict.
+            const children = await runtime.listDirectChildren(session);
+            const childProcesses = new Map();
+            await mapWithConcurrency([...children], 4, async (child) => {
+                childProcesses.set(child.id, await runtime.inspectChildProcesses(session, child));
+            });
+            // The writer read is also asynchronous; it cannot publish after the
+            // durable owner has gone away either.
             if (!sessions.find(sessionId))
-                return;
+                return false;
+            // Publish only after the entire authoritative read succeeds. A fresh
+            // root with stale child topology is not a valid supervision snapshot.
             const occurredAt = new Date().toISOString();
             activity.observe({
                 sessionId,
@@ -187,19 +193,11 @@ export async function composeRelayApp(options) {
                 ...(session.threadId ? { threadId: session.threadId } : {}),
                 ...(history.activeTurnId ? { turnId: history.activeTurnId } : {}),
             });
-            const children = await runtime.listDirectChildren(session);
-            const childProcesses = new Map();
-            await mapWithConcurrency([...children], 4, async (child) => {
-                childProcesses.set(child.id, await runtime.inspectChildProcesses(session, child));
-            });
-            // The writer read is also asynchronous; it cannot publish after the
-            // durable owner has gone away either.
-            if (!sessions.find(sessionId))
-                return;
             activity.childrenReconciled(sessionId, occurredAt, children.map((child) => ({
                 ...child,
                 processes: childProcesses.get(child.id) ?? [],
             })));
+            return true;
         },
     });
     const autopilot = new AutopilotCoordinator({

package/dist/server/server/features/agent-activity/registry.js

@@ -157,7 +157,9 @@ export class AgentActivityRegistry {
         const now = this.options.now?.() ?? new Date().toISOString();
         this.reconciling(sessionId, now);
         try {
-            await this.options.reconcile?.(sessionId);
+            const observed = await this.options.reconcile?.(sessionId);
+            if (observed !== true)
+                throw new Error('AGENT_ACTIVITY_RECONCILE_NO_EVIDENCE');
             if (this.#generation.get(sessionId) === generation)
                 this.reconciled(sessionId, this.options.now?.() ?? now);
         }

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

@@ -91,7 +91,7 @@ export function decideAutopilot(input) {
         return { kind: 'safetyPause', reason: 'actionRateExceeded' };
     if (!activity || activity.confidence !== 'fresh')
         return { kind: 'reconcile' };
-    if (Date.parse(now) - Date.parse(activity.root.lastActivityAt) > policy.staleAfterMs)
+    if (Date.parse(now) - Date.parse(activity.root.observedAt) > policy.staleAfterMs)
         return { kind: 'reconcile' };
     const disposition = classifyAgentActivity(activity);
     if (disposition === 'attention')

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

@@ -417,9 +417,11 @@ export class AutopilotCoordinator {
             case 'scheduleContinuation':
                 if (session?.activeTurnId || this.deps.pendingInteraction(sessionId))
                     break;
+                const plan = this.deps.plan(sessionId)?.plan;
                 if (this.deps.executorController &&
-                    this.deps.plan(sessionId)?.plan &&
-                    this.currentExecutor(sessionId, this.deps.plan(sessionId).plan, prior.consecutiveNoProgress, prior.executor)) {
+                    plan &&
+                    !this.requiresRootBoundary(prior, plan) &&
+                    this.currentExecutor(sessionId, plan, prior.consecutiveNoProgress, prior.executor)) {
                     this.enqueue(sessionId, async () => {
                         await this.enforceSupervisedLifecycle(sessionId, 'stateChanged');
                     });
@@ -1012,6 +1014,7 @@ export class AutopilotCoordinator {
         if (this.deps.executorController &&
             retained &&
             !current.executor?.replacement &&
+            !this.requiresRootBoundary(current, retained.plan) &&
             this.currentExecutor(sessionId, retained.plan, current.consecutiveNoProgress, current.executor)) {
             const now = this.deps.now();
             const cancelled = this.cancelScheduledControl(current, now);
@@ -1159,6 +1162,10 @@ export class AutopilotCoordinator {
             !state?.requestedEnabled ||
             this.deps.pendingInteraction(sessionId))
             return false;
+        // Checkpoints are root-owned report boundaries. Once an executor has made
+        // one eligible, never mechanically resume it past the unreported result.
+        if (this.requiresRootBoundary(state, retained.plan))
+            return false;
         const executor = this.currentExecutor(sessionId, retained.plan, state.consecutiveNoProgress, state.executor);
         const executorChanged = executor ? this.persistExecutor(sessionId, executor) : false;
         if (executor && (await this.reconcileSplitBrain(sessionId, executor)))
@@ -1167,6 +1174,18 @@ export class AutopilotCoordinator {
             this.supersedeExecutorCommands(sessionId, retained.identity, retained.plan, executor);
         if (executorChanged && this.wakeForExecutorChange(sessionId, executor))
             return true;
+        if (executor && this.executorTurnActive(executor, this.deps.activity(sessionId))) {
+            // A malformed root yield must not send a duplicate continuation into a
+            // still-running executor. A valid parked lease already owns its wake;
+            // otherwise retain one bounded reconciliation watchdog as the fallback.
+            const parkedLease = state.supervision?.waitLease;
+            const parkedWakeLive = state.supervision?.outcome === 'parked' &&
+                parkedLease &&
+                this.parkedSubscriptions.get(sessionId) === parkedLease.id;
+            if (!parkedWakeLive)
+                this.armExecutorRefresh(sessionId, this.deps.policy.executorContinuationMaxMs);
+            return true;
+        }
         const decision = decideSupervisedLifecycle({
             plan: retained.plan,
             event,
@@ -1249,6 +1268,21 @@ export class AutopilotCoordinator {
             }
         }
     }
+    requiresRootBoundary(state, plan) {
+        const reportedL2 = new Set(state.checkpoints?.reportedL2Ids ?? []);
+        const reportedL1 = new Set(state.checkpoints?.reportedL1Ids ?? []);
+        const epochs = new Map(state.checkpoints?.completionEpochs?.map((entry) => [entry.target, entry]) ?? []);
+        const epochNeedsReport = (target) => {
+            const epoch = epochs.get(target);
+            return Boolean(epoch?.reopened || epoch?.completed === false);
+        };
+        return plan.steps.some((l1) => l1.children.some((l2) => l2.state === 'DONE' &&
+            (!reportedL2.has(JSON.stringify([l1.id, l2.id])) ||
+                epochNeedsReport(checkpointTarget('l2', l1.id, l2.id)))) ||
+            (l1.state === 'DONE' &&
+                l1.reviewStatus === 'REVIEWED' &&
+                (!reportedL1.has(l1.id) || epochNeedsReport(checkpointTarget('l1', l1.id)))));
+    }
     currentExecutor(sessionId, plan, continuationCount, persisted) {
         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');
@@ -1987,6 +2021,14 @@ export class AutopilotCoordinator {
                 child.state === 'awaitingAgent' ||
                 child.ownedProcesses?.some((process) => process.state === 'running' || process.state === 'detached-active')));
     }
+    executorTurnActive(executor, activity) {
+        if (activity?.confidence !== 'fresh')
+            return false;
+        const child = activity.subagents.find((candidate) => (candidate.threadId ?? candidate.id) === executor.threadId &&
+            candidate.taskPath === executor.taskPath &&
+            (candidate.continuationGeneration ?? 1) === executor.continuationGeneration);
+        return child?.state === 'working' || child?.state === 'awaitingAgent';
+    }
     /** Builds both GET and pre-commit event payloads from the same prospective facts. */
     snapshotFor(next, prospectiveControl) {
         const session = this.deps.session(next.sessionId);
@@ -2180,7 +2222,7 @@ export class AutopilotCoordinator {
             // yield to. A later activity/watchdog event will evaluate it again.
             const activity = this.deps.activity(sessionId);
             if (activity?.confidence === 'fresh' &&
-                Date.parse(this.deps.now()) - Date.parse(activity.root.lastActivityAt) <=
+                Date.parse(this.deps.now()) - Date.parse(activity.root.observedAt) <=
                     this.deps.policy.staleAfterMs) {
                 this.evaluate(sessionId);
             }

package/package.json

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