gestalt-mobile 0.29.0 → 0.30.1

package/dist/server/server/features/autopilot/domain/supervision-protocol.js

@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Facts which may wake a parked supervisor without inspecting conversation text. */
+export const observableWakeConditions = [
+    'planChanged',
+    'reviewChanged',
+    'checkpointChanged',
+    'interactionChanged',
+    'executorChanged',
+    'processExited',
+    'processResultAvailable',
+    'processLimitBreached',
+    'agentActivityChanged',
+];
+/**
+ * A canonical, durable representation rather than a clock- or transcript-derived score.
+ * The string is intentionally opaque to callers; compare it only for equality.
+ */
+export function semanticProgressKey(facts) {
+    return JSON.stringify({
+        plan: facts.plan,
+        review: facts.review,
+        checkpoint: facts.checkpoint,
+        pendingInteractions: [...facts.pendingInteractions]
+            .map(({ id, kind, state }) => ({ id, kind, state }))
+            .sort(compareBy('id')),
+        executor: facts.executor,
+        ownedProcesses: [...facts.ownedProcesses]
+            .map(({ id, state, ownerGeneration }) => ({ id, state, ownerGeneration }))
+            .sort(compareBy('id')),
+        agentActivity: latestAgentActivity(facts.agentActivity),
+    });
+}
+function latestAgentActivity(observations) {
+    const latest = new Map();
+    for (const observation of observations) {
+        const current = latest.get(observation.agentId);
+        if (!current ||
+            observation.sequence > current.sequence ||
+            (observation.sequence === current.sequence &&
+                observation.state.localeCompare(current.state) < 0))
+            latest.set(observation.agentId, observation);
+    }
+    return [...latest.values()]
+        .map(({ agentId, sequence, state }) => ({ agentId, sequence, state }))
+        .sort(compareBy('agentId'));
+}
+function compareBy(key) {
+    return (left, right) => left[key].localeCompare(right[key]);
+}
+export function startSupervisionProtocol(progressKey) {
+    return {
+        outcome: 'active',
+        progressKey,
+        unchangedContinuations: 0,
+        probeKey: null,
+        lastReportId: null,
+        waitLease: null,
+        retryKey: null,
+        safetyPauseReason: null,
+    };
+}
+/** Records an automatic continuation result; prose and timestamps are not inputs. */
+export function recordAutomaticContinuation(state, progressKey) {
+    if (state.outcome === 'parked' ||
+        state.outcome === 'attentionRequired' ||
+        state.outcome === 'safetyPaused')
+        return state;
+    // The probe itself is the one continuation allowed while this key is
+    // unchanged. Reaching the scheduling boundary again without a structured
+    // report or semantic progress means that probe failed closed.
+    if (state.outcome === 'probeRequired' && progressKey === state.probeKey)
+        return { ...state, outcome: 'safetyPaused', safetyPauseReason: 'invalidProbeReport' };
+    if (state.outcome === 'retrying' && progressKey === state.retryKey)
+        return state.unchangedContinuations === 0
+            ? { ...state, unchangedContinuations: 1 }
+            : { ...state, outcome: 'safetyPaused', safetyPauseReason: 'retryRecurrence' };
+    if (progressKey !== state.progressKey)
+        return { ...startSupervisionProtocol(progressKey), lastReportId: state.lastReportId };
+    const unchangedContinuations = Math.min(3, state.unchangedContinuations + 1);
+    if (unchangedContinuations === 3 && state.probeKey !== progressKey)
+        return { ...state, unchangedContinuations, outcome: 'probeRequired', probeKey: progressKey };
+    return { ...state, unchangedContinuations };
+}
+/** Accepts only structured, bounded probe reports. Unsupported waits fail closed. */
+export function reportProbe(state, report) {
+    if (state.lastReportId === report.id)
+        return state;
+    if (state.outcome !== 'probeRequired' || !state.probeKey)
+        return state;
+    if (report.kind === 'attention')
+        return { ...state, outcome: 'attentionRequired', lastReportId: report.id };
+    if (report.kind === 'actionable')
+        return {
+            ...startSupervisionProtocol(state.progressKey),
+            lastReportId: report.id,
+        };
+    const wakeConditions = uniqueSupportedWakeConditions(report.wakeConditions);
+    if (!report.leaseId || wakeConditions.length === 0)
+        return state;
+    return {
+        ...state,
+        outcome: 'parked',
+        lastReportId: report.id,
+        waitLease: { id: report.leaseId, probeKey: state.probeKey, wakeConditions },
+    };
+}
+/** A wake is useful only when it matches the durable lease and changed semantic state. */
+export function consumeObservableWake(state, wake) {
+    const lease = state.waitLease;
+    if (state.outcome !== 'parked' ||
+        !lease ||
+        wake.leaseId !== lease.id ||
+        !lease.wakeConditions.includes(wake.condition) ||
+        wake.progressKey === lease.probeKey)
+        return state;
+    return {
+        ...state,
+        outcome: 'retrying',
+        progressKey: wake.progressKey,
+        unchangedContinuations: 0,
+        probeKey: null,
+        waitLease: null,
+        retryKey: wake.progressKey,
+    };
+}
+/** Manual recovery is the only transition out of durable safety pause. */
+export function recoverSafetyPause(state, progressKey) {
+    return state.outcome === 'safetyPaused' ? startSupervisionProtocol(progressKey) : state;
+}
+/** Reject malformed persisted values instead of silently resuming automatic work. */
+export function parseSupervisionProtocolState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    const base = startSupervisionProtocol(typeof candidate.progressKey === 'string' ? candidate.progressKey : '');
+    if (!base.progressKey || !isProtocolOutcome(candidate.outcome))
+        return undefined;
+    const unchangedContinuations = candidate.unchangedContinuations;
+    if (unchangedContinuations !== 0 &&
+        unchangedContinuations !== 1 &&
+        unchangedContinuations !== 2 &&
+        unchangedContinuations !== 3)
+        return undefined;
+    const probeKey = nullableText(candidate.probeKey);
+    const lastReportId = nullableText(candidate.lastReportId);
+    const retryKey = nullableText(candidate.retryKey);
+    if (probeKey === undefined || lastReportId === undefined || retryKey === undefined)
+        return undefined;
+    const waitLease = parseWaitLease(candidate.waitLease);
+    if (waitLease === undefined)
+        return undefined;
+    if (candidate.safetyPauseReason !== null &&
+        candidate.safetyPauseReason !== 'retryRecurrence' &&
+        candidate.safetyPauseReason !== 'invalidProbeReport')
+        return undefined;
+    return {
+        ...base,
+        outcome: candidate.outcome,
+        unchangedContinuations,
+        probeKey,
+        lastReportId,
+        waitLease,
+        retryKey,
+        safetyPauseReason: candidate.safetyPauseReason,
+    };
+}
+function uniqueSupportedWakeConditions(conditions) {
+    return [...new Set(conditions)].filter((condition) => observableWakeConditions.includes(condition));
+}
+function isProtocolOutcome(value) {
+    return [
+        'active',
+        'probeRequired',
+        'parked',
+        'retrying',
+        'attentionRequired',
+        'safetyPaused',
+    ].includes(value);
+}
+function nullableText(value) {
+    return value === null ? null : typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function parseWaitLease(value) {
+    if (value === null)
+        return null;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    if (typeof candidate.id !== 'string' ||
+        !candidate.id ||
+        typeof candidate.probeKey !== 'string' ||
+        !candidate.probeKey ||
+        !Array.isArray(candidate.wakeConditions))
+        return undefined;
+    const wakeConditions = uniqueSupportedWakeConditions(candidate.wakeConditions);
+    return wakeConditions.length === candidate.wakeConditions.length
+        ? { id: candidate.id, probeKey: candidate.probeKey, wakeConditions }
+        : undefined;
+}

package/dist/server/server/features/sessions/application/resume-command.js

@@ -8,9 +8,7 @@ export function buildResumeCommand(session) {
     if (!session.threadId)
         throw new Error('THREAD_REQUIRED');
     return [
-        'codex-profile',
-        'cli',
-        session.profile,
+        'codex',
         'resume',
         session.threadId,
         '-C',

package/dist/server/server/features/sessions/interaction/kind.js

@@ -12,5 +12,6 @@ export function isInteractionKind(value) {
         'quiz',
         'orgPlanAttention',
         'orgPlanCheckpoint',
+        'autopilotWaitLease',
     ].includes(value);
 }

package/dist/server/server/features/sessions/interaction/response-validator.js

@@ -11,7 +11,10 @@ export function isValidInteractionResponse(kind, value) {
         return false;
     if (kind === 'userInput')
         return isValidUserInputResponse(value);
-    if (kind === 'quiz' || kind === 'orgPlanAttention' || kind === 'orgPlanCheckpoint')
+    if (kind === 'quiz' ||
+        kind === 'orgPlanAttention' ||
+        kind === 'orgPlanCheckpoint' ||
+        kind === 'autopilotWaitLease')
         return false;
     if (kind === 'permissionsApproval')
         return isRecord(value.permissions) && (value.scope === 'turn' || value.scope === 'session');

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

@@ -7,7 +7,7 @@ import { buildResumeCommand } from '../application/resume-command.js';
 export function registerListRecentThreads(app, deps) {
     app.get('/api/sessions/recent-threads', async () => {
         const threads = await deps.list();
-        return threads.map(({ id, cwd, profile, recencyAt }) => {
+        return threads.map(({ id, cwd, recencyAt }) => {
             const metadata = deps.metadata?.(id);
             return {
                 id,
@@ -18,7 +18,7 @@ export function registerListRecentThreads(app, deps) {
                 ...(metadata?.orgPlanFilename === undefined
                     ? {}
                     : { orgPlanFilename: metadata.orgPlanFilename }),
-                resumeCommand: buildResumeCommand({ profile, threadId: id, workspacePath: cwd }),
+                resumeCommand: buildResumeCommand({ threadId: id, workspacePath: cwd }),
             };
         });
     });

package/dist/server/server/features/sessions/model/relay-session.js

@@ -30,11 +30,13 @@ export function createSessionExecutionPolicy(input) {
     };
 }
 export function createEffectiveSkillSelection(input) {
+    const warnings = (input.warnings ?? []).filter((warning) => typeof warning === 'string' && warning.length > 0);
     return {
         ...(input.selectedProfileName === undefined
             ? {}
             : { selectedProfileName: normalizeSkillProfileName(input.selectedProfileName) }),
         skills: createSkillSelection(input.skills),
+        ...(warnings.length > 0 ? { warnings: warnings.slice(0, 50) } : {}),
     };
 }
 export class RelaySession {

package/dist/server/server/features/sessions/start-session/use-case.js

@@ -5,7 +5,7 @@
  */
 import { RelaySession } from '../model/relay-session.js';
 import { DEFAULT_SESSION_MODEL } from '../application/start-settings.js';
-import { applySkillSelectionSnapshot, } from '../../skills/model/skill-profile.js';
+import { reconcileSkillSelectionSnapshot, } from '../../skills/model/skill-profile.js';
 import { SkillProfileError } from '../../skills/model/errors.js';
 export async function startSession(input, deps) {
     const model = input.model ?? DEFAULT_SESSION_MODEL;
@@ -28,13 +28,18 @@ export async function startSession(input, deps) {
         deps.skillCatalog(input.profile).list(workspace.realPath),
     ]);
     const sourceProfile = selectedProfile ?? projectProfile;
+    const reconciledSkills = reconcileSkillSelectionSnapshot(catalog.skills, sourceProfile?.skills);
     const effectiveSkillSelection = {
         ...(selectedProfile ? { selectedProfileName: selectedProfile.name } : {}),
-        skills: applySkillSelectionSnapshot(catalog.skills, sourceProfile?.skills).map((skill) => ({
-            name: skill.name,
-            path: skill.path,
-            enabled: skill.enabled,
-        })),
+        skills: [
+            ...reconciledSkills.skills.map((skill) => ({
+                name: skill.name,
+                path: skill.path,
+                enabled: skill.enabled,
+            })),
+            ...reconciledSkills.missing,
+        ],
+        ...(reconciledSkills.warnings.length > 0 ? { warnings: reconciledSkills.warnings } : {}),
     };
     const branch = await deps.gitBranch?.(workspace.realPath);
     const session = RelaySession.create({

package/dist/server/server/features/skills/model/skill-profile.js

@@ -167,6 +167,28 @@ export function selectEffectiveSkillSelection(input) {
         return { source: 'project', selection: createSkillSelection(input.project) };
     return { source: 'native', selection: undefined };
 }
+/**
+ * Reconcile a saved snapshot against fresh discovery. Missing entries remain
+ * visible as disabled profile state, but are never passed to Codex.
+ */
+export function reconcileSkillSelectionSnapshot(discovered, selection) {
+    if (selection === undefined)
+        return {
+            skills: applySkillSelectionSnapshot(discovered),
+            missing: [],
+            warnings: [],
+        };
+    const reboundSelection = rebindVersionedPluginSkills(discovered, selection);
+    const discoveredPaths = new Set(discovered.map((skill) => canonicalSkillPath(skill.path)));
+    const missing = createSkillSelection(reboundSelection
+        .filter((entry) => !discoveredPaths.has(entry.path))
+        .map((entry) => ({ ...entry, enabled: false })));
+    return {
+        skills: applySkillSelectionSnapshot(discovered, reboundSelection),
+        missing,
+        warnings: missing.map((entry) => `Skill "${entry.name}" is missing and was disabled: ${entry.path}`),
+    };
+}
 /**
  * Compile a complete, process-local `skills.config` map from fresh discovery.
  * It neither writes configuration nor mutates the user Codex installation.
@@ -175,18 +197,13 @@ export function compileSkillOverride(input) {
     const effective = selectEffectiveSkillSelection(input);
     if (effective.selection === undefined)
         return { source: 'native', skillsConfig: undefined, warnings: [] };
-    const reboundSelection = rebindVersionedPluginSkills(input.discovered, effective.selection);
-    const discoveredPaths = new Set(input.discovered.map((skill) => canonicalSkillPath(skill.path)));
-    const warnings = reboundSelection
-        .filter((entry) => !discoveredPaths.has(entry.path))
-        .map((entry) => `Saved skill path is no longer discovered: ${entry.path}`);
-    const configured = applySkillSelectionSnapshot(input.discovered, reboundSelection);
+    const reconciled = reconcileSkillSelectionSnapshot(input.discovered, effective.selection);
     return {
         source: effective.source,
-        skillsConfig: configured
+        skillsConfig: reconciled.skills
             .map((skill) => ({ path: skill.path, enabled: skill.enabled }))
             .sort((left, right) => left.path.localeCompare(right.path)),
-        warnings,
+        warnings: reconciled.warnings,
     };
 }
 /** Construct the single profile contract shared by global and project YAML files. */

package/dist/server/server/platform/catalog/launcher-profile-catalog.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const launcherProfile = {
+    name: 'default',
+    state: 'ok',
+    status: 'Using the Gestalt launcher environment',
+};
+export class LauncherProfileCatalog {
+    async list() {
+        return [launcherProfile];
+    }
+    async require(name) {
+        const profile = (await this.list()).find((item) => item.name === name);
+        if (!profile)
+            throw new Error('PROFILE_NOT_FOUND');
+        return profile;
+    }
+}

package/dist/server/server/platform/catalog/profile-command.js

@@ -3,19 +3,8 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const localAvailability = {
-    codexProfileAvailable: () => !spawnSync('codex-profile', ['--version'], { stdio: 'ignore' }).error,
-    gestaltHomeExists: () => existsSync(join(homedir(), '.codex-gestalt')),
-};
-export function profileAppServerCommand(_profile, availability = localAvailability, skillsConfig) {
-    void _profile;
-    const base = availability.codexProfileAvailable() && availability.gestaltHomeExists()
-        ? { command: 'codex-profile', args: ['cli', 'gestalt', 'app-server', '--stdio'] }
-        : { command: 'codex', args: ['app-server', '--stdio'] };
+export function profileAppServerCommand(skillsConfig) {
+    const base = { command: 'codex', args: ['app-server', '--stdio'] };
     return skillsConfig === undefined
         ? base
         : {

package/dist/server/server/platform/codex/codex-process-launcher.js

@@ -7,7 +7,7 @@ import { spawn } from 'node:child_process';
 import { JsonRpcClient } from './json-rpc-client.js';
 import { profileAppServerCommand } from '../catalog/profile-command.js';
 export function launchCodexAppServer(input) {
-    const launch = profileAppServerCommand(input.profile, undefined, input.skillsConfig);
+    const launch = profileAppServerCommand(input.skillsConfig);
     const child = spawn(launch.command, launch.args, {
         cwd: input.cwd,
         env: codexChildEnvironment(input.environment),

package/dist/server/server/platform/codex/server-request.js

@@ -6,6 +6,7 @@
 import { GESTALT_QUIZ_TOOL_NAME, parseQuiz } from '../../../shared/contracts/quiz.js';
 import { GESTALT_ORG_PLAN_ATTENTION_TOOL_NAME, parseOrgPlanAttention, } from '../../../shared/contracts/org-plan-attention.js';
 import { GESTALT_ORG_PLAN_CHECKPOINT_TOOL_NAME, parseOrgPlanCheckpoint, } from '../../../shared/contracts/org-plan-checkpoint.js';
+import { GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME, parseAutopilotWaitLease, } from '../../../shared/contracts/autopilot-wait-lease.js';
 export function toPendingInteraction(input) {
     if (!Number.isSafeInteger(input.id) || !isRecord(input.params))
         return null;
@@ -26,6 +27,12 @@ export function toPendingInteraction(input) {
                 ? { requestId: String(input.id), kind: 'orgPlanCheckpoint', payload: checkpoint }
                 : null;
         }
+        if (input.params.tool === GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME) {
+            const lease = parseAutopilotWaitLease(input.params.arguments);
+            return lease
+                ? { requestId: String(input.id), kind: 'autopilotWaitLease', payload: lease }
+                : null;
+        }
         return null;
     }
     const kind = {
@@ -45,6 +52,12 @@ export function resolvedServerRequestId(input) {
         return null;
     return String(requestId);
 }
+export function isAutopilotWaitLeaseCall(input) {
+    return (Number.isSafeInteger(input.id) &&
+        input.method === 'item/tool/call' &&
+        isRecord(input.params) &&
+        input.params.tool === GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME);
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/server/server/platform/codex/session-runtime.js

@@ -10,6 +10,7 @@ import { canRebindMissingRollout, rebindMissingRollout, } from '../../features/s
 import { gestaltQuizDynamicTool } from '../../../shared/contracts/quiz.js';
 import { gestaltOrgPlanAttentionDynamicTool } from '../../../shared/contracts/org-plan-attention.js';
 import { gestaltOrgPlanCheckpointDynamicTool } from '../../../shared/contracts/org-plan-checkpoint.js';
+import { gestaltAutopilotWaitLeaseDynamicTool } from '../../../shared/contracts/autopilot-wait-lease.js';
 import { countDiffLines } from '../../../shared/contracts/file-change.js';
 import { threadPlanName } from './thread-plan-name.js';
 import { WriterAcquisitionError, } from '../../features/sessions/application/writer-acquisition.js';
@@ -568,6 +569,7 @@ export class CodexSessionRuntime {
                         gestaltQuizDynamicTool,
                         gestaltOrgPlanAttentionDynamicTool,
                         gestaltOrgPlanCheckpointDynamicTool,
+                        gestaltAutopilotWaitLeaseDynamicTool,
                     ],
                 });
                 result = {
@@ -658,6 +660,7 @@ export class CodexSessionRuntime {
                 gestaltQuizDynamicTool,
                 gestaltOrgPlanAttentionDynamicTool,
                 gestaltOrgPlanCheckpointDynamicTool,
+                gestaltAutopilotWaitLeaseDynamicTool,
             ],
             ...(session.model ? { model: session.model } : {}),
             ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),

package/dist/server/server/platform/persistence/sqlite-autopilot-store.js

@@ -16,7 +16,14 @@ export class SqliteAutopilotStore {
         if (!row)
             return null;
         const lifecycle = parseLifecycle(row.lifecycle_json);
-        if (!['disabled', 'monitoring', 'backoff', 'attentionRequired', 'completed'].includes(String(row.state)) ||
+        if (![
+            'disabled',
+            'monitoring',
+            'backoff',
+            'attentionRequired',
+            'completed',
+            'safetyPaused',
+        ].includes(String(row.state)) ||
             ![
                 'manualDisabled',
                 'planRequired',
@@ -30,6 +37,7 @@ export class SqliteAutopilotStore {
                 'planRemoved',
                 'planReplaced',
                 'sessionEnded',
+                'safetyPaused',
                 'null',
             ].includes(String(row.stop_reason)) ||
             !Number.isSafeInteger(Number(row.generation)) ||
@@ -57,10 +65,11 @@ export class SqliteAutopilotStore {
     save(state) {
         this.db
             .prepare('INSERT INTO autopilot_sessions (session_id,state,requested_enabled,plan_identity,plan_fingerprint,generation,no_progress_count,next_evaluation_at,last_control_id,stop_reason,lifecycle_json,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(session_id) DO UPDATE SET state=excluded.state,requested_enabled=excluded.requested_enabled,plan_identity=excluded.plan_identity,plan_fingerprint=excluded.plan_fingerprint,generation=excluded.generation,no_progress_count=excluded.no_progress_count,next_evaluation_at=excluded.next_evaluation_at,last_control_id=excluded.last_control_id,stop_reason=excluded.stop_reason,lifecycle_json=excluded.lifecycle_json,updated_at=excluded.updated_at')
-            .run(state.sessionId, state.state, state.requestedEnabled ? 1 : 0, state.planIdentity, state.planFingerprint, state.generation, state.consecutiveNoProgress, state.nextEvaluationAt, state.lastControlId, state.stopReason, state.executor || state.blocking || state.checkpoints
+            .run(state.sessionId, state.state, state.requestedEnabled ? 1 : 0, state.planIdentity, state.planFingerprint, state.generation, state.consecutiveNoProgress, state.nextEvaluationAt, state.lastControlId, state.stopReason, state.executor || state.blocking || state.supervision || state.checkpoints
             ? JSON.stringify({
                 executor: state.executor,
                 blocking: state.blocking,
+                supervision: state.supervision,
                 checkpoints: state.checkpoints,
             })
             : null, state.updatedAt);

package/dist/server/server/platform/plans/filesystem-plan-status-source.js

@@ -154,9 +154,11 @@ class ActiveLease {
     onActiveStatusPath;
     onClose;
     watcher;
+    planWatcher;
     debounce;
     closed = false;
     activeStatusPath;
+    activePlanPath;
     lastEmittedUpdate;
     constructor(statusDirectory, sessionId, workspacePath, listener, planReadFilesystem, isDismissed, onActiveStatusPath, onClose) {
         this.statusDirectory = statusDirectory;
@@ -184,7 +186,10 @@ class ActiveLease {
         this.closed = true;
         if (this.debounce)
             clearTimeout(this.debounce);
+        if (this.planDebounce)
+            clearTimeout(this.planDebounce);
         void this.watcher?.return?.();
+        void this.planWatcher?.return?.();
         this.onClose();
     }
     async remove() {
@@ -226,6 +231,35 @@ class ActiveLease {
             void (pendingStatusPath ? this.refreshPath(pendingStatusPath) : this.refreshLatest());
         }, 25);
     }
+    watchActivePlan(planPath) {
+        if (this.activePlanPath === planPath && this.planWatcher)
+            return;
+        void this.planWatcher?.return?.();
+        this.activePlanPath = planPath;
+        void (async () => {
+            try {
+                this.planWatcher = watch(dirname(planPath), { persistent: false });
+                for await (const event of this.planWatcher) {
+                    if (this.closed || basename(String(event.filename ?? '')) !== basename(planPath))
+                        continue;
+                    this.schedulePlanRefresh();
+                }
+            }
+            catch {
+                // The status signal remains the bounded recovery path.
+            }
+        })();
+    }
+    planDebounce;
+    schedulePlanRefresh() {
+        if (this.planDebounce)
+            clearTimeout(this.planDebounce);
+        this.planDebounce = setTimeout(() => {
+            this.planDebounce = undefined;
+            if (this.activeStatusPath)
+                void this.refreshPath(this.activeStatusPath);
+        }, 25);
+    }
     async refreshCurrent() {
         return this.activeStatusPath ? this.refreshPath(this.activeStatusPath) : this.refreshLatest();
     }
@@ -274,6 +308,7 @@ class ActiveLease {
                 if (!this.closed && !(await this.isDismissed(identity)) && !this.closed) {
                     const previousStatusPath = this.activeStatusPath;
                     this.activeStatusPath = statusPath;
+                    this.watchActivePlan(planPath);
                     this.onActiveStatusPath(statusPath);
                     const update = {
                         kind: 'updated',

package/dist/server/shared/contracts/autopilot-wait-lease.js

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export const GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME = 'gestalt_autopilot_wait_lease';
+export const autopilotWaitWakeConditions = [
+    'planChanged',
+    'reviewChanged',
+    'checkpointChanged',
+    'interactionChanged',
+    'executorChanged',
+    'processExited',
+    'processResultAvailable',
+    'processLimitBreached',
+    'agentActivityChanged',
+];
+export const gestaltAutopilotWaitLeaseDynamicTool = {
+    type: 'function',
+    name: GESTALT_AUTOPILOT_WAIT_LEASE_TOOL_NAME,
+    description: 'Register a bounded observable wait for the current supervised session after an Autopilot probe. This cannot request human authority and never accepts transcript prose.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['version', 'reportId', 'leaseId', 'wakeConditions'],
+        properties: {
+            version: { const: 1 },
+            reportId: { type: 'string', minLength: 1, maxLength: 128 },
+            leaseId: { type: 'string', minLength: 1, maxLength: 128 },
+            wakeConditions: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 4,
+                uniqueItems: true,
+                items: { type: 'string', enum: autopilotWaitWakeConditions },
+            },
+        },
+    },
+};
+export function parseAutopilotWaitLease(value) {
+    if (!record(value) || Object.keys(value).length !== 4 || value.version !== 1)
+        return null;
+    if (!bounded(value.reportId) || !bounded(value.leaseId) || !Array.isArray(value.wakeConditions))
+        return null;
+    const wakeConditions = value.wakeConditions;
+    if (wakeConditions.length < 1 ||
+        wakeConditions.length > 4 ||
+        new Set(wakeConditions).size !== wakeConditions.length ||
+        !wakeConditions.every((condition) => typeof condition === 'string' &&
+            autopilotWaitWakeConditions.includes(condition)))
+        return null;
+    return { version: 1, reportId: value.reportId, leaseId: value.leaseId, wakeConditions };
+}
+export function autopilotWaitLeaseToolResponse() {
+    return { success: true, contentItems: [{ type: 'inputText', text: '{"accepted":true}' }] };
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function bounded(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 128;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",
@@ -70,7 +70,7 @@
     "@fontsource/syne": "5.2.7",
     "@simplewebauthn/browser": "13.3.0",
     "@simplewebauthn/server": "13.3.2",
-    "fastify": "^5.10.0",
+    "fastify": "^5.12.3",
     "qrcode": "^1.5.4",
     "ws": "^8.21.0",
     "yaml": "^2.9.0",