gestalt-mobile 0.25.2 → 0.25.4

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

@@ -0,0 +1,255 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { orgPlanAgentDisplayName } from '../../../../shared/org-plan-position.js';
+export const blockingResumeConditions = {
+    planChange: 'planRevision',
+    hardBlock: 'externalStateChanged',
+    missingDependency: 'dependencyInstalled',
+    permissionRequired: 'permissionGranted',
+    externalState: 'externalStateChanged',
+    materialAmbiguity: 'userGuidance',
+};
+export function validStructuredBlock(value) {
+    return Boolean(value && blockingResumeConditions[value.reason] === value.resumeCondition);
+}
+export function parsePersistedSupervisedLifecycle(value) {
+    const root = record(value);
+    if (!root)
+        return undefined;
+    const blockingValue = record(root.blocking);
+    const blocking = blockingValue ? parseStructuredBlock(blockingValue) : undefined;
+    if (blockingValue && !blocking)
+        return undefined;
+    const executorValue = record(root.executor);
+    if (!executorValue)
+        return blocking ? { blocking } : {};
+    const processesValue = executorValue.ownedProcesses;
+    if (!Array.isArray(processesValue) || processesValue.length > 64)
+        return undefined;
+    const ownedProcesses = processesValue.flatMap((candidate) => {
+        const process = record(candidate);
+        if (!process)
+            return [];
+        const processId = boundedText(process.processId);
+        const itemId = boundedText(process.itemId);
+        const ownerThreadId = boundedText(process.ownerThreadId);
+        const ownerTaskPath = boundedText(process.ownerTaskPath);
+        const ownership = stringValue(process.ownership, ['executor', 'supervisor']);
+        const state = stringValue(process.state, [
+            'running',
+            'detached-active',
+            'exited-awaiting-result',
+            'result-consumed',
+            'terminated-for-budget',
+        ]);
+        const observedAt = boundedText(process.observedAt);
+        const elapsedMs = nonNegativeNumber(process.elapsedMs);
+        const cpuPercent = nullableNonNegativeNumber(process.cpuPercent);
+        const rssBytes = nullableNonNegativeNumber(process.rssBytes);
+        if (!processId ||
+            !itemId ||
+            !ownerThreadId ||
+            !ownerTaskPath ||
+            !ownership ||
+            !state ||
+            !observedAt ||
+            elapsedMs === null ||
+            cpuPercent === undefined ||
+            rssBytes === undefined)
+            return [];
+        const osPid = nonNegativeInteger(process.osPid);
+        const exitStatus = integer(process.exitStatus);
+        const resultArtifact = boundedText(process.resultArtifact);
+        return [
+            {
+                processId,
+                itemId,
+                ownerThreadId,
+                ownerTaskPath,
+                ownership,
+                state,
+                observedAt,
+                elapsedMs,
+                cpuPercent,
+                rssBytes,
+                ...(osPid === null ? {} : { osPid }),
+                ...(exitStatus === null ? {} : { exitStatus }),
+                ...(resultArtifact ? { resultArtifact } : {}),
+            },
+        ];
+    });
+    if (ownedProcesses.length !== processesValue.length)
+        return undefined;
+    const canonicalPosition = boundedText(executorValue.canonicalPosition);
+    const canonicalTaskName = boundedText(executorValue.canonicalTaskName);
+    const taskPath = boundedText(executorValue.taskPath);
+    const threadId = boundedText(executorValue.threadId);
+    const l1State = stringValue(executorValue.l1State, ['TODO', 'WIP', 'DONE']);
+    const l2State = stringValue(executorValue.l2State, ['TODO', 'WIP', 'DONE']);
+    const lastActivityAt = boundedText(executorValue.lastActivityAt);
+    const outcome = stringValue(executorValue.outcome, [
+        'objective_complete',
+        'partial',
+        'blocked',
+        'cancelled',
+        'failed',
+    ]);
+    const continuationGeneration = nonNegativeInteger(executorValue.continuationGeneration);
+    const continuationCount = nonNegativeInteger(executorValue.continuationCount);
+    if (!canonicalPosition ||
+        !canonicalTaskName ||
+        !taskPath ||
+        !threadId ||
+        !l1State ||
+        !lastActivityAt ||
+        !outcome ||
+        continuationGeneration === null ||
+        continuationCount === null)
+        return undefined;
+    const executorBlockingValue = record(executorValue.blocking);
+    const executorBlocking = executorBlockingValue
+        ? parseStructuredBlock(executorBlockingValue)
+        : undefined;
+    if (executorBlockingValue && !executorBlocking)
+        return undefined;
+    return {
+        executor: {
+            canonicalPosition,
+            canonicalTaskName,
+            taskPath,
+            threadId,
+            l1State,
+            ...(l2State ? { l2State } : {}),
+            lastActivityAt,
+            ownedProcesses,
+            outcome,
+            ...(executorBlocking ? { blocking: executorBlocking } : {}),
+            continuationGeneration,
+            continuationCount,
+        },
+        ...(blocking ? { blocking } : {}),
+    };
+}
+export function classifyExecutorOutcome(input) {
+    if (input.objectiveComplete)
+        return { outcome: 'objective_complete' };
+    if (input.reportedOutcome === 'cancelled' || input.reportedOutcome === 'failed')
+        return { outcome: input.reportedOutcome };
+    const blocking = input.blockingReason && input.resumeCondition
+        ? { reason: input.blockingReason, resumeCondition: input.resumeCondition }
+        : undefined;
+    if (input.reportedOutcome === 'blocked' && validStructuredBlock(blocking))
+        return { outcome: 'blocked', blocking };
+    // A turn ending, a checkpoint, or free-form language about time/context is
+    // not objective state. Incomplete Org state remains mechanically partial.
+    return { outcome: 'partial' };
+}
+export function decideSupervisedLifecycle(input) {
+    if (input.explicitlyPausedOrCancelled || executionComplete(input.plan))
+        return { finalAllowed: true, action: { kind: 'allowFinal' } };
+    if (validStructuredBlock(input.attention))
+        return {
+            finalAllowed: true,
+            action: { kind: 'invokeAttention', ...input.attention },
+        };
+    const processes = input.executor?.ownedProcesses ?? [];
+    const overBudget = processes.find((process) => (process.state === 'running' || process.state === 'detached-active') &&
+        (process.elapsedMs > input.policy.processMaxElapsedMs ||
+            (process.rssBytes !== null && process.rssBytes > input.policy.processMaxRssBytes)));
+    if (overBudget)
+        return {
+            finalAllowed: false,
+            action: {
+                kind: 'terminateProcess',
+                threadId: overBudget.ownerThreadId,
+                processId: overBudget.processId,
+            },
+        };
+    const exited = processes.find((process) => process.state === 'exited-awaiting-result' && process.resultArtifact);
+    if (exited)
+        return {
+            finalAllowed: false,
+            action: {
+                kind: 'consumeProcessResult',
+                threadId: exited.ownerThreadId,
+                processId: exited.processId,
+                resultArtifact: exited.resultArtifact,
+            },
+        };
+    const active = processes.find((process) => process.state === 'running' || process.state === 'detached-active');
+    if (active)
+        return {
+            finalAllowed: false,
+            action: {
+                kind: 'monitorProcess',
+                process: { ...active, ownership: 'supervisor', state: 'detached-active' },
+                pollAfterMs: input.policy.processPollMs,
+            },
+        };
+    if (input.event === 'waitTimeout' && !input.executor)
+        return { finalAllowed: false, action: { kind: 'reinspect' } };
+    if (!input.executor || input.executor.l1State === 'DONE')
+        return { finalAllowed: false, action: { kind: 'continueSupervisor' } };
+    const exponent = Math.min(30, Math.max(0, input.executor.continuationCount));
+    const delayMs = Math.min(input.policy.continuationMaxDelayMs, input.policy.continuationBaseDelayMs * 2 ** exponent);
+    return {
+        finalAllowed: false,
+        action: {
+            kind: 'resumeExecutor',
+            threadId: input.executor.threadId,
+            generation: input.executor.continuationGeneration + 1,
+            delayMs,
+        },
+    };
+}
+export function executorIdentity(canonicalTaskName, generation) {
+    if (!/^l[1-9]\d*(?:_[1-9]\d*)?$/.test(canonicalTaskName) ||
+        !Number.isSafeInteger(generation) ||
+        generation < 1)
+        throw new Error('INVALID_EXECUTOR_IDENTITY');
+    return {
+        canonicalTaskName,
+        canonicalPosition: orgPlanAgentDisplayName(canonicalTaskName),
+        generation,
+        taskName: generation === 1 ? canonicalTaskName : `${canonicalTaskName}_g${generation}`,
+    };
+}
+function executionComplete(plan) {
+    return (plan.executionComplete ??
+        plan.steps.every((step) => step.state === 'DONE' &&
+            step.reviewStatus === 'REVIEWED' &&
+            step.children.every((child) => child.state === 'DONE')));
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parseStructuredBlock(value) {
+    const reason = stringValue(value.reason, Object.keys(blockingResumeConditions));
+    const resumeCondition = stringValue(value.resumeCondition, Object.values(blockingResumeConditions));
+    const blocking = reason && resumeCondition ? { reason, resumeCondition } : undefined;
+    return validStructuredBlock(blocking) ? blocking : undefined;
+}
+function boundedText(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 512 ? value : undefined;
+}
+function stringValue(value, values) {
+    return typeof value === 'string' && values.includes(value) ? value : undefined;
+}
+function nonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function nullableNonNegativeNumber(value) {
+    return value === null ? null : (nonNegativeNumber(value) ?? undefined);
+}
+function integer(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) ? value : null;
+}
+function nonNegativeInteger(value) {
+    const parsed = integer(value);
+    return parsed !== null && parsed >= 0 ? parsed : null;
+}

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

