gestalt-mobile 0.29.0 → 0.30.0

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/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/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.0",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",