gestalt-mobile 0.30.3 → 0.31.0

package/dist/client/index.html

@@ -16,8 +16,8 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-BK3qsn4l.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DHqGG2Sf.css">
+    <script type="module" crossorigin src="/assets/index-DKzUE8x1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DDwVphGb.css">
   </head>
   <body>
     <div id="app"></div>

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

@@ -690,7 +690,9 @@ describe('production composition', () => {
                     url: `/api/sessions/${fixture.sessionId}/autopilot`,
                     payload: { enabled: true },
                 })).statusCode).toBe(200);
-                await vi.waitFor(() => expect(timers).toHaveLength(1));
+                // Initial supervision schedules its control and keeps a separate,
+                // bounded reconciliation watchdog while activity is still stale.
+                await vi.waitFor(() => expect(timers).toHaveLength(2));
                 const staleTimer = timers[0];
                 if (action === 'close') {
                     await writeFile(join(fixture.workspacePath, 'autopilot.org'), completedAutopilotPlanText());
@@ -1366,6 +1368,64 @@ describe('production composition', () => {
         });
     });
     describeCompositionConcern('lifecycle', () => {
+        it('publishes an idle websocket status after saving a completed turn', async () => {
+            const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
+            const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
+            ownTemporaryPaths(root, dataDir);
+            await mkdir(join(root, 'workspace'));
+            const handles = [];
+            const app = await composeAuthorizedApp({
+                root,
+                dataDir,
+                relyingParty,
+                installedCodexVersion: 'codex-cli 0.144.3',
+                startAppServers: true,
+                launchAppServer: liveAppServer(handles),
+                profiles: {
+                    list: async () => [],
+                    require: async () => ({
+                        name: 'default',
+                        state: 'ok',
+                        status: 'ready',
+                    }),
+                },
+            });
+            const sessionId = await createComposedSession(app);
+            const handle = handles.find((candidate) => candidate.notify);
+            expect(handle?.notify).toBeDefined();
+            await app.listen({ host: '127.0.0.1', port: 0 });
+            const address = app.server.address();
+            if (!address || typeof address === 'string')
+                throw new Error('Expected TCP listener');
+            const socket = new WebSocket(`ws://127.0.0.1:${address.port}/api/sessions/${sessionId}/events?after=0`, {
+                headers: {
+                    origin: relyingParty.publicOrigin,
+                    cookie: 'gestalt_mobile_session=test-session',
+                },
+            });
+            const messages = [];
+            socket.on('message', (data) => messages.push(JSON.parse(String(data))));
+            await once(socket, 'open');
+            const started = await app.inject({
+                method: 'POST',
+                url: `/api/sessions/${sessionId}/turns`,
+                payload: { text: 'complete this turn' },
+            });
+            expect(started.statusCode).toBe(202);
+            const turnId = started.json().activeTurnId;
+            handle.notify({ method: 'turn/completed', params: { turn: { id: turnId } } });
+            await vi.waitFor(() => {
+                const status = messages
+                    .filter((message) => message.event.type === 'session.status.updated')
+                    .at(-1)?.event.payload;
+                expect(status).toMatchObject({ state: 'idle' });
+            });
+            expect((await app.inject(`/api/sessions/${sessionId}`)).json()).toMatchObject({
+                activeTurnId: null,
+            });
+            socket.close();
+            await app.close();
+        });
         it('forgets a session while activity reconciliation is pending without publishing late activity', async () => {
             const root = await mkdtemp(join(tmpdir(), 'gestalt-mobile-root-'));
             const dataDir = await mkdtemp(join(tmpdir(), 'gestalt-mobile-state-'));
@@ -2342,6 +2402,7 @@ describe('production composition', () => {
                 agentActivity: { root: { state: 'working' } },
             });
             expect(activityEvents.filter((message) => message.event.type === 'agent.activity.updated')).toHaveLength(initialActivityEvents + 1);
+            expect(JSON.stringify(activityEvents)).not.toMatch(/ownerThreadId|ownerTaskPath|itemId|cpuPercent|rssBytes|resultArtifact/);
             const activitySequence = activityEvents.find((message) => message.event.type === 'agent.activity.updated').event.sequence;
             socket.close();
             const replaySocket = new WebSocket(`ws://127.0.0.1:${address.port}/api/sessions/${sessionId}/events?after=${activitySequence - 1}`, {

package/dist/server/server/composition.js

@@ -34,6 +34,7 @@ import { SessionSupervisor } from './platform/runtime/session-supervisor.js';
 import { mapWithConcurrency } from './platform/runtime/concurrency.js';
 import { RelaySession, } from './features/sessions/model/relay-session.js';
 import { AgentActivityRegistry } from './features/agent-activity/registry.js';
+import { toAgentActivityDto } from './features/agent-activity/activity-dto.js';
 import { decodeAgentActivityFacts } from './platform/codex/activity-facts.js';
 import { isAutopilotWaitLeaseCall, resolvedServerRequestId, toPendingInteraction, } from './platform/codex/server-request.js';
 import { parseOrgPlanCheckpoint, toOrgPlanCheckpointToolResponse, } from '../shared/contracts/org-plan-checkpoint.js';
@@ -51,6 +52,7 @@ import { checkpointPlanMeasurement } from './platform/plans/plan-measurement-com
 import { PlanMeasurementRefresh } from './platform/plans/plan-measurement-refresh.js';
 import { SqliteAutopilotStore } from './platform/persistence/sqlite-autopilot-store.js';
 import { AutopilotCoordinator } from './features/autopilot/application/service.js';
+import { deriveSessionStatus } from './features/sessions/session-status.js';
 import { AUTOPILOT_CONTINUATION_PROMPT, AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT, autopilotExecutorLaunchPrompt, defaultAutopilotPolicy, } from './features/autopilot/application/policy.js';
 import { createRelyingPartyConfig } from './config.js';
 import { parseOrgPlanAttention } from '../shared/contracts/org-plan-attention.js';
@@ -95,6 +97,7 @@ export async function composeRelayApp(options) {
     const withPendingInteractions = (session) => (session ? { ...session, pendingInteractions: interactions.list(session.id) } : null);
     const events = new SessionEventBus();
     let notifyAutopilotActivity = () => undefined;
+    let publishSessionStatus = () => undefined;
     const attentionTransitions = {
         subscribe: (sessionId, listener) => events.subscribe(sessionId, (event) => {
             if (event.type !== 'org-plan.attention-required' &&
@@ -116,7 +119,8 @@ 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));
+        events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', toAgentActivityDto(snapshot), occurredAt));
+        publishSessionStatus(snapshot.sessionId, occurredAt);
         notifyAutopilotActivity(snapshot.sessionId);
     }, {
         // Evidence arms one bounded reconciliation; healthy sessions are never polled.
@@ -287,6 +291,19 @@ export async function composeRelayApp(options) {
         },
     });
     notifyAutopilotActivity = (sessionId) => autopilot.activityChanged(sessionId);
+    publishSessionStatus = (sessionId, occurredAt) => {
+        const session = sessions.find(sessionId);
+        if (!session)
+            return;
+        events.publish(journal.append(sessionId, 'session.status.updated', deriveSessionStatus({
+            session,
+            plan: supervisedPlans.find(sessionId),
+            activity: activity.snapshot(sessionId, occurredAt),
+            autopilot: autopilot.snapshot(sessionId),
+            pendingAttention: interactions.list(sessionId).length > 0,
+            observedAt: occurredAt,
+        }), occurredAt));
+    };
     options.onAutopilotCoordinator?.(autopilot);
     const workspaces = new FilesystemWorkspaceCatalog(root);
     const workspaceFiles = new FilesystemWorkspaceFiles();
@@ -337,6 +354,7 @@ export async function composeRelayApp(options) {
         if (interaction?.kind === 'orgPlanAttention')
             events.publish(journal.append(sessionId, 'org-plan.attention-resolved', { requestId, turnId: interaction.turnId ?? null, resolvedAt: occurredAt, outcome }, occurredAt));
         autopilot.semanticEvent(sessionId, 'interactionChanged');
+        publishSessionStatus(sessionId, occurredAt);
     };
     const publishAttentionSettlement = (sessionId, requestId, occurredAt, outcome) => {
         const remaining = interactions.list(sessionId);
@@ -385,12 +403,12 @@ export async function composeRelayApp(options) {
         if (update.kind === 'updated' && update.reason === 'supervision-start')
             autopilot.supervisionStarted(sessionId);
         autopilot.planStatusChanged(sessionId);
+        publishSessionStatus(sessionId, new Date().toISOString());
     };
     runtime = options.startAppServers
         ? new CodexSessionRuntime(options.launchAppServer ?? launchCodexAppServer, undefined, (sessionId, notification, origin) => {
             const occurredAt = new Date().toISOString();
-            for (const activityFact of decodeAgentActivityFacts(sessionId, occurredAt, notification))
-                activity.observe(activityFact);
+            const activityFacts = decodeAgentActivityFacts(sessionId, occurredAt, notification);
             const resolvedRequestId = resolvedServerRequestId(notification);
             if (resolvedRequestId) {
                 const interaction = interactions.find(sessionId, resolvedRequestId);
@@ -416,8 +434,11 @@ export async function composeRelayApp(options) {
                 ? { ...origin, kind: 'root' }
                 : origin;
             const normalized = normalizeCodexNotification(sessionId, 0, occurredAt, notification, currentSession?.workspacePath, currentSession?.activeTurnId, resolvedOrigin);
-            if (!normalized)
+            if (!normalized) {
+                for (const activityFact of activityFacts)
+                    activity.observe(activityFact);
                 return;
+            }
             let completedSession;
             if (normalized.type === 'turnCompleted') {
                 const turnId = normalized.payload.turn?.id;
@@ -429,6 +450,11 @@ export async function composeRelayApp(options) {
                 }
                 planMeasurementRefresh?.refreshNow(sessionId);
             }
+            // Activity publication also derives and broadcasts the session verdict.
+            // Complete the durable turn first so its status cannot retain the just-finished
+            // activeTurnId while the completion fact makes the root appear idle.
+            for (const activityFact of activityFacts)
+                activity.observe(activityFact);
             events.publish(journal.append(sessionId, normalized.type, normalized.payload, normalized.occurredAt));
             if (completedSession)
                 events.publish(journal.append(sessionId, 'session.updated', completedSession, occurredAt));

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Public roster projection: never expose process, thread, task-path, or host metrics identifiers. */
+export function toAgentActivityDto(snapshot) {
+    return {
+        sessionId: snapshot.sessionId,
+        root: snapshot.root,
+        subagents: snapshot.subagents.slice(0, 64).map((child) => ({
+            id: child.id,
+            ...(child.nickname ? { nickname: child.nickname } : {}),
+            ...(child.role ? { role: child.role } : {}),
+            ...(child.model ? { model: child.model } : {}),
+            ...(child.canonicalTaskName ? { canonicalTaskName: child.canonicalTaskName } : {}),
+            ...(child.canonicalPosition ? { canonicalPosition: child.canonicalPosition } : {}),
+            ...(child.continuationGeneration
+                ? { continuationGeneration: child.continuationGeneration }
+                : {}),
+            ...(child.outcome ? { outcome: child.outcome } : {}),
+            ownedProcesses: (child.ownedProcesses ?? []).slice(0, 64).map((process) => ({
+                state: process.state,
+                ownership: process.ownership,
+                observedAt: process.observedAt,
+            })),
+            state: child.state,
+            reason: child.reason,
+            observedAt: child.observedAt,
+            lastActivityAt: child.lastActivityAt,
+        })),
+        aggregateSubagents: snapshot.aggregateSubagents,
+        confidence: snapshot.confidence,
+    };
+}

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

@@ -84,6 +84,9 @@ export function projectAgentActivity(current, fact) {
             const before = children.get(fact.childId);
             const taskPath = fact.childTaskPath ?? before?.taskPath;
             const identity = taskPath ? parseOrgPlanAgentIdentity(taskPath) : null;
+            const terminalReviewer = taskPath?.split('/').filter(Boolean).at(-1) === 'final_review' ||
+                before?.canonicalTaskName === 'final_review' ||
+                fact.childRole === 'org-plan-reviewer';
             const outcome = childOutcome(fact.childStatus, fact.collaborationAction, before?.outcome);
             const child = Object.freeze({
                 id: fact.childId,
@@ -110,7 +113,9 @@ export function projectAgentActivity(current, fact) {
                         canonicalPosition: identity.canonicalPosition,
                         continuationGeneration: identity.generation,
                     }
-                    : {}),
+                    : terminalReviewer
+                        ? { canonicalTaskName: 'final_review' }
+                        : {}),
                 ...(outcome ? { outcome } : {}),
                 ...(fact.childOwnedProcesses
                     ? { ownedProcesses: Object.freeze([...fact.childOwnedProcesses]) }
@@ -143,14 +148,20 @@ export function projectAgentActivity(current, fact) {
 export function withActivityConfidence(snapshot, confidence) {
     return snapshot.confidence === confidence ? snapshot : Object.freeze({ ...snapshot, confidence });
 }
-/** Process loss revokes child identities; recovery must repopulate them from a fresh list read. */
+/**
+ * A process disconnect makes the roster stale, but is not evidence that its
+ * children ceased to exist. Keep their authoritative identity and present the
+ * last known physical generation as disconnected until disposal or a later
+ * reconciliation replaces it.
+ */
 export function clearAgentActivityChildren(snapshot) {
     if (snapshot.subagents.length === 0 && snapshot.aggregateSubagents === 'idle')
         return snapshot;
+    const subagents = Object.freeze(snapshot.subagents.map((child) => Object.freeze({ ...child, state: 'disconnected', reason: 'processExited' })));
     return Object.freeze({
         ...snapshot,
-        subagents: Object.freeze([]),
-        aggregateSubagents: 'idle',
+        subagents,
+        aggregateSubagents: aggregate(subagents),
     });
 }
 function applyStatus(root, status) {
@@ -231,6 +242,12 @@ function semantic(snapshot) {
             nickname: child.nickname,
             role: child.role,
             model: child.model,
+            taskPath: child.taskPath,
+            canonicalTaskName: child.canonicalTaskName,
+            canonicalPosition: child.canonicalPosition,
+            continuationGeneration: child.continuationGeneration,
+            outcome: child.outcome,
+            ownedProcesses: child.ownedProcesses,
             state: child.state,
             reason: child.reason,
         })),

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

@@ -3,6 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { deriveSessionStatus } from '../../sessions/session-status.js';
 import { createHash } from 'node:crypto';
 import { autopilotSnapshot, disabledAutopilot, } from '../domain/autopilot-session.js';
 import { classifyExecutorOutcome, decideSupervisedLifecycle, executorIdentity, validStructuredBlock, } from '../domain/supervised-lifecycle.js';
@@ -16,13 +17,21 @@ export class AutopilotCoordinator {
     publishedSnapshots = new Map();
     planEventKeys = new Map();
     activityEventKeys = new Map();
+    /** Durable wait data is not proof that this process has a live subscription. */
+    parkedSubscriptions = new Map();
+    /** One reconciliation owns a session until it has published its next wake. */
+    reconciling = new Set();
     /** Serializes asynchronous watchdog and timer work per relay session. */
     operations = new Map();
     constructor(deps) {
         this.deps = deps;
     }
     snapshot(sessionId) {
-        return autopilotSnapshot(this.deps.store.find(sessionId) ?? disabledAutopilot(sessionId, this.deps.now()), this.deps.policy.retryLimit);
+        const state = this.deps.store.find(sessionId) ?? disabledAutopilot(sessionId, this.deps.now());
+        const control = state.lastControlId
+            ? this.deps.store.findControl(sessionId, state.lastControlId)
+            : null;
+        return this.snapshotFor(state, control ?? undefined);
     }
     controlIds(sessionId) {
         return this.deps.store.controlIds(sessionId);
@@ -45,8 +54,31 @@ export class AutopilotCoordinator {
         // coordinator. The plan-status watcher is authoritative and asynchronous,
         // so retaining enabled durable state until it supplies the projection is
         // safer than interpreting this short bootstrap gap as plan removal.
-        if (!this.deps.plan(sessionId))
+        const retained = this.deps.plan(sessionId);
+        if (!retained)
             return;
+        if (state.supervision?.outcome === 'parked') {
+            if (retained.identity !== state.planIdentity) {
+                this.parkedSubscriptions.delete(sessionId);
+                return;
+            }
+            const validated = autopilotSnapshot(state, this.deps.policy.retryLimit, {
+                activeTurn: Boolean(session.activeTurnId),
+                executorActive: false,
+                control: 'none',
+                timerArmed: false,
+                reconciling: false,
+                planMatches: true,
+                parkedSubscriptionActive: true,
+                transitionFresh: true,
+                observedAt: this.deps.now(),
+            });
+            if (state.supervision.waitLease && validated.health.wait.wakeCategories.length > 0) {
+                this.parkedSubscriptions.set(sessionId, state.supervision.waitLease.id);
+                return;
+            }
+            this.parkedSubscriptions.delete(sessionId);
+        }
         const control = state.lastControlId
             ? this.deps.store.findControl(sessionId, state.lastControlId)
             : null;
@@ -83,6 +115,8 @@ export class AutopilotCoordinator {
         this.cancelTimer(sessionId);
         this.planEventKeys.delete(sessionId);
         this.activityEventKeys.delete(sessionId);
+        this.reconciling.delete(sessionId);
+        this.parkedSubscriptions.delete(sessionId);
     }
     /** Accepts a session-owned structured probe response; no transcript text is inspected. */
     reportProbe(sessionId, report) {
@@ -92,6 +126,10 @@ export class AutopilotCoordinator {
         const nextProtocol = reportProbe(state.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), report);
         if (nextProtocol === state.supervision)
             return false;
+        if (nextProtocol.outcome === 'parked' && nextProtocol.waitLease)
+            this.parkedSubscriptions.set(sessionId, nextProtocol.waitLease.id);
+        else
+            this.parkedSubscriptions.delete(sessionId);
         const now = this.deps.now();
         this.persist({
             ...state,
@@ -149,6 +187,7 @@ export class AutopilotCoordinator {
         const nextProtocol = consumeObservableWake(state.supervision, wake);
         if (nextProtocol === state.supervision)
             return false;
+        this.parkedSubscriptions.delete(sessionId);
         this.persist({ ...state, supervision: nextProtocol, updatedAt: this.deps.now() });
         this.evaluate(sessionId);
         return true;
@@ -176,6 +215,7 @@ export class AutopilotCoordinator {
         const now = this.deps.now();
         const prior = this.deps.store.find(sessionId) ?? disabledAutopilot(sessionId, now);
         const nextFingerprint = fingerprint(currentPlan.plan);
+        const replacing = Boolean(prior.planIdentity && prior.planIdentity !== currentPlan.identity);
         if (prior.requestedEnabled &&
             prior.planIdentity === currentPlan.identity &&
             prior.state !== 'attentionRequired')
@@ -192,7 +232,12 @@ export class AutopilotCoordinator {
             stopReason: null,
             executor: undefined,
             blocking: undefined,
-            supervision: recoverSafetyPause(prior.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId)),
+            // A replacement plan cannot inherit a parked lease, retry key, or probe
+            // budget from a different semantic plan identity. Re-enabling the same
+            // plan still preserves its non-terminal protocol state.
+            supervision: replacing
+                ? startSupervisionProtocol(this.progressKey(sessionId))
+                : recoverSafetyPause(prior.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId)),
             updatedAt: now,
         };
         this.persist(next);
@@ -263,7 +308,17 @@ export class AutopilotCoordinator {
                 break;
             case 'reconcile':
                 next = { ...prior, state: 'monitoring', nextEvaluationAt: null, updatedAt: now };
-                this.enqueue(sessionId, () => this.reconcile(sessionId, prior.generation));
+                if (!this.reconciling.has(sessionId)) {
+                    this.reconciling.add(sessionId);
+                    this.enqueue(sessionId, async () => {
+                        try {
+                            await this.reconcile(sessionId, prior.generation);
+                        }
+                        finally {
+                            this.reconciling.delete(sessionId);
+                        }
+                    });
+                }
                 break;
             case 'scheduleContinuation':
                 if (session?.activeTurnId || this.deps.pendingInteraction(sessionId))
@@ -308,6 +363,9 @@ export class AutopilotCoordinator {
                     failureCode: null,
                     turnId: null,
                 };
+                // The durable event must describe an actually armed future wake, not
+                // merely a control row that is about to receive one.
+                this.arm(sessionId, prior.generation, decision.at);
                 this.persist(next, control, [
                     {
                         sessionId,
@@ -317,7 +375,6 @@ export class AutopilotCoordinator {
                     },
                 ]);
                 next = prior;
-                this.arm(sessionId, prior.generation, decision.at);
                 break;
             case 'requestAttention': {
                 const blocking = this.deps.attention?.(sessionId) ?? undefined;
@@ -475,7 +532,11 @@ export class AutopilotCoordinator {
                 occurredAt,
             },
         ]);
-        this.semanticEvent(sessionId, 'checkpointChanged');
+        // A lease only optimizes a probe that deliberately yielded. Checkpoints are
+        // authoritative progress events in their own right, so an incomplete plan
+        // must be evaluated even when no probe (and therefore no lease) exists.
+        if (!this.semanticEvent(sessionId, 'checkpointChanged'))
+            this.evaluate(sessionId);
         return true;
     }
     /** Handles only plan lifecycle safety; ordinary plan mutations are ignored. */
@@ -495,13 +556,15 @@ export class AutopilotCoordinator {
         if (this.semanticEvent(sessionId, 'planChanged') ||
             this.semanticEvent(sessionId, 'reviewChanged'))
             return;
-        if (executionComplete(plan.plan)) {
-            const eventKey = `plan:${fingerprint(plan.plan)}`;
-            if (this.planEventKeys.get(sessionId) === eventKey)
-                return;
-            this.planEventKeys.set(sessionId, eventKey);
-            this.evaluate(sessionId);
-        }
+        // Plan and review changes are mandatory lifecycle inputs, not merely a
+        // completion detector.  A parked lease consumes the event above; without
+        // one, directly evaluate so an accepted L1 or a partial transition cannot
+        // strand the root waiting for unrelated activity.
+        const eventKey = `plan:${fingerprint(plan.plan)}`;
+        if (this.planEventKeys.get(sessionId) === eventKey)
+            return;
+        this.planEventKeys.set(sessionId, eventKey);
+        this.evaluate(sessionId);
     }
     /**
      * Records a validated, session-private supervision request.  It intentionally
@@ -540,6 +603,9 @@ export class AutopilotCoordinator {
             stopReason: null,
             executor: undefined,
             blocking: undefined,
+            supervision: replacing
+                ? startSupervisionProtocol(this.progressKey(sessionId))
+                : recoverSafetyPause(prior.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId)),
             updatedAt: now,
         };
         this.persist(next, cancelled);
@@ -554,8 +620,12 @@ export class AutopilotCoordinator {
         if (!prior?.requestedEnabled)
             return;
         const activity = this.deps.activity(sessionId);
-        if (!activity || activity.confidence !== 'fresh')
+        // A stale or absent activity projection is itself a mandatory wake input.
+        // Do not require a probe lease to restore the authoritative topology.
+        if (!activity || activity.confidence !== 'fresh') {
+            this.evaluate(sessionId);
             return;
+        }
         const eventKey = JSON.stringify({
             root: [activity.root.state, activity.root.reason],
             children: activity.subagents.map((child) => [
@@ -580,6 +650,10 @@ export class AutopilotCoordinator {
             this.evaluate(sessionId);
             return;
         }
+        if (disposition === 'reconcile') {
+            this.evaluate(sessionId);
+            return;
+        }
         if (disposition === 'active') {
             this.cancelTimer(sessionId);
             const now = this.deps.now();
@@ -651,8 +725,12 @@ export class AutopilotCoordinator {
             consecutiveNoProgress: prior.consecutiveNoProgress + 1,
             updatedAt: now,
         };
+        const priorControl = this.deps.store.findControl(sessionId, controlId);
+        if (!priorControl || priorControl.status !== 'scheduled')
+            return false;
+        const issuedControl = { ...priorControl, status: 'issued', updatedAt: now };
         const events = [
-            ...this.snapshotEvents(next),
+            ...this.snapshotEvents(next, issuedControl),
             { sessionId, type: 'autopilot.control-issued', payload: { controlId }, occurredAt: now },
         ];
         const control = this.deps.store.claimControlIssued
@@ -660,19 +738,19 @@ export class AutopilotCoordinator {
             : this.legacyClaim(sessionId, controlId, next, events);
         if (!control)
             return false;
-        this.publishedSnapshots.set(sessionId, this.semanticSnapshot(next));
+        this.publishedSnapshots.set(sessionId, this.semanticSnapshot(next, control));
         this.flushOutbox(sessionId);
         return true;
     }
     persist(next, control, events = []) {
-        const snapshotEvents = this.snapshotEvents(next);
+        const snapshotEvents = this.snapshotEvents(next, control);
         this.commit({
             state: next,
             ...(control ? { control } : {}),
             events: [...snapshotEvents, ...events],
         });
         if (snapshotEvents.length)
-            this.publishedSnapshots.set(next.sessionId, this.semanticSnapshot(next));
+            this.publishedSnapshots.set(next.sessionId, this.semanticSnapshot(next, control));
         this.flushOutbox(next.sessionId);
     }
     arm(sessionId, generation, at) {
@@ -1081,23 +1159,86 @@ export class AutopilotCoordinator {
         });
         this.flushOutbox(sessionId);
     }
-    semanticSnapshot(next) {
+    authoritativeExecutorActive(next, plan, activity) {
+        if (!plan || activity?.confidence !== 'fresh')
+            return false;
+        const selected = plan.steps.findIndex((step) => step.id === plan.currentStepId || step.state === 'WIP');
+        const index = selected >= 0 ? selected : plan.steps.findIndex((step) => step.state !== 'DONE');
+        if (index < 0)
+            return false;
+        const position = `L${index + 1}`;
+        const taskName = `l${index + 1}`;
+        const child = activity.subagents
+            .filter((candidate) => candidate.canonicalPosition === position &&
+            candidate.canonicalTaskName === taskName &&
+            (!next.executor ||
+                ((candidate.threadId ?? candidate.id) === next.executor.threadId &&
+                    candidate.taskPath === next.executor.taskPath)))
+            .sort((left, right) => (right.continuationGeneration ?? 1) - (left.continuationGeneration ?? 1))[0];
+        return Boolean(child &&
+            (child.state === 'working' ||
+                child.state === 'awaitingAgent' ||
+                child.ownedProcesses?.some((process) => process.state === 'running' || process.state === 'detached-active')));
+    }
+    /** Builds both GET and pre-commit event payloads from the same prospective facts. */
+    snapshotFor(next, prospectiveControl) {
+        const session = this.deps.session(next.sessionId);
+        const plan = this.deps.plan(next.sessionId);
+        const activity = this.deps.activity(next.sessionId);
+        const now = this.deps.now();
+        const control = prospectiveControl ??
+            (next.lastControlId ? this.deps.store.findControl(next.sessionId, next.lastControlId) : null);
+        return autopilotSnapshot(next, this.deps.policy.retryLimit, {
+            activeTurn: Boolean(session?.activeTurnId),
+            executorActive: this.authoritativeExecutorActive(next, plan?.plan ?? null, activity),
+            control: control?.status ?? 'none',
+            timerArmed: this.timers.has(next.sessionId),
+            reconciling: this.reconciling.has(next.sessionId),
+            planMatches: Boolean(plan && plan.identity === next.planIdentity),
+            parkedSubscriptionActive: Boolean(next.supervision?.waitLease) &&
+                this.parkedSubscriptions.get(next.sessionId) === next.supervision?.waitLease?.id,
+            transitionFresh: Date.parse(now) - Date.parse(next.updatedAt) <= 120_000,
+            observedAt: now,
+        });
+    }
+    semanticSnapshot(next, control) {
         return JSON.stringify({
-            ...autopilotSnapshot(next, this.deps.policy.retryLimit),
+            ...this.snapshotFor(next, control),
             updatedAt: '',
         });
     }
-    snapshotEvents(next) {
-        const semantic = this.semanticSnapshot(next);
+    snapshotEvents(next, control) {
+        const semantic = this.semanticSnapshot(next, control);
         if (this.publishedSnapshots.get(next.sessionId) === semantic)
             return [];
+        const session = this.deps.session(next.sessionId);
+        const plan = this.deps.plan(next.sessionId)?.plan ?? null;
+        const activity = this.deps.activity(next.sessionId);
+        const snapshot = this.snapshotFor(next, control);
         return [
             {
                 sessionId: next.sessionId,
                 type: 'autopilot.updated',
-                payload: autopilotSnapshot(next, this.deps.policy.retryLimit),
+                payload: snapshot,
                 occurredAt: next.updatedAt,
             },
+            ...(session
+                ? [
+                    {
+                        sessionId: next.sessionId,
+                        type: 'session.status.updated',
+                        payload: deriveSessionStatus({
+                            session,
+                            plan,
+                            activity,
+                            autopilot: snapshot,
+                            pendingAttention: this.deps.pendingInteraction(next.sessionId),
+                            observedAt: next.updatedAt,
+                        }),
+                        occurredAt: next.updatedAt,
+                    },
+                ]
+                : []),
         ];
     }
     flushOutbox(sessionId) {
@@ -1215,8 +1356,15 @@ export class AutopilotCoordinator {
             const activity = this.deps.activity(sessionId);
             if (activity?.confidence === 'fresh' &&
                 Date.parse(this.deps.now()) - Date.parse(activity.root.lastActivityAt) <=
-                    this.deps.policy.staleAfterMs)
+                    this.deps.policy.staleAfterMs) {
                 this.evaluate(sessionId);
+            }
+            else {
+                // A compatible read that did not yield fresh actor evidence is not a
+                // healthy wait. Keep one bounded watchdog armed for missed activity or
+                // late runtime recovery rather than silently settling the supervisor.
+                this.armExecutorRefresh(sessionId, this.deps.policy.executorContinuationMaxMs);
+            }
         }
         catch {
             const current = this.deps.store.find(sessionId);