@@ -29,6 +29,8 @@ class SessionResource {
     writtenThreadName;
     capabilities = new Map();
     spawnedAgentModels = new Map();
+    attemptedAgentModelRecovery = new Set();
+    ownedChildProcesses = new Map();
     constructor(sessionId, process, planStatusLease, planMeasurementToken, unregister, onDisposed) {
         this.sessionId = sessionId;
         this.process = process;
@@ -182,6 +184,17 @@ export class CodexSessionRuntime {
         }));
         return RelaySession.rehydrate(session).startTurn(result, now).snapshot;
     }
+    async startExecutorTurn(session, childThreadId, text, clientUserMessageId) {
+        const resource = this.sessions.get(session.id);
+        if (!resource)
+            throw new Error('CODEX_SESSION_NOT_RUNNING');
+        return decodeTurnStart(await resource.process.rpc.request('turn/start', {
+            threadId: childThreadId,
+            input: [{ type: 'text', text, text_elements: [] }],
+            clientUserMessageId,
+            ...(session.model ? { model: session.model } : {}),
+        }));
+    }
     /** The sole authoritative in-process ownership probe.  It never launches a child. */
     ownsWriter(sessionId) {
         return this.sessions.get(sessionId)?.active === true;
@@ -315,6 +328,9 @@ export class CodexSessionRuntime {
                         ...(owned.spawnedAgentModels.get(value.id)
                             ? { model: owned.spawnedAgentModels.get(value.id) }
                             : {}),
+                        ...(decodeAgentTaskPath(value.source)
+                            ? { taskPath: decodeAgentTaskPath(value.source) }
+                            : {}),
                     },
                 ];
             }));
