gestalt-mobile 0.29.0 → 0.30.1

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-CRULnRRB.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BtlbAtm9.css">
+    <script type="module" crossorigin src="/assets/index-CedbthUQ.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CKhqx71S.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/cli.js

@@ -12,7 +12,7 @@ import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import { composeRelayApp } from './composition.js';
 import { CliUsageError, parseConfig } from './config.js';
-import { CodexProfileCatalog } from './platform/catalog/codex-profile-catalog.js';
+import { LauncherProfileCatalog } from './platform/catalog/launcher-profile-catalog.js';
 import { FilesystemSkillProfileStore } from './platform/skills/filesystem-skill-profile-store.js';
 const runFile = promisify(execFile);
 export const usage = `Usage: gestalt-mobile [options]
@@ -28,6 +28,26 @@ Options:
   --skills list      List saved global skill profiles without starting the server
   --help             Show this help
   --version          Show the installed version`;
+export async function runStartupDoctor(cwd) {
+    if (process.env.GESTALT_STARTUP_DIAGNOSTICS_DONE === '1')
+        return { ok: true, report: '' };
+    try {
+        const result = await runFile('gestalt', ['doctor'], {
+            cwd,
+            env: process.env,
+            timeout: 60_000,
+            maxBuffer: 1024 * 1024,
+        });
+        return { ok: true, report: `${result.stdout}${result.stderr}` };
+    }
+    catch (error) {
+        const failure = error;
+        return {
+            ok: false,
+            report: `${failure.stdout ?? ''}${failure.stderr ?? ''}${failure.message ? `${failure.message}\n` : ''}`,
+        };
+    }
+}
 export function packageRoot(moduleUrl) {
     let directory = dirname(fileURLToPath(moduleUrl));
     while (true) {
@@ -155,13 +175,18 @@ export async function runCli(dependencies = {}) {
         stderr.write(`Unknown skill profile: ${config.skillsProfile}\n\n${usage}\n`);
         return 2;
     }
+    const diagnosis = await (dependencies.runStartupDoctor ?? runStartupDoctor)(cwd);
+    if (diagnosis.report)
+        stderr.write(diagnosis.report);
+    if (!diagnosis.ok)
+        stderr.write('WARNING: Startup diagnostics reported a problem; Gestalt Mobile will continue so it can show recovery controls.\n');
     const app = await (dependencies.compose ?? composeRelayApp)({
         root: config.root,
         dataDir: config.dataDir,
         relyingParty: config.relyingParty,
         passkeyAuthEnabled: config.passkeyAuthEnabled,
         staticDir: packagedClientDir(moduleUrl),
-        profiles: new CodexProfileCatalog(),
+        profiles: new LauncherProfileCatalog(),
         installedCodexVersion: await (dependencies.probeCodexVersion ?? probeCodexVersion)(),
         startAppServers: true,
         homeDirectory: dependencies.homeDirectory,

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

@@ -210,7 +210,7 @@ async function composeAuthorizedApp(options) {
     if (!store.sessionDevice(authorizationSessionId('test-session'), '2026-08-02T00:00:00.000Z'))
         store.saveSession(authorizationSessionId('test-session'), {
             deviceId: device.id,
-            expiresAt: '2026-09-01T00:00:00.000Z',
+            expiresAt: '2099-09-01T00:00:00.000Z',
         });
     store.close();
     const app = await composeRelayApp({ ...options, homeDirectory });

package/dist/server/server/composition.js

@@ -35,7 +35,7 @@ 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 { decodeAgentActivityFacts } from './platform/codex/activity-facts.js';
-import { resolvedServerRequestId, toPendingInteraction } from './platform/codex/server-request.js';
+import { isAutopilotWaitLeaseCall, resolvedServerRequestId, toPendingInteraction, } from './platform/codex/server-request.js';
 import { parseOrgPlanCheckpoint, toOrgPlanCheckpointToolResponse, } from '../shared/contracts/org-plan-checkpoint.js';
 import { validOrgPlanCheckpoint } from './features/org-plan-checkpoint/application/validate.js';
 import { isValidInteractionResponse, isValidQuizInteractionResponse, } from './features/sessions/interaction/response-validator.js';
@@ -51,9 +51,10 @@ 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 { AUTOPILOT_CONTINUATION_PROMPT, AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT, defaultAutopilotPolicy, } from './features/autopilot/application/policy.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';
+import { autopilotWaitLeaseToolResponse, } from '../shared/contracts/autopilot-wait-lease.js';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
 export async function composeRelayApp(options) {
     const passkeyAuthEnabled = options.passkeyAuthEnabled ?? true;
@@ -219,7 +220,7 @@ export async function composeRelayApp(options) {
                     throw new Error('AUTOPILOT_START_UNAVAILABLE');
                 await options.autopilotBeforeTurnAccepted?.({ sessionId, controlId });
                 const continuationPrompt = launchIdentity
-                    ? `${AUTOPILOT_CONTINUATION_PROMPT} Launch task_name ${launchIdentity.taskName} for canonical ${launchIdentity.canonicalPosition}; retain the canonical label in status and review output.`
+                    ? autopilotExecutorLaunchPrompt(launchIdentity)
                     : AUTOPILOT_CONTINUATION_PROMPT;
                 const started = await runtime.startTurn(writer.session, continuationPrompt, controlId, new Date().toISOString());
                 if (!started.activeTurnId)
@@ -335,6 +336,7 @@ export async function composeRelayApp(options) {
         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));
+        autopilot.semanticEvent(sessionId, 'interactionChanged');
     };
     const publishAttentionSettlement = (sessionId, requestId, occurredAt, outcome) => {
         const remaining = interactions.list(sessionId);
@@ -428,8 +430,33 @@ export async function composeRelayApp(options) {
         }, (sessionId, request, origin) => {
             const rawInteraction = toPendingInteraction(request);
             const session = withPendingInteractions(sessions.find(sessionId));
-            if (!rawInteraction || !session)
+            if (!session)
+                return false;
+            if (!rawInteraction && isAutopilotWaitLeaseCall(request)) {
+                const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
+                if (rootOwned)
+                    autopilot.rejectProbe(sessionId);
+                return (runtime?.resolveServerRequest(sessionId, String(request.id), autopilotWaitLeaseToolResponse()) === true);
+            }
+            if (!rawInteraction)
                 return false;
+            if (rawInteraction.kind === 'autopilotWaitLease') {
+                const lease = rawInteraction.payload;
+                const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
+                const accepted = rootOwned &&
+                    autopilot.reportProbe(sessionId, {
+                        id: lease.reportId,
+                        kind: 'wait',
+                        leaseId: lease.leaseId,
+                        wakeConditions: lease.wakeConditions,
+                    });
+                if (!accepted) {
+                    if (rootOwned)
+                        autopilot.rejectProbe(sessionId);
+                    return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, autopilotWaitLeaseToolResponse()) === true);
+                }
+                return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, autopilotWaitLeaseToolResponse()) === true);
+            }
             if (rawInteraction.kind === 'orgPlanCheckpoint') {
                 const checkpoint = parseOrgPlanCheckpoint(rawInteraction.payload);
                 const retained = supervisedPlans.find(sessionId);
@@ -468,6 +495,7 @@ export async function composeRelayApp(options) {
                     ? { attentionReason: interaction.payload.reason }
                     : {}),
             });
+            autopilot.semanticEvent(sessionId, 'interactionChanged');
             const updated = RelaySession.rehydrate(session).requestInteraction(interaction, new Date().toISOString()).snapshot;
             sessions.save(updated);
             events.publish(journal.append(sessionId, 'interaction.requested', interaction, updated.updatedAt));

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

@@ -3,9 +3,16 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-export const AUTOPILOT_PROMPT_VERSION = 'v3';
-export const AUTOPILOT_CONTINUATION_PROMPT = 'Inspect the active supervised Org Plan. Refer to every L1 as L<a> and each nested L2 as L<a>.<b>, using one-based positions. For a subagent dedicated to that position, use the collaboration-safe task_name l<a> or l<a>_<b> and refer to it by its canonical L label. Invoke gestalt_org_plan_attention only for a decision-table blocker; otherwise immediately perform the next legal lifecycle action. Do not send a status-only response.';
+export const AUTOPILOT_PROMPT_VERSION = 'v6';
+export const AUTOPILOT_CONTINUATION_PROMPT = 'Inspect the active supervised Org Plan. Refer to every L1 as L<a> and each nested L2 as L<a>.<b>, using one-based positions. For a subagent dedicated to that position, use the collaboration-safe task_name l<a> or l<a>_<b> and refer to it by its canonical L label. If the active L1 is still WIP and its executor stopped or is idle after a partial report or L2 checkpoint, call followup_task on that same executor before sending any response. Treat a status question as an interruption: answer briefly, then perform that continuation in the same turn. Invoke gestalt_org_plan_attention only for a decision-table blocker. When the Autopilot probe is active, register gestalt_autopilot_wait_lease with an observable wake condition, declare genuine attention, or immediately do actionable work; never acknowledge waiting in prose. Do not send a status-only response.';
 export const AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT = 'Continue the same assigned Org L1 from its durable state. A prior turn ending did not complete the objective. Consume any supplied process result, take the next legal L2 action, and report only at the L1 review boundary or through structured attention.';
+/** Builds a physical launch instruction while keeping durable L1 identity canonical. */
+export function autopilotExecutorLaunchPrompt(identity) {
+    const launch = `Launch task_name ${identity.taskName} for canonical ${identity.canonicalPosition}; retain the canonical label in status and review output.`;
+    if (identity.generation === 1)
+        return `${AUTOPILOT_CONTINUATION_PROMPT} ${launch}`;
+    return `${AUTOPILOT_CONTINUATION_PROMPT} ${launch} This is replacement generation ${identity.generation}: the durable ${identity.canonicalTaskName} slot may remain reserved. Do not reuse that task_name or attempt to change an existing agent's model in place. Interrupt the previous physical executor if it is still running, then spawn ${identity.taskName} with agent_type worker and an explicit model selected by the supervisor. Transfer sole ${identity.canonicalPosition} ownership and continue from its durable Org Plan and worktree state.`;
+}
 export const defaultAutopilotPolicy = Object.freeze({
     quiescenceMs: 1_000,
     staleAfterMs: 30_000,
@@ -74,6 +81,14 @@ export function decideAutopilot(input) {
     // validated Org attention record may turn an incomplete plan into a human stop.
     if (hasPendingInteraction)
         return { kind: 'observe' };
+    const semanticProgressObserved = Boolean(input.semanticProgressKey &&
+        state.supervision &&
+        input.semanticProgressKey !== state.supervision.progressKey);
+    const semanticLoopConfirmed = (state.supervision?.unchangedContinuations ?? 3) >= 3;
+    if ((input.automaticActionCount ?? 0) > policy.actionLimit &&
+        !semanticProgressObserved &&
+        semanticLoopConfirmed)
+        return { kind: 'safetyPause', reason: 'actionRateExceeded' };
     if (!activity || activity.confidence !== 'fresh')
         return { kind: 'reconcile' };
     if (Date.parse(now) - Date.parse(activity.root.lastActivityAt) > policy.staleAfterMs)

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

@@ -7,12 +7,15 @@ import { createHash } from 'node:crypto';
 import { autopilotSnapshot, disabledAutopilot, } from '../domain/autopilot-session.js';
 import { classifyExecutorOutcome, decideSupervisedLifecycle, executorIdentity, validStructuredBlock, } from '../domain/supervised-lifecycle.js';
 import { classifyAgentActivity, decideAutopilot, executionComplete, } from './policy.js';
+import { consumeObservableWake, recordAutomaticContinuation, recoverSafetyPause, reportProbe, semanticProgressKey, startSupervisionProtocol, } from '../domain/supervision-protocol.js';
 export class AutopilotCoordinator {
     deps;
     timers = new Map();
     completionTimers = new Map();
     executorTimers = new Map();
     publishedSnapshots = new Map();
+    planEventKeys = new Map();
+    activityEventKeys = new Map();
     /** Serializes asynchronous watchdog and timer work per relay session. */
     operations = new Map();
     constructor(deps) {
@@ -36,7 +39,7 @@ export class AutopilotCoordinator {
             !session ||
             !session.threadId ||
             !state.requestedEnabled ||
-            ['disabled', 'attentionRequired', 'completed'].includes(state.state))
+            ['disabled', 'attentionRequired', 'completed', 'safetyPaused'].includes(state.state))
             return;
         // A relay restart deliberately drops its writer before rehydrating the
         // coordinator. The plan-status watcher is authoritative and asynchronous,
@@ -78,6 +81,88 @@ export class AutopilotCoordinator {
     }
     dispose(sessionId) {
         this.cancelTimer(sessionId);
+        this.planEventKeys.delete(sessionId);
+        this.activityEventKeys.delete(sessionId);
+    }
+    /** Accepts a session-owned structured probe response; no transcript text is inspected. */
+    reportProbe(sessionId, report) {
+        const state = this.deps.store.find(sessionId);
+        if (!state?.requestedEnabled)
+            return false;
+        const nextProtocol = reportProbe(state.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), report);
+        if (nextProtocol === state.supervision)
+            return false;
+        const now = this.deps.now();
+        this.persist({
+            ...state,
+            supervision: nextProtocol,
+            ...(nextProtocol.outcome === 'attentionRequired'
+                ? {
+                    state: 'attentionRequired',
+                    requestedEnabled: false,
+                    stopReason: 'attentionRequired',
+                }
+                : {}),
+            updatedAt: now,
+        });
+        if (nextProtocol.outcome === 'parked' || nextProtocol.outcome === 'attentionRequired')
+            this.cancelTimer(sessionId);
+        return true;
+    }
+    /** Fails closed only for the currently active bounded probe. */
+    rejectProbe(sessionId) {
+        const state = this.deps.store.find(sessionId);
+        if (!state?.requestedEnabled || state.supervision?.outcome !== 'probeRequired')
+            return false;
+        const now = this.deps.now();
+        const cancelled = this.cancelScheduledControl(state, now);
+        this.cancelTimer(sessionId);
+        this.persist({
+            ...state,
+            state: 'safetyPaused',
+            requestedEnabled: false,
+            generation: state.generation + 1,
+            nextEvaluationAt: null,
+            ...(cancelled ? { lastControlId: null } : {}),
+            stopReason: 'safetyPaused',
+            supervision: {
+                ...state.supervision,
+                outcome: 'safetyPaused',
+                safetyPauseReason: 'invalidProbeReport',
+            },
+            updatedAt: now,
+        }, cancelled, [
+            {
+                sessionId,
+                type: 'autopilot.safety-paused',
+                payload: { reason: 'invalidProbeReport' },
+                occurredAt: now,
+            },
+        ]);
+        return true;
+    }
+    /** A durable matching wake grants the one retry and schedules no work by itself. */
+    observableWake(sessionId, wake) {
+        const state = this.deps.store.find(sessionId);
+        if (!state?.requestedEnabled || !state.supervision)
+            return false;
+        const nextProtocol = consumeObservableWake(state.supervision, wake);
+        if (nextProtocol === state.supervision)
+            return false;
+        this.persist({ ...state, supervision: nextProtocol, updatedAt: this.deps.now() });
+        this.evaluate(sessionId);
+        return true;
+    }
+    /** Wakes a parked lease only when this semantic event was explicitly requested. */
+    semanticEvent(sessionId, condition) {
+        const lease = this.deps.store.find(sessionId)?.supervision?.waitLease;
+        if (!lease || !lease.wakeConditions.includes(condition))
+            return false;
+        return this.observableWake(sessionId, {
+            leaseId: lease.id,
+            condition,
+            progressKey: this.progressKey(sessionId),
+        });
     }
     enable(sessionId) {
         const session = this.deps.session(sessionId);
@@ -107,6 +192,7 @@ export class AutopilotCoordinator {
             stopReason: null,
             executor: undefined,
             blocking: undefined,
+            supervision: recoverSafetyPause(prior.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId)),
             updatedAt: now,
         };
         this.persist(next);
@@ -137,6 +223,7 @@ export class AutopilotCoordinator {
             ...(cancelled ? { lastControlId: null } : {}),
             stopReason: 'manualDisabled',
             blocking: undefined,
+            supervision: recoverSafetyPause(prior.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId)),
             updatedAt: now,
         };
         this.persist(next, cancelled);
@@ -260,6 +347,17 @@ export class AutopilotCoordinator {
                     updatedAt: now,
                 };
                 break;
+            case 'safetyPause':
+                next = {
+                    ...prior,
+                    state: 'safetyPaused',
+                    requestedEnabled: false,
+                    generation: prior.generation + 1,
+                    nextEvaluationAt: null,
+                    stopReason: 'safetyPaused',
+                    updatedAt: now,
+                };
+                break;
             case 'disable':
                 next = {
                     ...prior,
@@ -275,12 +373,14 @@ export class AutopilotCoordinator {
         }
         if (decision.kind === 'requestAttention' ||
             decision.kind === 'complete' ||
-            decision.kind === 'disable')
+            decision.kind === 'disable' ||
+            decision.kind === 'safetyPause')
             this.cancelTimer(sessionId);
         if (next !== prior) {
             const cancelled = decision.kind === 'requestAttention' ||
                 decision.kind === 'complete' ||
-                decision.kind === 'disable'
+                decision.kind === 'disable' ||
+                decision.kind === 'safetyPause'
                 ? this.cancelScheduledControl(prior, now)
                 : undefined;
             this.persist(cancelled ? { ...next, lastControlId: null } : next, cancelled);
@@ -375,6 +475,7 @@ export class AutopilotCoordinator {
                 occurredAt,
             },
         ]);
+        this.semanticEvent(sessionId, 'checkpointChanged');
         return true;
     }
     /** Handles only plan lifecycle safety; ordinary plan mutations are ignored. */
@@ -391,8 +492,16 @@ export class AutopilotCoordinator {
             this.cancel(sessionId, 'planReplaced');
             return;
         }
-        if (executionComplete(plan.plan))
+        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);
+        }
     }
     /**
      * Records a validated, session-private supervision request.  It intentionally
@@ -447,6 +556,25 @@ export class AutopilotCoordinator {
         const activity = this.deps.activity(sessionId);
         if (!activity || activity.confidence !== 'fresh')
             return;
+        const eventKey = JSON.stringify({
+            root: [activity.root.state, activity.root.reason],
+            children: activity.subagents.map((child) => [
+                child.id,
+                child.state,
+                child.reason,
+                child.continuationGeneration ?? 0,
+                (child.ownedProcesses ?? []).map((process) => [
+                    process.processId,
+                    process.state,
+                    process.ownership,
+                ]),
+            ]),
+        });
+        if (this.activityEventKeys.get(sessionId) === eventKey)
+            return;
+        this.activityEventKeys.set(sessionId, eventKey);
+        if (this.semanticEvent(sessionId, 'agentActivityChanged'))
+            return;
         const disposition = classifyAgentActivity(activity);
         if (disposition === 'attention') {
             this.evaluate(sessionId);
@@ -589,6 +717,39 @@ export class AutopilotCoordinator {
             await this.enforceSupervisedLifecycle(sessionId, 'stateChanged');
             return;
         }
+        const protocol = recordAutomaticContinuation(current.supervision ?? startSupervisionProtocol(this.progressKey(sessionId)), this.progressKey(sessionId));
+        if (protocol.outcome === 'probeRequired') {
+            this.persist({ ...current, supervision: protocol, updatedAt: this.deps.now() }, undefined, [
+                {
+                    sessionId,
+                    type: 'autopilot.probe-required',
+                    payload: { progressKey: protocol.progressKey },
+                    occurredAt: this.deps.now(),
+                },
+            ]);
+        }
+        if (protocol.outcome === 'safetyPaused') {
+            const now = this.deps.now();
+            const cancelled = this.cancelScheduledControl(current, now);
+            this.persist({
+                ...current,
+                state: 'safetyPaused',
+                requestedEnabled: false,
+                stopReason: 'safetyPaused',
+                ...(cancelled ? { generation: current.generation + 1, lastControlId: null } : {}),
+                nextEvaluationAt: null,
+                supervision: protocol,
+                updatedAt: now,
+            }, cancelled, [
+                {
+                    sessionId,
+                    type: 'autopilot.safety-paused',
+                    payload: { progressKey: protocol.progressKey },
+                    occurredAt: now,
+                },
+            ]);
+            return;
+        }
         const id = current.lastControlId;
         if (!id)
             return;
@@ -646,8 +807,9 @@ export class AutopilotCoordinator {
             this.deps.pendingInteraction(sessionId))
             return false;
         const executor = this.currentExecutor(sessionId, retained.plan, state.consecutiveNoProgress, state.executor);
-        if (executor)
-            this.persistExecutor(sessionId, executor);
+        const executorChanged = executor ? this.persistExecutor(sessionId, executor) : false;
+        if (executorChanged && this.wakeForExecutorChange(sessionId, executor))
+            return true;
         const decision = decideSupervisedLifecycle({
             plan: retained.plan,
             event,
@@ -672,7 +834,11 @@ export class AutopilotCoordinator {
                 return true;
             case 'monitorProcess': {
                 const processId = decision.action.process.processId;
-                controller.transferProcess(sessionId, decision.action.process.ownerThreadId, processId);
+                const alreadyMonitoring = executor?.ownedProcesses.some((process) => process.processId === processId &&
+                    process.ownership === 'supervisor' &&
+                    process.state === 'detached-active');
+                if (!alreadyMonitoring)
+                    controller.transferProcess(sessionId, decision.action.process.ownerThreadId, processId);
                 if (executor)
                     this.persistExecutor(sessionId, {
                         ...executor,
@@ -680,10 +846,11 @@ export class AutopilotCoordinator {
                             ? { ...process, ownership: 'supervisor', state: 'detached-active' }
                             : process),
                     });
-                this.audit(sessionId, 'autopilot.process-monitoring', {
-                    threadId: decision.action.process.ownerThreadId,
-                    processId,
-                });
+                if (!alreadyMonitoring)
+                    this.audit(sessionId, 'autopilot.process-monitoring', {
+                        threadId: decision.action.process.ownerThreadId,
+                        processId,
+                    });
                 this.armExecutorRefresh(sessionId, decision.action.pollAfterMs);
                 return true;
             }
@@ -785,8 +952,22 @@ export class AutopilotCoordinator {
     persistExecutor(sessionId, executor) {
         const current = this.deps.store.find(sessionId);
         if (!current || JSON.stringify(current.executor) === JSON.stringify(executor))
-            return;
+            return false;
         this.persist({ ...current, executor, updatedAt: this.deps.now() });
+        return true;
+    }
+    wakeForExecutorChange(sessionId, executor) {
+        const processes = executor.ownedProcesses;
+        const conditions = [
+            ...(processes.some((process) => process.state === 'exited-awaiting-result')
+                ? ['processExited', 'processResultAvailable']
+                : []),
+            ...(processes.some((process) => process.state === 'terminated-for-budget')
+                ? ['processLimitBreached']
+                : []),
+            'executorChanged',
+        ];
+        return conditions.some((condition) => this.semanticEvent(sessionId, condition));
     }
     freshExecutorIdentity(sessionId) {
         const plan = this.deps.plan(sessionId)?.plan;
@@ -961,8 +1142,11 @@ export class AutopilotCoordinator {
         return 'unknown';
     }
     decision(sessionId, state) {
+        if (state.supervision?.outcome === 'parked')
+            return { kind: 'observe' };
         const plan = this.deps.plan(sessionId);
         const now = this.deps.now();
+        const currentProgressKey = this.progressKey(sessionId);
         return decideAutopilot({
             state,
             plan: plan?.plan ?? null,
@@ -971,10 +1155,53 @@ export class AutopilotCoordinator {
             hasActiveAttention: validStructuredBlock(this.deps.attention?.(sessionId) ?? state.blocking),
             lastTurnOutcome: this.lastTurnOutcome(sessionId, state.lastControlId),
             automaticActionCount: this.deps.store.automaticActionsSince?.(sessionId, new Date(Date.parse(now) - this.deps.policy.actionWindowMs).toISOString()) ?? 0,
+            semanticProgressKey: currentProgressKey,
             now,
             policy: this.deps.policy,
         });
     }
+    progressKey(sessionId) {
+        const retained = this.deps.plan(sessionId);
+        const activity = this.deps.activity(sessionId);
+        const interactions = this.deps.pendingInteraction(sessionId)
+            ? [{ id: 'pending', kind: 'session', state: 'pending' }]
+            : [];
+        return semanticProgressKey({
+            plan: {
+                identity: retained?.identity ?? 'none',
+                fingerprint: retained ? fingerprint(retained.plan) : 'none',
+                currentPosition: retained?.plan.currentStepId ?? null,
+            },
+            review: { status: null },
+            checkpoint: {
+                pendingTurnId: this.deps.store.find(sessionId)?.checkpoints?.pendingTurnId ?? null,
+                terminalReviewAccepted: this.deps.store.find(sessionId)?.checkpoints?.terminalReviewAccepted ?? false,
+            },
+            pendingInteractions: interactions,
+            executor: {
+                generation: this.deps.store.find(sessionId)?.executor?.continuationGeneration ?? 0,
+                state: this.deps.store.find(sessionId)?.executor?.outcome ?? null,
+            },
+            ownedProcesses: (this.deps.store.find(sessionId)?.executor?.ownedProcesses ?? []).map((process) => ({
+                id: process.processId,
+                state: process.state,
+                ownerGeneration: this.deps.store.find(sessionId)?.executor?.continuationGeneration ?? 0,
+            })),
+            agentActivity: [
+                ...(activity
+                    ? [
+                        {
+                            agentId: 'root',
+                            // Activity time is liveness-only; semantic progress uses the
+                            // sequenced state projection, never the observation clock.
+                            sequence: 0,
+                            state: activity.root.state,
+                        },
+                    ]
+                    : []),
+            ],
+        });
+    }
     async reconcile(sessionId, generation) {
         try {
             const result = await this.deps.reconcile(sessionId);

package/dist/server/server/features/autopilot/domain/supervised-lifecycle.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { orgPlanAgentDisplayName } from '../../../../shared/org-plan-position.js';
+import { parseSupervisionProtocolState, } from './supervision-protocol.js';
 export const blockingResumeConditions = {
     planChange: 'planRevision',
     hardBlock: 'externalStateChanged',
@@ -25,11 +26,19 @@ export function parsePersistedSupervisedLifecycle(value) {
         return undefined;
     const executorValue = record(root.executor);
     const checkpointsValue = record(root.checkpoints);
+    const supervisionValue = root.supervision;
+    const supervision = supervisionValue === undefined ? undefined : parseSupervisionProtocolState(supervisionValue);
+    if (supervisionValue !== undefined && !supervision)
+        return undefined;
     const checkpoints = checkpointsValue ? parseCheckpoints(checkpointsValue) : undefined;
     if (checkpointsValue && !checkpoints)
         return undefined;
     if (!executorValue)
-        return { ...(blocking ? { blocking } : {}), ...(checkpoints ? { checkpoints } : {}) };
+        return {
+            ...(blocking ? { blocking } : {}),
+            ...(supervision ? { supervision } : {}),
+            ...(checkpoints ? { checkpoints } : {}),
+        };
     const processesValue = executorValue.ownedProcesses;
     if (!Array.isArray(processesValue) || processesValue.length > 64)
         return undefined;
@@ -135,6 +144,7 @@ export function parsePersistedSupervisedLifecycle(value) {
             continuationCount,
         },
         ...(blocking ? { blocking } : {}),
+        ...(supervision ? { supervision } : {}),
         ...(checkpoints ? { checkpoints } : {}),
     };
 }