npm - gestalt-mobile - Versions diffs - 0.17.2 → 0.18.0 - Mend

gestalt-mobile 0.17.2 → 0.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/dist/client/index.html CHANGED Viewed

@@ -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-DgD-0I3M.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-e2lJ5XqL.css">
+    <script type="module" crossorigin src="/assets/index-orfZBEaD.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B0Uq4OB0.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/app.js CHANGED Viewed

@@ -15,6 +15,8 @@ import { registerSessionRoutes } from './features/sessions/register-routes.js';
 import { registerProblemHandler } from './platform/http/problem-handler.js';
 import { registerAuthorizationBoundary } from './platform/http/authorization-boundary.js';
 import { registerSkillRoutes } from './features/skills/register-routes.js';
+import { registerOrgPlanAttentionRoutes } from './features/org-plan-attention/register-routes.js';
+import { registerAutopilotRoutes } from './features/autopilot/register-routes.js';
 export async function buildApp(deps) {
     // Keep the default boundary finite even when an endpoint forgot a narrower schema.
     const app = fastify({ logger: false, bodyLimit: 1024 * 1024 });
@@ -41,6 +43,10 @@ export async function buildApp(deps) {
     if (deps.bootstrap)
         registerGetBootstrap(app, deps.bootstrap);
     registerSessionRoutes(app, deps);
+    if (deps.autopilot)
+        registerAutopilotRoutes(app, deps.autopilot, deps.sessionRoutes?.idempotency);
+    if (deps.orgPlanAttention)
+        registerOrgPlanAttentionRoutes(app, deps.orgPlanAttention);
     registerPlanRoutes(app, deps);
     registerGitRoutes(app, deps);
     registerSkillRoutes(app, deps);

package/dist/server/server/composition.js CHANGED Viewed

@@ -3,7 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { randomBytes, randomUUID } from 'node:crypto';
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -32,7 +32,9 @@ import { GitSummaryCache } from './platform/git/git-summary-cache.js';
 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 { toPendingInteraction } from './platform/codex/server-request.js';
+import { AgentActivityRegistry } from './features/agent-activity/registry.js';
+import { decodeAgentActivityFact } from './platform/codex/activity-facts.js';
+import { resolvedServerRequestId, toPendingInteraction } from './platform/codex/server-request.js';
 import { isValidInteractionResponse, isValidQuizInteractionResponse, } from './features/sessions/interaction/response-validator.js';
 import { promoteRecentThread } from './features/sessions/promote-recent-thread/use-case.js';
 import { FilesystemSkillProfileStore } from './platform/skills/filesystem-skill-profile-store.js';
@@ -45,7 +47,11 @@ import { FilesystemWorkspacePlanCatalog } from './platform/plans/filesystem-work
 import { OrgPlanCommandValidator } from './platform/plans/org-plan-command-validator.js';
 import { checkpointPlanMeasurement } from './platform/plans/plan-measurement-command.js';
 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 { AUTOPILOT_CONTINUATION_PROMPT, defaultAutopilotPolicy, } from './features/autopilot/application/policy.js';
 import { createRelyingPartyConfig } from './config.js';
+import { parseOrgPlanAttention } from '../shared/contracts/org-plan-attention.js';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
 export async function composeRelayApp(options) {
     const passkeyAuthEnabled = options.passkeyAuthEnabled ?? true;
@@ -70,14 +76,141 @@ export async function composeRelayApp(options) {
         throw error;
     }
     const sessions = new SqliteSessionRepository(database);
+    // Only sessions found while opening the relay database belong to a previous
+    // process. A listen hook can run after a new session has already started in
+    // this process; detaching that live writer would make restore and activity
+    // reconciliation race their own owner.
+    const persistedSessionIds = new Set(sessions.list().map((session) => session.id));
     const journal = new SqliteEventJournal(database);
     const interactions = new SqlitePendingInteractionStore(database);
     const idempotency = new SqliteIdempotencyStore(database);
+    const autopilotStore = new SqliteAutopilotStore(database);
+    const attentionResolutionOperations = new Map();
     const supervisedPlans = new SupervisedPlanRegistry();
     const planStatusSource = new FilesystemPlanStatusSource(join(dirname(databasePath), 'plans'));
     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();
+    const attentionTransitions = {
+        subscribe: (sessionId, listener) => events.subscribe(sessionId, (event) => {
+            if (event.type !== 'org-plan.attention-required' &&
+                event.type !== 'org-plan.attention-resolved')
+                return;
+            const payload = event.payload;
+            if (typeof payload.requestId !== 'string')
+                return;
+            listener({
+                kind: event.type === 'org-plan.attention-required'
+                    ? 'required'
+                    : payload.outcome === 'failed'
+                        ? 'failed'
+                        : 'resolved',
+                requestId: payload.requestId,
+                occurredAt: event.occurredAt,
+            });
+        }),
+    };
+    options.onAttentionTransitions?.(attentionTransitions);
+    const activity = new AgentActivityRegistry((snapshot, occurredAt) => events.publish(journal.append(snapshot.sessionId, 'agent.activity.updated', snapshot, occurredAt)), {
+        // Evidence arms one bounded reconciliation; healthy sessions are never polled.
+        schedule: options.activitySchedule ??
+            ((callback, delayMs) => {
+                const timer = setTimeout(callback, delayMs);
+                return () => clearTimeout(timer);
+            }),
+        now: () => new Date().toISOString(),
+        diagnostic: options.activityDiagnostic ??
+            ((sessionId, code) => console.warn(`agent activity ${code} session=${sessionId}`)),
+        reconcile: async (sessionId) => {
+            const session = sessions.find(sessionId);
+            if (!session || !runtime)
+                return;
+            const history = await runtime.readHistory(session);
+            const occurredAt = new Date().toISOString();
+            activity.observe({
+                sessionId,
+                occurredAt,
+                kind: history.activeTurnId ? 'turnStarted' : 'turnCompleted',
+                ...(session.threadId ? { threadId: session.threadId } : {}),
+                ...(history.activeTurnId ? { turnId: history.activeTurnId } : {}),
+            });
+            activity.childrenReconciled(sessionId, occurredAt, await runtime.listDirectChildren(session));
+        },
+    });
+    const autopilot = new AutopilotCoordinator({
+        store: autopilotStore,
+        now: () => new Date().toISOString(),
+        policy: defaultAutopilotPolicy,
+        plan: (sessionId) => {
+            const plan = supervisedPlans.find(sessionId);
+            const identity = supervisedPlans.identity(sessionId);
+            return plan && identity ? { plan, identity } : null;
+        },
+        session: (sessionId) => sessions.find(sessionId),
+        activity: (sessionId) => options.autopilotActivity
+            ? options.autopilotActivity(sessionId)
+            : activity.snapshot(sessionId, new Date().toISOString()),
+        pendingInteraction: (sessionId) => interactions.list(sessionId).length > 0,
+        reconcile: async (sessionId) => {
+            if (options.autopilotReconcile)
+                return options.autopilotReconcile(sessionId);
+            await activity.refresh(sessionId);
+            return {
+                compatible: activity.snapshot(sessionId, new Date().toISOString()).confidence === 'fresh',
+            };
+        },
+        schedule: options.autopilotSchedule ??
+            ((callback, delayMs) => {
+                const timer = setTimeout(callback, delayMs);
+                return () => clearTimeout(timer);
+            }),
+        nextControlId: (sessionId, generation) => `autopilot-${generation}-${createHash('sha256').update(`${sessionId}:${randomUUID()}`).digest('hex').slice(0, 16)}`,
+        turnStarter: {
+            start: async (sessionId, controlId, generation) => {
+                const current = () => {
+                    const state = autopilotStore.find(sessionId);
+                    return Boolean(state &&
+                        state.requestedEnabled &&
+                        state.generation === generation &&
+                        state.lastControlId === controlId);
+                };
+                if (!current())
+                    throw new Error('AUTOPILOT_START_UNAVAILABLE');
+                const session = sessions.find(sessionId);
+                if (!session || !runtime || session.activeTurnId || interactions.list(sessionId).length)
+                    throw new Error('AUTOPILOT_START_UNAVAILABLE');
+                // A relay restart can leave a durable, otherwise eligible session without this
+                // process's writer. Reacquire through the normal ownership boundary before a
+                // synthetic start; never bypass its single-writer and replacement semantics.
+                const writer = await runtime.ensureWriter(session, new Date().toISOString());
+                if (!current() || writer.session.activeTurnId || interactions.list(sessionId).length)
+                    throw new Error('AUTOPILOT_START_UNAVAILABLE');
+                await options.autopilotBeforeTurnAccepted?.({ sessionId, controlId });
+                const started = await runtime.startTurn(writer.session, AUTOPILOT_CONTINUATION_PROMPT, controlId, new Date().toISOString());
+                if (!started.activeTurnId)
+                    throw new Error('AUTOPILOT_START_UNAVAILABLE');
+                sessions.save(started);
+                await options.autopilotAfterTurnAccepted?.({
+                    sessionId,
+                    controlId,
+                    turnId: started.activeTurnId,
+                });
+                activity.observe({
+                    sessionId,
+                    occurredAt: started.updatedAt,
+                    kind: 'turnStarted',
+                    ...(started.threadId ? { threadId: started.threadId } : {}),
+                    ...(started.activeTurnId ? { turnId: started.activeTurnId } : {}),
+                });
+            },
+        },
+        publish: (sessionId, type, payload, occurredAt, outboxId) => {
+            if (!sessions.find(sessionId))
+                return;
+            events.publish(journal.append(sessionId, type, payload, occurredAt, outboxId));
+        },
+    });
+    options.onAutopilotCoordinator?.(autopilot);
     const workspaces = new FilesystemWorkspaceCatalog(root);
     const models = new CodexModelCatalog(root, options.launchAppServer ?? launchCodexAppServer);
     const skillProfiles = new FilesystemSkillProfileStore(options.homeDirectory ?? homedir());
@@ -113,9 +246,51 @@ export async function composeRelayApp(options) {
     const gitSummaries = new GitSummaryCache(inspectGit);
     let recoverExitedSession = () => { };
     let planMeasurementRefresh;
-    const runtime = options.startAppServers
+    const publishInteractionResolved = (sessionId, requestId, occurredAt, outcome) => {
+        const interaction = interactions
+            .snapshot(sessionId)
+            .find((item) => item.requestId === requestId);
+        events.publish(journal.append(sessionId, 'interaction.resolved', { requestId, turnId: interaction?.turnId ?? null, resolvedAt: occurredAt, outcome }, occurredAt));
+        if (interaction?.kind === 'orgPlanAttention')
+            events.publish(journal.append(sessionId, 'org-plan.attention-resolved', { requestId, turnId: interaction.turnId ?? null, resolvedAt: occurredAt, outcome }, occurredAt));
+    };
+    const publishAttentionSettlement = (sessionId, requestId, occurredAt, outcome) => {
+        const remaining = interactions.list(sessionId);
+        const attention = remaining.find((item) => item.kind === 'orgPlanAttention');
+        activity.observe({
+            sessionId,
+            occurredAt,
+            kind: 'interactionResolved',
+            hasPendingInteraction: remaining.length > 0,
+            ...(attention ? { attentionReason: attention.payload.reason } : {}),
+        });
+        publishInteractionResolved(sessionId, requestId, occurredAt, outcome);
+    };
+    const dismissPendingInteractions = (sessionId, occurredAt, outcome = 'dismissed') => {
+        for (const interaction of interactions.list(sessionId)) {
+            if (interactions.resolve(sessionId, interaction.requestId, occurredAt, outcome))
+                publishInteractionResolved(sessionId, interaction.requestId, occurredAt, outcome);
+        }
+    };
+    let closing = false;
+    let runtime = null;
+    runtime = options.startAppServers
         ? new CodexSessionRuntime(options.launchAppServer ?? launchCodexAppServer, undefined, (sessionId, notification) => {
             const occurredAt = new Date().toISOString();
+            const activityFact = decodeAgentActivityFact(sessionId, occurredAt, notification);
+            if (activityFact)
+                activity.observe(activityFact);
+            const resolvedRequestId = resolvedServerRequestId(notification);
+            if (resolvedRequestId) {
+                const interaction = interactions.find(sessionId, resolvedRequestId);
+                const outcome = interaction?.kind === 'orgPlanAttention' ? 'failed' : 'dismissed';
+                if (interactions.resolve(sessionId, resolvedRequestId, occurredAt, outcome)) {
+                    if (outcome === 'failed')
+                        publishAttentionSettlement(sessionId, resolvedRequestId, occurredAt, outcome);
+                    else
+                        publishInteractionResolved(sessionId, resolvedRequestId, occurredAt, outcome);
+                }
+            }
             const currentSession = sessions.find(sessionId);
             const normalized = normalizeCodexNotification(sessionId, 0, occurredAt, notification, currentSession?.workspacePath, currentSession?.activeTurnId);
             if (!normalized)
@@ -127,6 +302,7 @@ export async function composeRelayApp(options) {
                 if (session && turnId && session.activeTurnId === turnId) {
                     completedSession = RelaySession.rehydrate(session).completeTurn(turnId, occurredAt).snapshot;
                     sessions.save(completedSession);
+                    autopilot.turnCompleted(sessionId);
                 }
                 planMeasurementRefresh?.refreshNow(sessionId);
             }
@@ -144,11 +320,28 @@ export async function composeRelayApp(options) {
                 requestedAt: new Date().toISOString(),
             };
             interactions.add(sessionId, interaction);
+            activity.observe({
+                sessionId,
+                occurredAt: interaction.requestedAt,
+                kind: 'interactionPending',
+                ...(interaction.kind === 'orgPlanAttention'
+                    ? { attentionReason: interaction.payload.reason }
+                    : {}),
+            });
             const updated = RelaySession.rehydrate(session).requestInteraction(interaction, new Date().toISOString()).snapshot;
             sessions.save(updated);
             events.publish(journal.append(sessionId, 'interaction.requested', interaction, updated.updatedAt));
+            if (interaction.kind === 'orgPlanAttention')
+                events.publish(journal.append(sessionId, 'org-plan.attention-required', interaction, updated.updatedAt));
+            autopilot.evaluate(sessionId);
             return true;
-        }, (sessionId) => recoverExitedSession(sessionId), resolveSkills, planStatusSource, (sessionId, update) => {
+        }, (sessionId) => {
+            activity.disconnected(sessionId, new Date().toISOString());
+            dismissPendingInteractions(sessionId, new Date().toISOString(), 'failed');
+            recoverExitedSession(sessionId);
+        }, resolveSkills, planStatusSource, (sessionId, update) => {
+            if (closing)
+                return;
             supervisedPlans.accept(sessionId, update);
             planMeasurementRefresh?.accept(sessionId, update);
             if (update.kind === 'updated') {
@@ -166,6 +359,7 @@ export async function composeRelayApp(options) {
                 }
                 events.publish(journal.append(sessionId, 'plan.updated', { plan: update.plan, reason: update.reason }, occurredAt));
             }
+            autopilot.planUpdated(sessionId);
         }, options.planMeasurementBaseUrl, 30_000, 64, root)
         : null;
     if (runtime && planMeasurementHelperPath) {
@@ -177,8 +371,19 @@ export async function composeRelayApp(options) {
         }, (planPath, stepId, snapshot) => checkpointPlanMeasurement(planMeasurementHelperPath, planPath, stepId, snapshot));
     }
     const saveSession = (session) => {
+        const prior = sessions.find(session.id);
         sessions.save(session);
         events.publish(journal.append(session.id, 'session.updated', session, session.updatedAt));
+        const becameRuntimeReady = prior &&
+            prior.state !== 'ready' &&
+            prior.state !== 'turnActive' &&
+            (session.state === 'ready' || session.state === 'turnActive');
+        if (runtime &&
+            session.threadId &&
+            (!prior || prior.threadId !== session.threadId || becameRuntimeReady))
+            void activity.refresh(session.id);
+        if (becameRuntimeReady)
+            autopilot.restore(session.id);
     };
     if (runtime) {
         const supervisor = new SessionSupervisor(async (sessionId) => {
@@ -187,7 +392,8 @@ export async function composeRelayApp(options) {
                 return;
             const recovering = RelaySession.rehydrate(session).beginRecovery(new Date().toISOString()).snapshot;
             saveSession(recovering);
-            saveSession(await runtime.restore(recovering, new Date().toISOString()));
+            const restored = await runtime.restore(recovering, new Date().toISOString());
+            saveSession(restored);
         }, (sessionId) => {
             const session = sessions.find(sessionId);
             if (session)
@@ -198,8 +404,10 @@ export async function composeRelayApp(options) {
         recoverExitedSession = (sessionId) => {
             supervisor.cancel(sessionId);
             const session = sessions.find(sessionId);
-            if (session)
+            if (session) {
+                autopilot.cancel(sessionId, 'sessionEnded');
                 saveSession(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+            }
         };
     }
     let authorization;
@@ -291,16 +499,46 @@ export async function composeRelayApp(options) {
                 skillCatalog,
                 defaultSkillProfile: options.explicitSkillProfile,
                 activate: runtime
-                    ? async (session, settings) => runtime.start(session, new Date().toISOString(), settings)
+                    ? async (session, settings) => {
+                        const now = new Date().toISOString();
+                        dismissPendingInteractions(session.id, now);
+                        const started = await runtime.start(session, now, settings);
+                        return started;
+                    }
                     : undefined,
                 startTurn: runtime
-                    ? async (session, text, clientUserMessageId) => runtime.startTurn(session, text, clientUserMessageId, new Date().toISOString())
+                    ? async (session, text, clientUserMessageId) => {
+                        autopilot.manualSend(session.id);
+                        return runtime.startTurn(session, text, clientUserMessageId, new Date().toISOString());
+                    }
                     : undefined,
                 ensureWriter: runtime
-                    ? (session) => runtime.ensureWriter(session, new Date().toISOString())
+                    ? (session) => {
+                        dismissPendingInteractions(session.id, new Date().toISOString());
+                        return runtime.ensureWriter(session, new Date().toISOString());
+                    }
                     : undefined,
-                releaseWriter: runtime ? (id) => runtime.release(id) : undefined,
-                onTurnStarted: (session) => planMeasurementRefresh?.refreshNow(session.id),
+                releaseWriter: runtime
+                    ? (id) => {
+                        dismissPendingInteractions(id, new Date().toISOString());
+                        return runtime.release(id);
+                    }
+                    : undefined,
+                onTurnStarted: (session) => {
+                    activity.observe({
+                        sessionId: session.id,
+                        occurredAt: session.updatedAt,
+                        kind: 'turnStarted',
+                        ...(session.threadId ? { threadId: session.threadId } : {}),
+                        ...(session.activeTurnId ? { turnId: session.activeTurnId } : {}),
+                    });
+                    planMeasurementRefresh?.refreshNow(session.id);
+                },
+                agentActivity: (id) => activity.snapshot(id, new Date().toISOString()),
+                autopilotSnapshot: (id) => autopilot.snapshot(id),
+                autopilotControlTurns: (id) => autopilot.acceptedControlTurns(id),
+                autopilotAudit: (id, limit) => journal.autopilotAuditTail(id, limit),
+                refreshActivity: (id) => activity.refresh(id),
                 models,
                 readHistory: runtime ? (session) => runtime.readHistory(session) : undefined,
                 currentSequence: (sessionId) => journal.since(sessionId, 0).at(-1)?.sequence ?? 0,
@@ -308,8 +546,20 @@ export async function composeRelayApp(options) {
                     ? (session, turnId) => runtime.interruptTurn(session, turnId)
                     : undefined,
                 restore: runtime
-                    ? (session) => runtime.restoreWithOutcome(session, new Date().toISOString())
+                    ? async (session) => {
+                        const restored = await runtime.restoreWithOutcome(session, new Date().toISOString());
+                        // An exit can be reported while resume is resolving. Do not let the
+                        // route persist a stale ready snapshot over that recovered exit.
+                        if (!runtime.ownsWriter(session.id))
+                            return {
+                                ...restored,
+                                session: RelaySession.rehydrate(restored.session).stop(new Date().toISOString())
+                                    .snapshot,
+                            };
+                        return restored;
+                    }
                     : undefined,
+                ownsWriter: runtime ? (id) => runtime.ownsWriter(id) : undefined,
                 promoteRecent: runtime
                     ? (thread) => promoteRecentThread(thread, {
                         createId: randomUUID,
@@ -319,23 +569,41 @@ export async function composeRelayApp(options) {
                         read: (session) => runtime.readHistory(session),
                     })
                     : undefined,
-                release: (session) => RelaySession.rehydrate(session).release(new Date().toISOString()).snapshot,
-                remove: (id) => sessions.remove(id),
+                release: (session) => {
+                    autopilot.cancel(session.id, 'sessionEnded');
+                    return RelaySession.rehydrate(session).release(new Date().toISOString()).snapshot;
+                },
+                remove: (id) => {
+                    autopilot.cancel(id, 'sessionEnded');
+                    activity.dispose(id);
+                    sessions.remove(id);
+                },
                 idempotency,
                 close: runtime
                     ? (id) => {
+                        autopilot.cancel(id, 'sessionEnded');
                         planMeasurementRefresh?.stop(id);
+                        dismissPendingInteractions(id, new Date().toISOString());
+                        activity.dispose(id);
                         return runtime.release(id);
                     }
                     : undefined,
                 replyInteraction: runtime
-                    ? (sessionId, requestId, value) => runtime.resolveServerRequest(sessionId, requestId, value)
+                    ? (sessionId, requestId, value) => runtime.resolveServerRequest(sessionId, requestId, value) ? 'accepted' : 'cleared'
                     : undefined,
                 interactionResolved: (sessionId, requestId, occurredAt, outcome) => {
-                    const interaction = interactions
-                        .snapshot(sessionId)
-                        .find((item) => item.requestId === requestId);
-                    events.publish(journal.append(sessionId, 'interaction.resolved', { requestId, turnId: interaction?.turnId ?? null, resolvedAt: occurredAt, outcome }, occurredAt));
+                    const remaining = interactions.list(sessionId);
+                    const attention = remaining.find((item) => item.kind === 'orgPlanAttention');
+                    activity.observe({
+                        sessionId,
+                        occurredAt,
+                        kind: 'interactionResolved',
+                        hasPendingInteraction: remaining.length > 0,
+                        ...(attention
+                            ? { attentionReason: attention.payload.reason }
+                            : {}),
+                    });
+                    publishInteractionResolved(sessionId, requestId, occurredAt, outcome);
                 },
             },
             sessionEvents: {
@@ -355,12 +623,14 @@ export async function composeRelayApp(options) {
                 removeStatus: (id) => planStatusSource.remove(id, supervisedPlans.identity(id) ?? undefined),
                 clear: (id) => supervisedPlans.clear(id),
                 closed: (id) => {
+                    autopilot.cancel(id, 'planRemoved');
                     planMeasurementRefresh?.stop(id);
                     const occurredAt = new Date().toISOString();
                     events.publish(journal.append(id, 'plan.closed', {}, occurredAt));
                 },
             },
             workspacePlanRoutes: { workspaces, plans: workspacePlanCatalog },
+            autopilot,
             ...(runtime
                 ? {
                     planMeasurementRoutes: {
@@ -386,9 +656,108 @@ export async function composeRelayApp(options) {
                         return false;
                     if (interaction.kind === 'quiz')
                         return isValidQuizInteractionResponse(interaction.payload, value);
+                    // Attention must use its operation-keyed boundary; generic interaction
+                    // responses deliberately cannot bypass durable operation identity.
+                    if (interaction.kind === 'orgPlanAttention')
+                        return false;
                     return isValidInteractionResponse(interaction.kind, value);
                 },
             },
+            orgPlanAttention: {
+                exists: (id) => sessions.find(id) !== null,
+                reader: {
+                    active: (sessionId) => {
+                        const interaction = interactions
+                            .list(sessionId)
+                            .find((item) => item.kind === 'orgPlanAttention');
+                        const attention = interaction ? parseOrgPlanAttention(interaction.payload) : null;
+                        return interaction && attention
+                            ? {
+                                requestId: interaction.requestId,
+                                turnId: interaction.turnId ?? null,
+                                requestedAt: interaction.requestedAt ?? null,
+                                attention,
+                            }
+                            : null;
+                    },
+                },
+                resolver: {
+                    resolve: async ({ sessionId, requestId, operationKey, response }) => {
+                        const scope = `org-plan-attention:${sessionId}:${requestId}`;
+                        const stored = idempotency.get(scope, operationKey);
+                        if (stored)
+                            return JSON.parse(stored.body);
+                        const terminal = interactions.terminalOperation(sessionId, requestId);
+                        if (terminal)
+                            return terminal.operationKey === operationKey
+                                ? terminal.outcome === 'failed'
+                                    ? { kind: 'writerCleared', resolvedAt: terminal.resolvedAt }
+                                    : { kind: 'replayed', resolvedAt: terminal.resolvedAt }
+                                : { kind: 'staleOperation' };
+                        const key = `${scope}:${operationKey}`;
+                        const inFlight = attentionResolutionOperations.get(key);
+                        if (inFlight)
+                            return inFlight;
+                        const operation = (async () => {
+                            const interaction = interactions.find(sessionId, requestId);
+                            if (!interaction || interaction.kind !== 'orgPlanAttention')
+                                return { kind: 'noActive' };
+                            const claim = interactions.claimOperation(sessionId, requestId, operationKey);
+                            if (claim === 'resolved') {
+                                const resolved = interactions.resolved(sessionId, requestId);
+                                return resolved
+                                    ? { kind: 'replayed', resolvedAt: resolved.resolvedAt }
+                                    : { kind: 'staleOperation' };
+                            }
+                            if (claim === 'stale')
+                                return { kind: 'staleOperation' };
+                            if (claim === 'missing')
+                                return { kind: 'noActive' };
+                            // A durable capability belongs to the session/thread, not the
+                            // relay process.  A supported stopped writer is retryable;
+                            // missing capability identifies a pre-rollout legacy thread.
+                            if (sessions.find(sessionId)?.attentionToolCapability !== 'supported')
+                                return { kind: 'legacyUnsupported' };
+                            if (!runtime)
+                                return { kind: 'writerUnavailable' };
+                            if (!interactions.beginDelivery(sessionId, requestId, operationKey))
+                                return { kind: 'staleOperation' };
+                            const writer = runtime.attentionWriterState(sessionId, requestId);
+                            if (writer === 'unavailable') {
+                                interactions.retryDelivery(sessionId, requestId, operationKey);
+                                return { kind: 'writerUnavailable' };
+                            }
+                            const resolvedAt = new Date().toISOString();
+                            if (writer === 'cleared') {
+                                if (!interactions.settleOperation(sessionId, requestId, operationKey, resolvedAt, 'failed'))
+                                    return { kind: 'staleOperation' };
+                                publishAttentionSettlement(sessionId, requestId, resolvedAt, 'failed');
+                                return { kind: 'writerCleared', resolvedAt };
+                            }
+                            if (!runtime.resolveServerRequest(sessionId, requestId, response)) {
+                                // The state check and delivery are synchronous, but retain a
+                                // defensive retry path for a future runtime implementation.
+                                interactions.retryDelivery(sessionId, requestId, operationKey);
+                                return { kind: 'writerUnavailable' };
+                            }
+                            if (!interactions.settleOperation(sessionId, requestId, operationKey, resolvedAt, 'answered'))
+                                return { kind: 'staleOperation' };
+                            const accepted = { kind: 'accepted', resolvedAt };
+                            idempotency.put(scope, operationKey, 202, JSON.stringify({ kind: 'replayed', resolvedAt }));
+                            publishAttentionSettlement(sessionId, requestId, resolvedAt, 'answered');
+                            return accepted;
+                        })();
+                        attentionResolutionOperations.set(key, operation);
+                        try {
+                            return await operation;
+                        }
+                        finally {
+                            attentionResolutionOperations.delete(key);
+                        }
+                    },
+                },
+                transitions: attentionTransitions,
+            },
             gitSummary: {
                 workspaces,
                 inspect: async (path) => {
@@ -424,10 +793,18 @@ export async function composeRelayApp(options) {
         throw error;
     }
     const detachActiveSessions = async () => {
-        await mapWithConcurrency(sessions.list().filter((session) => session.threadId !== null), 2, async (session) => {
-            if (session.desiredState === 'active')
+        await mapWithConcurrency(sessions
+            .list()
+            .filter((session) => persistedSessionIds.has(session.id) && session.threadId !== null), 2, async (session) => {
+            // The status lease must repopulate the authoritative plan projection before
+            // a durable coordinator is restored. Writer detachment is a process concern,
+            // not a human disable: a later fenced continuation can reacquire it safely.
+            if (session.desiredState === 'active') {
                 saveSession(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+                await runtime?.release(session.id);
+            }
             await runtime?.watchPlanStatus(session);
+            autopilot.restore(session.id);
         });
     };
     app.addHook('onListen', async () => {
@@ -437,7 +814,22 @@ export async function composeRelayApp(options) {
         await detachActiveSessions();
     });
     app.addHook('onClose', async () => {
+        closing = true;
         planMeasurementRefresh?.stopAll();
+        for (const session of sessions.list()) {
+            autopilot.dispose(session.id);
+            activity.dispose(session.id);
+            // Relay shutdown only releases this process's writer.  A typed attention
+            // request remains a durable human-visible blocker for the next relay
+            // instance; only an app-server-cleared request is a failed audit outcome.
+            for (const interaction of interactions.list(session.id)) {
+                if (interaction.kind === 'orgPlanAttention')
+                    continue;
+                const occurredAt = new Date().toISOString();
+                if (interactions.resolve(session.id, interaction.requestId, occurredAt, 'dismissed'))
+                    publishInteractionResolved(session.id, interaction.requestId, occurredAt, 'dismissed');
+            }
+        }
         runtime?.stopAll();
         planStatusSource.closeAll();
         database.close();