@@ -322,7 +338,7 @@ export class CodexSessionRuntime {
                 ? response.nextCursor
                 : undefined;
             if (!next)
-                return children;
+                return this.withResolvedChildModels(owned, children);
             if (cursors.has(next) || children.length >= 64)
                 throw new Error('CODEX_CHILD_LIST_UNSUPPORTED');
             cursors.add(next);
@@ -330,7 +346,159 @@ export class CodexSessionRuntime {
         }
         if (cursor)
             throw new Error('CODEX_CHILD_LIST_UNSUPPORTED');
-        return children;
+        return this.withResolvedChildModels(owned, children);
+    }
+    async withResolvedChildModels(resource, children) {
+        for (const child of children) {
+            if (child.status !== 'notLoaded' ||
+                resource.spawnedAgentModels.has(child.id) ||
+                resource.attemptedAgentModelRecovery.has(child.id))
+                continue;
+            resource.attemptedAgentModelRecovery.add(child.id);
+            try {
+                const response = await resource.process.rpc.request('thread/resume', {
+                    threadId: child.id,
+                });
+                const model = boundedString(asRecord(response)?.model, 256);
+                if (model)
+                    resource.spawnedAgentModels.set(child.id, model);
+            }
+            catch {
+                // A live settings notification can still provide the model later.
+            }
+        }
+        return children.map((child) => {
+            const model = child.model ?? resource.spawnedAgentModels.get(child.id);
+            return model && model !== child.model ? { ...child, model } : child;
+        });
+    }
+    /** Reads only bounded process metadata; command text and output never enter lifecycle state. */
+    async inspectChildProcesses(session, child) {
+        const owned = this.sessions.get(session.id);
+        if (!owned)
+            return [];
+        const active = await this.listChildBackgroundTerminals(owned, child);
+        const activeIds = new Set(active.map((process) => process.processId));
+        for (const process of active)
+            owned.ownedChildProcesses.set(childProcessKey(child.id, process.processId), process);
+        const prior = [...owned.ownedChildProcesses.values()].filter((process) => process.ownerThreadId === child.id && !activeIds.has(process.processId));
+        if (prior.some((process) => process.state === 'running' || process.state === 'detached-active')) {
+            const results = await this.readChildProcessResults(owned, child.id);
+            for (const process of prior) {
+                if (process.state !== 'running' && process.state !== 'detached-active')
+                    continue;
+                const result = results.get(process.itemId);
+                owned.ownedChildProcesses.set(childProcessKey(child.id, process.processId), {
+                    ...process,
+                    state: 'exited-awaiting-result',
+                    cpuPercent: 0,
+                    rssBytes: 0,
+                    ...(result?.exitStatus === undefined ? {} : { exitStatus: result.exitStatus }),
+                    resultArtifact: `${child.id}:${process.itemId}`,
+                });
+            }
+        }
+        return [...owned.ownedChildProcesses.values()].filter((process) => process.ownerThreadId === child.id &&
+            process.state !== 'result-consumed' &&
+            process.state !== 'terminated-for-budget');
+    }
+    consumeChildProcessResult(sessionId, childThreadId, processId) {
+        this.sessions
+            .get(sessionId)
+            ?.ownedChildProcesses.delete(childProcessKey(childThreadId, processId));
+    }
+    async terminateChildProcess(session, childThreadId, processId) {
+        const owned = this.sessions.get(session.id);
+        if (!owned)
+            return false;
+        const result = await owned.process.rpc.request('thread/backgroundTerminals/terminate', {
+            threadId: childThreadId,
+            processId,
+        });
+        const terminated = asRecord(result)?.terminated === true;
+        if (terminated) {
+            const key = childProcessKey(childThreadId, processId);
+            const process = owned.ownedChildProcesses.get(key);
+            if (process)
+                owned.ownedChildProcesses.set(key, { ...process, state: 'terminated-for-budget' });
+        }
+        return terminated;
+    }
+    async listChildBackgroundTerminals(owned, child) {
+        const processes = [];
+        const cursors = new Set();
+        let cursor;
+        for (let page = 0; page < 4 && processes.length < 64; page += 1) {
+            const result = await owned.process.rpc.request('thread/backgroundTerminals/list', {
+                threadId: child.id,
+                limit: 64,
+                ...(cursor ? { cursor } : {}),
+            });
+            const response = asRecord(result);
+            const data = Array.isArray(response?.data) ? response.data : [];
+            for (const candidate of data) {
+                const value = asRecord(candidate);
+                const itemId = boundedString(value?.itemId, 256);
+                const processId = boundedString(value?.processId, 256);
+                if (!itemId || !processId || processes.length >= 64)
+                    continue;
+                const key = childProcessKey(child.id, processId);
+                const before = owned.ownedChildProcesses.get(key);
+                const observedAt = before?.observedAt ?? new Date().toISOString();
+                const rssKb = boundedNonNegativeNumber(value?.rssKb);
+                processes.push({
+                    processId,
+                    itemId,
+                    ownerThreadId: child.id,
+                    ownerTaskPath: child.taskPath ?? child.id,
+                    ownership: before?.ownership ?? 'executor',
+                    state: before?.state === 'detached-active' ? 'detached-active' : 'running',
+                    observedAt,
+                    elapsedMs: Math.max(0, Date.now() - Date.parse(observedAt)),
+                    cpuPercent: boundedNonNegativeNumber(value?.cpuPercent),
+                    rssBytes: rssKb === null ? null : Math.min(Number.MAX_SAFE_INTEGER, rssKb * 1024),
+                    ...(boundedNonNegativeInteger(value?.osPid) === null
+                        ? {}
+                        : { osPid: boundedNonNegativeInteger(value?.osPid) }),
+                });
+            }
+            const next = boundedString(response?.nextCursor, 256);
+            if (!next)
+                return processes;
+            if (cursors.has(next) || processes.length >= 64)
+                throw new Error('CODEX_BACKGROUND_TERMINAL_LIST_UNSUPPORTED');
+            cursors.add(next);
+            cursor = next;
+        }
+        if (cursor)
+            throw new Error('CODEX_BACKGROUND_TERMINAL_LIST_UNSUPPORTED');
+        return processes;
+    }
+    async readChildProcessResults(owned, childThreadId) {
+        const result = await owned.process.rpc.request('thread/read', {
+            threadId: childThreadId,
+            includeTurns: true,
+        });
+        const decoded = new Map();
+        const turns = asRecord(asRecord(result)?.thread)?.turns;
+        if (!Array.isArray(turns) || turns.length > 10_000)
+            return decoded;
+        for (const turn of turns) {
+            const items = asRecord(turn)?.items;
+            if (!Array.isArray(items) || items.length > 10_000)
+                continue;
+            for (const candidate of items) {
+                const item = asRecord(candidate);
+                const itemId = boundedString(item?.id, 256);
+                if (item?.type !== 'commandExecution' ||
+                    !itemId ||
+                    !['completed', 'failed', 'declined'].includes(String(item.status)))
+                    continue;
+                const exitStatus = boundedInteger(item.exitCode);
+                decoded.set(itemId, exitStatus === null ? {} : { exitStatus });
+            }
+        }
+        return decoded;
     }
     async readDetachedHistory(session) {
         // A reader is intentionally not a SessionResource: it owns no subscriptions,
@@ -353,7 +521,6 @@ export class CodexSessionRuntime {
     async decodeHistory(process, threadId, resource) {
         const response = await process.rpc.request('thread/read', { threadId, includeTurns: true });
         if (resource) {
-            resource.spawnedAgentModels.clear();
             for (const [childId, model] of decodeSpawnedAgentModels(response))
                 resource.spawnedAgentModels.set(childId, model);
         }
@@ -525,6 +692,11 @@ export class CodexSessionRuntime {
             const notificationUnsubscribe = process.rpc.onNotification((notification) => {
                 if (!resource.active)
                     return;
+                const childModel = decodeThreadSettingsModel(notification);
+                if (childModel &&
+                    (resource.spawnedAgentModels.has(childModel.threadId) ||
+                        resource.spawnedAgentModels.size < 256))
+                    resource.spawnedAgentModels.set(childModel.threadId, childModel.model);
                 const resolvedRequestId = resolvedServerRequestId(notification);
                 if (resolvedRequestId) {
                     const pending = resource.pendingRequests.get(resolvedRequestId);
@@ -622,6 +794,35 @@ function threadTokenUsage(value) {
 function asRecord(value) {
     return value && typeof value === 'object' ? value : undefined;
 }
+function decodeAgentTaskPath(value) {
+    const subagent = asRecord(asRecord(value)?.subagent);
+    const spawn = asRecord(subagent?.thread_spawn);
+    const path = boundedString(spawn?.agent_path, 256);
+    return path?.startsWith('/') && !path.includes('..') ? path : undefined;
+}
+/** Captures the resolved model that Codex applies after spawning a child thread. */
+function decodeThreadSettingsModel(notification) {
+    if (notification.method !== 'thread/settings/updated')
+        return undefined;
+    const params = asRecord(notification.params);
+    const threadId = boundedString(params?.threadId, 256);
+    const model = boundedString(asRecord(params?.threadSettings)?.model, 256);
+    return threadId && model ? { threadId, model } : undefined;
+}
+function childProcessKey(childThreadId, processId) {
+    return `${childThreadId}:${processId}`;
+}
+function boundedNonNegativeNumber(value) {
+    const number = typeof value === 'bigint' ? Number(value) : value;
+    return typeof number === 'number' && Number.isFinite(number) && number >= 0 ? number : null;
+}
+function boundedInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) ? value : null;
+}
+function boundedNonNegativeInteger(value) {
+    const number = boundedInteger(value);
+    return number !== null && number >= 0 ? number : null;
+}
 function decodeThreadStart(value) {
     const id = asRecord(asRecord(value)?.thread)?.id;
     if (typeof id !== 'string' || !id || id.length > 256)

package/dist/server/server/platform/persistence/migrate.js

@@ -3,10 +3,10 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-const schema = `CREATE TABLE IF NOT EXISTS relay_sessions (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, workspace_path TEXT NOT NULL, profile TEXT NOT NULL, model TEXT, branch TEXT, sandbox TEXT, approval_policy TEXT, thread_id TEXT, state TEXT NOT NULL, desired_state TEXT NOT NULL, active_turn_id TEXT, protocol_version TEXT, failure_count INTEGER NOT NULL DEFAULT 0, effective_skill_selection_json TEXT, last_org_plan_json TEXT, next_sequence INTEGER NOT NULL DEFAULT 1, created_at TEXT NOT NULL, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS pending_interactions (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, request_id TEXT NOT NULL, kind TEXT NOT NULL, payload_json TEXT NOT NULL, turn_id TEXT, requested_at TEXT, resolved_at TEXT, outcome TEXT, operation_key TEXT, resolution_state TEXT NOT NULL DEFAULT 'active', PRIMARY KEY (session_id, request_id)); CREATE TABLE IF NOT EXISTS session_events (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, sequence INTEGER NOT NULL, occurred_at TEXT NOT NULL, type TEXT NOT NULL, payload_json TEXT NOT NULL, autopilot_outbox_id INTEGER, PRIMARY KEY (session_id, sequence), UNIQUE(session_id, autopilot_outbox_id)); CREATE TABLE IF NOT EXISTS idempotency_results (scope TEXT NOT NULL, key TEXT NOT NULL, status_code INTEGER NOT NULL, body_json TEXT NOT NULL, PRIMARY KEY (scope, key)); CREATE TABLE IF NOT EXISTS autopilot_sessions (session_id TEXT PRIMARY KEY REFERENCES relay_sessions(id) ON DELETE CASCADE, state TEXT NOT NULL, requested_enabled INTEGER NOT NULL, plan_identity TEXT, plan_fingerprint TEXT, generation INTEGER NOT NULL, no_progress_count INTEGER NOT NULL, next_evaluation_at TEXT, last_control_id TEXT, stop_reason TEXT, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS autopilot_controls (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, control_id TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, failure_code TEXT, turn_id TEXT, PRIMARY KEY (session_id, control_id)); CREATE TABLE IF NOT EXISTS autopilot_outbox (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, type TEXT NOT NULL, payload_json TEXT NOT NULL, occurred_at TEXT NOT NULL);`;
+const schema = `CREATE TABLE IF NOT EXISTS relay_sessions (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, workspace_path TEXT NOT NULL, profile TEXT NOT NULL, model TEXT, branch TEXT, sandbox TEXT, approval_policy TEXT, thread_id TEXT, state TEXT NOT NULL, desired_state TEXT NOT NULL, active_turn_id TEXT, protocol_version TEXT, failure_count INTEGER NOT NULL DEFAULT 0, effective_skill_selection_json TEXT, last_org_plan_json TEXT, next_sequence INTEGER NOT NULL DEFAULT 1, created_at TEXT NOT NULL, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS pending_interactions (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, request_id TEXT NOT NULL, kind TEXT NOT NULL, payload_json TEXT NOT NULL, turn_id TEXT, requested_at TEXT, resolved_at TEXT, outcome TEXT, operation_key TEXT, resolution_state TEXT NOT NULL DEFAULT 'active', PRIMARY KEY (session_id, request_id)); CREATE TABLE IF NOT EXISTS session_events (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, sequence INTEGER NOT NULL, occurred_at TEXT NOT NULL, type TEXT NOT NULL, payload_json TEXT NOT NULL, autopilot_outbox_id INTEGER, PRIMARY KEY (session_id, sequence), UNIQUE(session_id, autopilot_outbox_id)); CREATE TABLE IF NOT EXISTS idempotency_results (scope TEXT NOT NULL, key TEXT NOT NULL, status_code INTEGER NOT NULL, body_json TEXT NOT NULL, PRIMARY KEY (scope, key)); CREATE TABLE IF NOT EXISTS autopilot_sessions (session_id TEXT PRIMARY KEY REFERENCES relay_sessions(id) ON DELETE CASCADE, state TEXT NOT NULL, requested_enabled INTEGER NOT NULL, plan_identity TEXT, plan_fingerprint TEXT, generation INTEGER NOT NULL, no_progress_count INTEGER NOT NULL, next_evaluation_at TEXT, last_control_id TEXT, stop_reason TEXT, lifecycle_json TEXT, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS autopilot_controls (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, control_id TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, failure_code TEXT, turn_id TEXT, PRIMARY KEY (session_id, control_id)); CREATE TABLE IF NOT EXISTS autopilot_outbox (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, type TEXT NOT NULL, payload_json TEXT NOT NULL, occurred_at TEXT NOT NULL);`;
 export function migrate(database) {
     database.exec(schema);
-    database.exec("CREATE INDEX IF NOT EXISTS session_events_autopilot_audit_tail_v2 ON session_events(session_id, type, sequence DESC) WHERE type IN ('autopilot.continuation-scheduled','autopilot.control-issued','autopilot.turn-started','autopilot.turn-failed','autopilot.progress-reset','autopilot.updated','org-plan.attention-required','org-plan.attention-resolved')");
+    database.exec("CREATE INDEX IF NOT EXISTS session_events_autopilot_audit_tail_v3 ON session_events(session_id, type, sequence DESC) WHERE type IN ('autopilot.continuation-scheduled','autopilot.control-issued','autopilot.turn-started','autopilot.turn-failed','autopilot.progress-reset','autopilot.final-rejected','autopilot.executor-resumed','autopilot.process-monitoring','autopilot.process-result-consumed','autopilot.process-terminated','autopilot.updated','org-plan.attention-required','org-plan.attention-resolved')");
     const columns = database.prepare('PRAGMA table_info(relay_sessions)').all();
     if (!columns.some((column) => column.name === 'effective_skill_selection_json'))
         database.exec('ALTER TABLE relay_sessions ADD COLUMN effective_skill_selection_json TEXT');
@@ -22,6 +22,11 @@ export function migrate(database) {
         database.exec('ALTER TABLE relay_sessions ADD COLUMN sandbox TEXT');
     if (!columns.some((column) => column.name === 'approval_policy'))
         database.exec('ALTER TABLE relay_sessions ADD COLUMN approval_policy TEXT');
+    const autopilotColumns = database
+        .prepare('PRAGMA table_info(autopilot_sessions)')
+        .all();
+    if (!autopilotColumns.some((column) => column.name === 'lifecycle_json'))
+        database.exec('ALTER TABLE autopilot_sessions ADD COLUMN lifecycle_json TEXT');
     const interactionColumns = database
         .prepare('PRAGMA table_info(pending_interactions)')
         .all();

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

@@ -3,6 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { parsePersistedSupervisedLifecycle } from '../../features/autopilot/domain/supervised-lifecycle.js';
 export class SqliteAutopilotStore {
     db;
     constructor(db) {
@@ -14,6 +15,7 @@ export class SqliteAutopilotStore {
             .get(sessionId);
         if (!row)
             return null;
+        const lifecycle = parseLifecycle(row.lifecycle_json);
         if (!['disabled', 'monitoring', 'backoff', 'attentionRequired', 'completed'].includes(String(row.state)) ||
             ![
                 'manualDisabled',
@@ -34,7 +36,8 @@ export class SqliteAutopilotStore {
             Number(row.generation) < 0 ||
             !Number.isSafeInteger(Number(row.no_progress_count)) ||
             Number(row.no_progress_count) < 0 ||
-            ![0, 1].includes(Number(row.requested_enabled)))
+            ![0, 1].includes(Number(row.requested_enabled)) ||
+            lifecycle === null)
             return null;
         return {
             sessionId: String(row.session_id),
@@ -47,13 +50,16 @@ export class SqliteAutopilotStore {
             nextEvaluationAt: row.next_evaluation_at === null ? null : String(row.next_evaluation_at),
             lastControlId: row.last_control_id === null ? null : String(row.last_control_id),
             stopReason: row.stop_reason,
+            ...lifecycle,
             updatedAt: String(row.updated_at),
         };
     }
     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,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,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.updatedAt);
+            .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
+            ? JSON.stringify({ executor: state.executor, blocking: state.blocking })
+            : null, state.updatedAt);
     }
     findControl(sessionId, controlId) {
         const row = this.db
@@ -158,3 +164,15 @@ export class SqliteAutopilotStore {
         this.db.prepare('DELETE FROM autopilot_sessions WHERE session_id = ?').run(sessionId);
     }
 }
+function parseLifecycle(value) {
+    if (value === null || value === undefined)
+        return {};
+    if (typeof value !== 'string' || value.length > 256_000)
+        return null;
+    try {
+        return parsePersistedSupervisedLifecycle(JSON.parse(value)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/server/platform/persistence/sqlite-event-journal.js

@@ -6,6 +6,11 @@
 export const autopilotAuditEventTypes = [
     'autopilot.turn-started',
     'autopilot.turn-failed',
+    'autopilot.final-rejected',
+    'autopilot.executor-resumed',
+    'autopilot.process-monitoring',
+    'autopilot.process-result-consumed',
+    'autopilot.process-terminated',
     'autopilot.updated',
     'org-plan.attention-required',
     'org-plan.attention-resolved',

package/dist/server/shared/contracts/autopilot-audit.js

@@ -7,6 +7,18 @@
 export function autopilotAuditLabel(type, payload) {
     if (type === 'autopilot.turn-started')
         return 'Continued execution automatically';
+    if (type === 'autopilot.final-rejected')
+        return 'Kept incomplete supervised work active';
+    if (type === 'autopilot.executor-resumed')
+        return 'Resumed the assigned executor';
+    if (type === 'autopilot.process-monitoring')
+        return 'Monitoring executor background work';
+    if (type === 'autopilot.process-result-consumed')
+        return 'Consumed background work result';
+    if (type === 'autopilot.process-terminated')
+        return property(payload, 'reason') === 'resourceBudget'
+            ? 'Stopped background work at its resource limit'
+            : 'Stopped executor background work';
     if (type === 'autopilot.turn-failed') {
         const code = property(payload, 'code');
         return code === 'START_UNAVAILABLE'

package/dist/server/shared/org-plan-position.js

@@ -6,8 +6,18 @@
 export function orgPlanPosition(l1Position, l2Position) {
     return l2Position === undefined ? `L${l1Position}` : `L${l1Position}.${l2Position}`;
 }
+export function parseOrgPlanAgentIdentity(nameOrPath) {
+    const name = nameOrPath.split('/').filter(Boolean).at(-1) ?? nameOrPath;
+    const match = /^(l([1-9]\d*)(?:_([1-9]\d*))?)(?:_g([1-9]\d*))?$/.exec(name);
+    if (!match)
+        return null;
+    return {
+        canonicalTaskName: match[1],
+        canonicalPosition: orgPlanPosition(Number(match[2]), match[3] ? Number(match[3]) : undefined),
+        generation: match[4] ? Number(match[4]) : 1,
+    };
+}
 /** Converts the collaboration API's tool-safe task name into its canonical plan label. */
 export function orgPlanAgentDisplayName(name) {
-    const match = /^l([1-9]\d*)(?:_([1-9]\d*))?$/.exec(name);
-    return match ? orgPlanPosition(Number(match[1]), match[2] ? Number(match[2]) : undefined) : name;
+    return parseOrgPlanAgentIdentity(name)?.canonicalPosition ?? name;
 }