gestalt-mobile 0.30.2 → 0.31.0

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);

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 { observableWakeConditions, } from './supervision-protocol.js';
 export function disabledAutopilot(sessionId, now) {
     return {
         sessionId,
@@ -18,10 +19,99 @@ export function disabledAutopilot(sessionId, now) {
         updatedAt: now,
     };
 }
-export function autopilotSnapshot(state, retryLimit) {
+export function autopilotSnapshot(state, retryLimit, facts = {
+    activeTurn: false,
+    executorActive: false,
+    control: 'none',
+    timerArmed: false,
+    reconciling: false,
+    planMatches: false,
+    parkedSubscriptionActive: false,
+    transitionFresh: false,
+    observedAt: state.updatedAt,
+}) {
+    const supervision = state.supervision?.outcome ?? 'none';
+    const waitCategories = supportedWakeCategories(state.supervision?.waitLease?.wakeConditions ?? []);
+    const parkedWait = supervision === 'parked' && waitCategories.length > 0 && facts.parkedSubscriptionActive;
+    const evaluationAt = state.nextEvaluationAt ? Date.parse(state.nextEvaluationAt) : Number.NaN;
+    const scheduled = state.state === 'backoff' &&
+        facts.control === 'scheduled' &&
+        facts.timerArmed &&
+        Number.isFinite(evaluationAt) &&
+        evaluationAt > Date.parse(facts.observedAt);
+    const rootWorking = facts.activeTurn;
+    // Runtime observations are current at observedAt.  A slow or old durable
+    // transition must not turn an actually active root/timer/reconciliation or
+    // installed wait lease into a false idle signal.
+    const liveContinuation = parkedWait || scheduled || rootWorking || facts.executorActive || facts.reconciling;
+    const healthy = state.requestedEnabled &&
+        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.';
     return {
         state: state.state,
         enabled: state.requestedEnabled,
+        health: {
+            healthy,
+            phase,
+            supervision,
+            wait: {
+                present: Boolean(state.supervision?.waitLease),
+                wakeCategories: [...waitCategories].slice(0, 9),
+            },
+            observedAt: facts.observedAt,
+            lastTransitionAt: state.updatedAt,
+            nextExpectedAction,
+            ...(!healthy && state.requestedEnabled
+                ? {
+                    degradationReason: !facts.planMatches
+                        ? 'planMismatch'
+                        : !facts.transitionFresh ||
+                            (Number.isFinite(evaluationAt) && evaluationAt <= Date.parse(facts.observedAt))
+                            ? 'staleTransition'
+                            : state.supervision?.waitLease && !parkedWait
+                                ? 'invalidWaitLease'
+                                : 'missingContinuation',
+                }
+                : {}),
+        },
         ...(state.stopReason ? { reason: state.stopReason } : {}),
         retry: { position: state.consecutiveNoProgress, limit: retryLimit },
         ...(state.lastControlId
@@ -40,3 +130,12 @@ export function autopilotSnapshot(state, retryLimit) {
         updatedAt: state.updatedAt,
     };
 }
+function supportedWakeCategories(conditions) {
+    if (conditions.length > observableWakeConditions.length)
+        return [];
+    const categories = conditions.filter((condition) => typeof condition === 'string' &&
+        observableWakeConditions.includes(condition));
+    return categories.length === conditions.length && new Set(categories).size === categories.length
+        ? categories
+        : [];
+}

package/dist/server/server/features/sessions/get-session/endpoint.js

@@ -4,16 +4,30 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { buildResumeCommand } from '../application/resume-command.js';
-export function registerGetSession(app, find, activity, autopilot) {
+import { toAgentActivityDto } from '../../agent-activity/activity-dto.js';
+import { deriveSessionStatus } from '../session-status.js';
+export function registerGetSession(app, find, activity, autopilot, plan) {
     app.get('/api/sessions/:id', async (request, reply) => {
         const session = find(request.params.id);
-        return session
-            ? reply.send({
-                ...session,
-                ...(activity ? { agentActivity: activity(session.id) } : {}),
-                ...(autopilot ? { autopilot: autopilot(session.id) } : {}),
-                resumeCommand: session.threadId ? buildResumeCommand(session) : null,
-            })
-            : reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const activitySnapshot = activity?.(session.id) ?? null;
+        const autopilotSnapshot = autopilot?.(session.id) ?? null;
+        const retainedPlan = plan?.(session.id) ?? null;
+        return reply.send({
+            ...session,
+            ...(activitySnapshot ? { agentActivity: toAgentActivityDto(activitySnapshot) } : {}),
+            ...(autopilotSnapshot ? { autopilot: autopilotSnapshot } : {}),
+            ...(retainedPlan ? { plan: retainedPlan } : {}),
+            sessionStatus: deriveSessionStatus({
+                session,
+                plan: retainedPlan,
+                activity: activitySnapshot,
+                autopilot: autopilotSnapshot,
+                pendingAttention: Boolean(session.pendingInteractions?.length),
+                observedAt: new Date().toISOString(),
+            }),
+            resumeCommand: session.threadId ? buildResumeCommand(session) : null,
+        });
     });
 }

package/dist/server/server/features/sessions/list-sessions/endpoint.js

@@ -4,14 +4,26 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { buildResumeCommand } from '../application/resume-command.js';
+import { toAgentActivityDto } from '../../agent-activity/activity-dto.js';
+import { deriveSessionStatus } from '../session-status.js';
 export function registerListSessions(app, deps) {
     app.get('/api/sessions', async () => deps.list().map((session) => {
         const plan = deps.plan?.(session.id) ?? null;
+        const activity = deps.activity?.(session.id) ?? null;
+        const autopilot = deps.autopilot?.(session.id) ?? null;
         return {
             ...session,
-            ...(deps.activity ? { agentActivity: deps.activity(session.id) } : {}),
-            ...(deps.autopilot ? { autopilot: deps.autopilot(session.id) } : {}),
+            ...(activity ? { agentActivity: toAgentActivityDto(activity) } : {}),
+            ...(autopilot ? { autopilot } : {}),
             ...(plan ? { plan } : {}),
+            sessionStatus: deriveSessionStatus({
+                session,
+                plan,
+                activity,
+                autopilot,
+                pendingAttention: Boolean(session.pendingInteractions?.length),
+                observedAt: new Date().toISOString(),
+            }),
             resumeCommand: session.threadId ? buildResumeCommand(session) : null,
         };
     }));

package/dist/server/server/features/sessions/register-routes.js

@@ -48,7 +48,7 @@ export function registerSessionRoutes(app, deps) {
             ...sessions,
             reportFailure: (operation, error) => deps.logger.error(`${operation} failed: ${safeErrorLabel(error)}`),
         });
-        registerGetSession(app, sessions.find, sessions.agentActivity, sessions.autopilotSnapshot);
+        registerGetSession(app, sessions.find, sessions.agentActivity, sessions.autopilotSnapshot, sessions.plan);
         if (sessions.refreshActivity)
             registerRefreshActivity(app, {
                 exists: (id) => sessions.find(id) !== null,

package/dist/server/server/features/sessions/session-status.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * A conservative, server-owned verdict. It deliberately uses only durable
+ * state and bounded activity facts: neither model prose nor opaque identity is
+ * accepted as evidence of progress.
+ */
+export function deriveSessionStatus(input) {
+    const confidence = input.activity?.confidence ?? 'stale';
+    const base = (state, reason, nextExpectedAction) => ({
+        state,
+        reason,
+        confidence,
+        observedAt: input.observedAt,
+        nextExpectedAction,
+    });
+    if (input.pendingAttention || input.autopilot?.state === 'attentionRequired')
+        return base('idle', 'needsYou', 'Respond to the pending request.');
+    const activeProcess = input.activity?.subagents.some((agent) => agent.ownedProcesses?.some((process) => process.state === 'running' || process.state === 'detached-active'));
+    const rootWorking = Boolean(input.session.activeTurnId) ||
+        (input.activity?.confidence === 'fresh' && input.activity.root.state === 'working');
+    const observedChildWorking = input.activity?.subagents.some((agent) => agent.state === 'working' || agent.state === 'awaitingAgent');
+    // A completed plan is authoritative.  Old child/process rows are historical
+    // unless their activity observation is fresh; an active root turn remains
+    // direct session evidence regardless of roster freshness.
+    const childWorking = input.activity?.confidence === 'fresh' ? observedChildWorking : false;
+    const currentProcess = input.activity?.confidence === 'fresh' ? activeProcess : false;
+    if (input.plan?.executionComplete || input.plan?.allDone) {
+        if (rootWorking)
+            return base('working', 'rootTurn', 'Wait for the active turn to settle.');
+        if (childWorking)
+            return base('working', 'agent', 'Wait for the active agent to settle.');
+        if (currentProcess)
+            return base('working', 'process', 'Wait for the owned process result.');
+        return base('idle', 'complete', 'No further plan action is required.');
+    }
+    if (rootWorking)
+        return base('working', 'rootTurn', 'Wait for the supervisor turn to settle.');
+    if (childWorking)
+        return base('working', 'agent', 'Wait for the active agent to settle.');
+    if (currentProcess)
+        return base('working', 'process', 'Wait for the owned process result.');
+    if (input.plan && input.autopilot?.health?.healthy)
+        return base('working', 'autopilot', input.autopilot.health.nextExpectedAction);
+    if (input.plan)
+        return base('idle', 'incompleteWithoutContinuation', 'Resume supervision or enable a healthy Autopilot continuation.');
+    if (input.activity?.root.state === 'disconnected')
+        return base('idle', 'disconnected', 'Restore or reopen the session.');
+    if (input.session.state === 'stopped' || input.session.state === 'released')
+        return base('idle', 'stopped', 'Open the session to continue.');
+    return base('idle', 'unknown', 'Refresh session status.');
+}