gestalt-mobile 0.18.4 → 0.18.5

package/dist/server/server/composition.js

@@ -90,6 +90,7 @@ export async function composeRelayApp(options) {
     const planMeasurementHelperPath = options.planMeasurementHelperPath ?? process.env.GESTALT_MOBILE_ORG_PLAN_HELPER;
     const withPendingInteractions = (session) => (session ? { ...session, pendingInteractions: interactions.list(session.id) } : null);
     const events = new SessionEventBus();
+    let notifyAutopilotSettled = () => undefined;
     const attentionTransitions = {
         subscribe: (sessionId, listener) => events.subscribe(sessionId, (event) => {
             if (event.type !== 'org-plan.attention-required' &&
@@ -110,7 +111,13 @@ export async function composeRelayApp(options) {
         }),
     };
     options.onAttentionTransitions?.(attentionTransitions);
-    const activity = new AgentActivityRegistry((snapshot, occurredAt) => events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', snapshot, occurredAt)), {
+    const activity = new AgentActivityRegistry((snapshot, occurredAt) => {
+        events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', snapshot, occurredAt));
+        if (snapshot.confidence === 'fresh' &&
+            ['idle', 'blocked'].includes(snapshot.root.state) &&
+            ['idle', 'blocked'].includes(snapshot.aggregateSubagents))
+            notifyAutopilotSettled(snapshot.sessionId);
+    }, {
         // Evidence arms one bounded reconciliation; healthy sessions are never polled.
         schedule: options.activitySchedule ??
             ((callback, delayMs) => {
@@ -209,6 +216,7 @@ export async function composeRelayApp(options) {
             events.publish(journal.append(sessionId, type, payload, occurredAt, outboxId));
         },
     });
+    notifyAutopilotSettled = (sessionId) => autopilot.activitySettled(sessionId);
     options.onAutopilotCoordinator?.(autopilot);
     const workspaces = new FilesystemWorkspaceCatalog(root);
     const models = new CodexModelCatalog(root, options.launchAppServer ?? launchCodexAppServer);

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

@@ -38,7 +38,9 @@ export function decideAutopilot(input) {
         return { kind: 'reconcile' };
     if (Date.parse(now) - Date.parse(activity.root.lastActivityAt) > policy.staleAfterMs)
         return { kind: 'reconcile' };
-    if (activity.root.state !== 'idle' || activity.aggregateSubagents !== 'idle')
+    const rootSettled = activity.root.state === 'idle' || activity.root.state === 'blocked';
+    const subagentsSettled = activity.aggregateSubagents === 'idle' || activity.aggregateSubagents === 'blocked';
+    if (!rootSettled || !subagentsSettled)
         return activity.aggregateSubagents === 'disconnected'
             ? { kind: 'reconcile' }
             : { kind: 'observe' };

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

@@ -145,20 +145,8 @@ export class AutopilotCoordinator {
         const prior = this.deps.store.find(sessionId);
         if (!prior)
             return this.snapshot(sessionId);
-        const plan = this.deps.plan(sessionId);
         const session = this.deps.session(sessionId);
-        const decision = decideAutopilot({
-            state: prior,
-            plan: plan?.plan ?? null,
-            planIdentity: plan?.identity,
-            planFingerprint: plan ? fingerprint(plan.plan) : null,
-            activity: this.deps.activity(sessionId),
-            hasPendingInteraction: this.deps.pendingInteraction(sessionId),
-            hasActiveAttention: prior.state === 'attentionRequired',
-            lastTurnOutcome: this.lastTurnOutcome(sessionId, prior.lastControlId),
-            now: this.deps.now(),
-            policy: this.deps.policy,
-        });
+        const decision = this.decision(sessionId, prior);
         const now = this.deps.now();
         this.deps.diagnostic?.(sessionId, decision.kind);
         let next = prior;
@@ -172,6 +160,21 @@ export class AutopilotCoordinator {
             case 'scheduleContinuation':
                 if (session?.activeTurnId || this.deps.pendingInteraction(sessionId))
                     break;
+                const existingControl = prior.lastControlId
+                    ? this.deps.store.findControl(sessionId, prior.lastControlId)
+                    : null;
+                if (existingControl?.status === 'scheduled') {
+                    const evaluationAt = prior.nextEvaluationAt ?? decision.at;
+                    if (prior.state !== 'backoff' || prior.nextEvaluationAt !== evaluationAt)
+                        this.persist({
+                            ...prior,
+                            state: 'backoff',
+                            nextEvaluationAt: evaluationAt,
+                            updatedAt: now,
+                        });
+                    this.arm(sessionId, prior.generation, evaluationAt);
+                    break;
+                }
                 const scheduledControlId = this.deps.nextControlId(sessionId, prior.generation);
                 next = {
                     ...prior,
@@ -272,9 +275,18 @@ export class AutopilotCoordinator {
         this.evaluate(sessionId);
     }
     turnCompleted(sessionId) {
+        this.activitySettled(sessionId);
+    }
+    activitySettled(sessionId) {
+        const prior = this.deps.store.find(sessionId);
+        if (!prior?.requestedEnabled || prior.state !== 'monitoring')
+            return;
         this.completionTimers.get(sessionId)?.();
         this.completionTimers.set(sessionId, this.deps.schedule(() => {
             this.completionTimers.delete(sessionId);
+            const current = this.deps.store.find(sessionId);
+            if (!current?.requestedEnabled || current.state !== 'monitoring')
+                return;
             this.evaluate(sessionId);
         }, this.deps.policy.quiescenceMs));
     }
@@ -339,13 +351,21 @@ export class AutopilotCoordinator {
     async fire(sessionId, generation) {
         this.timers.delete(sessionId);
         const current = this.deps.store.find(sessionId);
+        if (!current || current.generation !== generation || !current.requestedEnabled)
+            return;
         const session = this.deps.session(sessionId);
-        if (!current ||
-            current.generation !== generation ||
-            !current.requestedEnabled ||
-            session?.activeTurnId ||
-            this.deps.pendingInteraction(sessionId))
+        if (session?.activeTurnId ||
+            this.deps.pendingInteraction(sessionId) ||
+            this.decision(sessionId, current).kind !== 'scheduleContinuation') {
+            this.persist({
+                ...current,
+                state: 'monitoring',
+                nextEvaluationAt: null,
+                updatedAt: this.deps.now(),
+            });
+            this.evaluate(sessionId);
             return;
+        }
         const id = current.lastControlId;
         if (!id)
             return;
@@ -481,6 +501,21 @@ export class AutopilotCoordinator {
             return 'completed';
         return 'unknown';
     }
+    decision(sessionId, state) {
+        const plan = this.deps.plan(sessionId);
+        return decideAutopilot({
+            state,
+            plan: plan?.plan ?? null,
+            planIdentity: plan?.identity,
+            planFingerprint: plan ? fingerprint(plan.plan) : null,
+            activity: this.deps.activity(sessionId),
+            hasPendingInteraction: this.deps.pendingInteraction(sessionId),
+            hasActiveAttention: state.state === 'attentionRequired',
+            lastTurnOutcome: this.lastTurnOutcome(sessionId, state.lastControlId),
+            now: this.deps.now(),
+            policy: this.deps.policy,
+        });
+    }
     async reconcile(sessionId, generation) {
         try {
             const result = await this.deps.reconcile(sessionId);

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

@@ -20,6 +20,14 @@ export const orgPlanAttentionResumeConditions = [
     'permissionGranted',
     'externalStateChanged',
 ];
+export const orgPlanAttentionResumeConditionByReason = {
+    planChange: 'planRevision',
+    hardBlock: 'externalStateChanged',
+    missingDependency: 'dependencyInstalled',
+    permissionRequired: 'permissionGranted',
+    externalState: 'externalStateChanged',
+    materialAmbiguity: 'userGuidance',
+};
 export const gestaltOrgPlanAttentionDynamicTool = {
     type: 'function',
     name: GESTALT_ORG_PLAN_ATTENTION_TOOL_NAME,
@@ -34,6 +42,13 @@ export const gestaltOrgPlanAttentionDynamicTool = {
             requestedAction: { type: 'string', minLength: 1, maxLength: 600 },
             resumeCondition: { type: 'string', enum: orgPlanAttentionResumeConditions },
         },
+        oneOf: orgPlanAttentionReasons.map((reason) => ({
+            properties: {
+                reason: { const: reason },
+                resumeCondition: { const: orgPlanAttentionResumeConditionByReason[reason] },
+            },
+            required: ['reason', 'resumeCondition'],
+        })),
     },
 };
 export function parseOrgPlanAttention(value) {
@@ -42,7 +57,8 @@ export function parseOrgPlanAttention(value) {
     if (!isReason(value.reason) ||
         !isBoundedText(value.summary, 600) ||
         !isBoundedText(value.requestedAction, 600) ||
-        !isResumeCondition(value.resumeCondition))
+        !isResumeCondition(value.resumeCondition) ||
+        orgPlanAttentionResumeConditionByReason[value.reason] !== value.resumeCondition)
         return null;
     return {
         reason: value.reason,

package/package.json

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