gestalt-mobile 0.28.0 → 0.30.0

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',
@@ -24,8 +25,20 @@ export function parsePersistedSupervisedLifecycle(value) {
     if (blockingValue && !blocking)
         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 } : {};
+        return {
+            ...(blocking ? { blocking } : {}),
+            ...(supervision ? { supervision } : {}),
+            ...(checkpoints ? { checkpoints } : {}),
+        };
     const processesValue = executorValue.ownedProcesses;
     if (!Array.isArray(processesValue) || processesValue.length > 64)
         return undefined;
@@ -131,6 +144,42 @@ export function parsePersistedSupervisedLifecycle(value) {
             continuationCount,
         },
         ...(blocking ? { blocking } : {}),
+        ...(supervision ? { supervision } : {}),
+        ...(checkpoints ? { checkpoints } : {}),
+    };
+}
+function parseCheckpoints(value) {
+    const planIdentity = boundedText(value.planIdentity);
+    if (value.protocolVersion !== 1 || !planIdentity)
+        return undefined;
+    if (!Array.isArray(value.reportedL1Ids) || value.reportedL1Ids.length > 128)
+        return undefined;
+    const reportedL1Ids = value.reportedL1Ids
+        .map((id) => boundedText(id))
+        .filter(Boolean);
+    if (reportedL1Ids.length !== value.reportedL1Ids.length ||
+        new Set(reportedL1Ids).size !== reportedL1Ids.length)
+        return undefined;
+    if (!Array.isArray(value.acceptedKeys) || value.acceptedKeys.length > 128)
+        return undefined;
+    const acceptedKeys = value.acceptedKeys
+        .map((key) => boundedText(key))
+        .filter(Boolean);
+    if (acceptedKeys.length !== value.acceptedKeys.length ||
+        new Set(acceptedKeys).size !== acceptedKeys.length)
+        return undefined;
+    const pendingTurnId = value.pendingTurnId === null ? null : boundedText(value.pendingTurnId);
+    if (pendingTurnId === undefined)
+        return undefined;
+    if (typeof value.terminalReviewAccepted !== 'boolean')
+        return undefined;
+    return {
+        protocolVersion: 1,
+        planIdentity,
+        reportedL1Ids,
+        acceptedKeys,
+        pendingTurnId,
+        terminalReviewAccepted: value.terminalReviewAccepted,
     };
 }
 export function classifyExecutorOutcome(input) {

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/org-plan-checkpoint/application/validate.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function validOrgPlanCheckpoint(input) {
+    const { checkpoint, plan, planIdentity, rootOwned } = input;
+    if (!rootOwned || checkpoint.planIdentity !== planIdentity)
+        return false;
+    if (checkpoint.kind === 'terminalReviewAccepted')
+        return plan.steps.every((step) => step.state === 'DONE' && step.reviewStatus === 'REVIEWED');
+    const l1 = plan.steps.find((step) => step.id === checkpoint.l1Id);
+    if (!l1)
+        return false;
+    const position = `L${plan.steps.indexOf(l1) + 1}`;
+    return (checkpoint.position === position &&
+        l1.state === 'DONE' &&
+        l1.reviewStatus === 'REVIEWED' &&
+        !input.hasActiveL1Writer(position));
+}

package/dist/server/server/features/sessions/get-history/endpoint.js

@@ -83,6 +83,7 @@ function toActivityHistory(events, throughSequence) {
             label: payload.label,
             detail: payload.detail,
             ...(typeof payload.turnId === 'string' ? { turnId: payload.turnId } : {}),
+            ...(typeof payload.actorTurnId === 'string' ? { actorTurnId: payload.actorTurnId } : {}),
             ...(Number.isFinite(occurredAt) ? { occurredAt } : {}),
             ...(changes.length ? { changes } : {}),
         });

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

@@ -11,5 +11,7 @@ export function isInteractionKind(value) {
         'userInput',
         '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')
+    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/normalizer.js

@@ -5,11 +5,13 @@
  */
 import { countDiffLines } from '../../../shared/contracts/file-change.js';
 import { relative } from 'node:path';
-export function normalizeCodexNotification(sessionId, sequence, occurredAt, notification, workspacePath, activeTurnId) {
+export function normalizeCodexNotification(sessionId, sequence, occurredAt, notification, workspacePath, activeTurnId, origin = { kind: 'root' }) {
     const decoded = decodeNotification(notification);
     if (!decoded)
         return null;
-    if (decoded.method === 'item/agentMessage/delta')
+    if (decoded.method === 'item/agentMessage/delta') {
+        if (origin.kind !== 'root')
+            return null;
         return {
             sessionId,
             sequence,
@@ -18,12 +20,11 @@ export function normalizeCodexNotification(sessionId, sequence, occurredAt, noti
             payload: {
                 text: decoded.params.delta,
                 ...(decoded.params.itemId ? { itemId: decoded.params.itemId } : {}),
-                ...((decoded.params.turnId ?? activeTurnId)
-                    ? { turnId: decoded.params.turnId ?? activeTurnId }
-                    : {}),
+                ...(activeTurnId ? { turnId: activeTurnId } : {}),
             },
         };
-    if (decoded.method === 'turn/completed')
+    }
+    if (decoded.method === 'turn/completed' && origin.kind === 'root')
         return {
             sessionId,
             sequence,
@@ -37,13 +38,15 @@ export function normalizeCodexNotification(sessionId, sequence, occurredAt, noti
             type: 'fileChange',
             status: 'in_progress',
             changes: decoded.params.changes,
-        }, workspacePath, activeTurnId, decoded.params.turnId);
+        }, workspacePath, activeTurnId, decoded.params.turnId, origin);
         return activity
             ? { sessionId, sequence, occurredAt, type: 'activity.updated', payload: activity }
             : null;
     }
     if (decoded.method === 'item/started' || decoded.method === 'item/completed') {
-        const message = safeAgentMessage(decoded.params.item, activeTurnId, decoded.params.turnId);
+        const message = origin.kind === 'root'
+            ? safeAgentMessage(decoded.params.item, activeTurnId, decoded.params.turnId)
+            : null;
         if (message)
             return {
                 sessionId,
@@ -52,7 +55,7 @@ export function normalizeCodexNotification(sessionId, sequence, occurredAt, noti
                 type: decoded.method === 'item/started' ? 'agentMessageStarted' : 'agentMessageCompleted',
                 payload: message,
             };
-        const activity = safeActivity(decoded.params.item, workspacePath, activeTurnId, decoded.params.turnId);
+        const activity = safeActivity(decoded.params.item, workspacePath, activeTurnId, decoded.params.turnId, origin);
         if (activity)
             return { sessionId, sequence, occurredAt, type: 'activity.updated', payload: activity };
     }
@@ -120,19 +123,21 @@ export function decodeNotification(input) {
     }
     return null;
 }
-function safeActivity(item, workspacePath, activeTurnId, notificationTurnId) {
+function safeActivity(item, workspacePath, activeTurnId, notificationTurnId, origin = { kind: 'root' }) {
     if (!item || typeof item !== 'object')
         return null;
     const value = item;
     if (typeof value.id !== 'string' || typeof value.type !== 'string')
         return null;
-    const owner = notificationTurnId
-        ? { turnId: notificationTurnId }
-        : safeId(value.turnId)
-            ? { turnId: value.turnId }
-            : activeTurnId
-                ? { turnId: activeTurnId }
-                : {};
+    const owner = origin.kind === 'child' && activeTurnId
+        ? { turnId: activeTurnId, actorTurnId: origin.physicalTurnId }
+        : notificationTurnId && origin.kind === 'root'
+            ? { turnId: notificationTurnId }
+            : safeId(value.turnId)
+                ? { turnId: value.turnId }
+                : activeTurnId && origin.kind === 'root'
+                    ? { turnId: activeTurnId }
+                    : {};
     const status = typeof value.status === 'string' ? ` · ${value.status}` : '';
     if (value.type === 'commandExecution' && typeof value.command === 'string')
         return { id: value.id, label: `Command${status}`, detail: value.command, ...owner };

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

@@ -5,6 +5,8 @@
  */
 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;
@@ -19,6 +21,18 @@ export function toPendingInteraction(input) {
                 ? { requestId: String(input.id), kind: 'orgPlanAttention', payload: attention }
                 : null;
         }
+        if (input.params.tool === GESTALT_ORG_PLAN_CHECKPOINT_TOOL_NAME) {
+            const checkpoint = parseOrgPlanCheckpoint(input.params.arguments);
+            return checkpoint
+                ? { 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 = {
@@ -38,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

@@ -9,6 +9,8 @@ import { createPlanMeasurementSnapshot, } from '../../features/plans/application
 import { canRebindMissingRollout, rebindMissingRollout, } from '../../features/sessions/restore-session/use-case.js';
 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';
@@ -32,6 +34,8 @@ class SessionResource {
     spawnedAgentModels = new Map();
     attemptedAgentModelRecovery = new Set();
     ownedChildProcesses = new Map();
+    turnThreads = new Map();
+    childThreads = new Set();
     constructor(sessionId, process, planStatusLease, planMeasurementToken, unregister, onDisposed) {
         this.sessionId = sessionId;
         this.process = process;
@@ -561,7 +565,12 @@ export class CodexSessionRuntime {
                         ? { approvalPolicy: session.executionPolicy.approvalPolicy }
                         : {}),
                     ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),
-                    dynamicTools: [gestaltQuizDynamicTool, gestaltOrgPlanAttentionDynamicTool],
+                    dynamicTools: [
+                        gestaltQuizDynamicTool,
+                        gestaltOrgPlanAttentionDynamicTool,
+                        gestaltOrgPlanCheckpointDynamicTool,
+                        gestaltAutopilotWaitLeaseDynamicTool,
+                    ],
                 });
                 result = {
                     session: RelaySession.rehydrate(session).restore(now).supportsAttentionTool(now).snapshot,
@@ -629,7 +638,8 @@ export class CodexSessionRuntime {
             resource.pendingRequests.set(requestId, { resolve, reject });
             let accepted = false;
             try {
-                accepted = this.onServerRequest?.(resource.sessionId, request) === true;
+                accepted =
+                    this.onServerRequest?.(resource.sessionId, request, this.resolveNotificationOrigin(resource, request)) === true;
             }
             catch {
                 // Publication failures are protocol failures, not permission to retain
@@ -646,7 +656,12 @@ export class CodexSessionRuntime {
         return {
             cwd: session.workspacePath,
             approvalPolicy: session.executionPolicy?.approvalPolicy ?? 'on-request',
-            dynamicTools: [gestaltQuizDynamicTool, gestaltOrgPlanAttentionDynamicTool],
+            dynamicTools: [
+                gestaltQuizDynamicTool,
+                gestaltOrgPlanAttentionDynamicTool,
+                gestaltOrgPlanCheckpointDynamicTool,
+                gestaltAutopilotWaitLeaseDynamicTool,
+            ],
             ...(session.model ? { model: session.model } : {}),
             ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),
         };
@@ -709,7 +724,7 @@ export class CodexSessionRuntime {
                     // The notification callback reconciles the durable interaction record.
                     pending?.reject(new Error('CODEX_SERVER_REQUEST_CLEARED'));
                 }
-                this.onNotification?.(session.id, notification);
+                this.onNotification?.(session.id, notification, this.resolveNotificationOrigin(resource, notification));
             });
             const requestUnsubscribe = process.rpc.onServerRequest((request) => this.holdServerRequest(resource, request));
             if (!resource.active) {
@@ -726,6 +741,48 @@ export class CodexSessionRuntime {
             throw error;
         }
     }
+    resolveNotificationOrigin(resource, notification) {
+        const params = asRecord(notification.params);
+        if (!params)
+            return { kind: 'unknown' };
+        const item = asRecord(params.item);
+        if (item?.type === 'collabAgentToolCall' || item?.type === 'collabToolCall') {
+            for (const value of [item.receiverThreadId, item.newThreadId])
+                if (boundedString(value, 256) && resource.childThreads.size < 64)
+                    resource.childThreads.add(boundedString(value, 256));
+            if (Array.isArray(item.receiverThreadIds))
+                for (const value of item.receiverThreadIds)
+                    if (boundedString(value, 256) && resource.childThreads.size < 64)
+                        resource.childThreads.add(boundedString(value, 256));
+            const states = asRecord(item.agentsStates);
+            if (states)
+                for (const childId of Object.keys(states))
+                    if (boundedString(childId, 256) && resource.childThreads.size < 64)
+                        resource.childThreads.add(childId);
+        }
+        const turn = asRecord(params.turn);
+        const turnId = boundedString(params.turnId, 256) ??
+            boundedString(turn?.id, 256) ??
+            boundedString(item?.turnId, 256);
+        if (notification.method === 'turn/started' && turnId && boundedString(params.threadId, 256)) {
+            if (resource.turnThreads.has(turnId) || resource.turnThreads.size < 256)
+                resource.turnThreads.set(turnId, boundedString(params.threadId, 256));
+        }
+        const resolvedThreadId = boundedString(params.threadId, 256) ??
+            (turnId ? resource.turnThreads.get(turnId) : undefined);
+        const origin = {
+            kind: resolvedThreadId && resolvedThreadId === resource.threadId
+                ? 'root'
+                : resolvedThreadId && resource.childThreads.has(resolvedThreadId)
+                    ? 'child'
+                    : 'unknown',
+            ...(turnId ? { physicalTurnId: turnId } : {}),
+            ...(resolvedThreadId ? { physicalThreadId: resolvedThreadId } : {}),
+        };
+        if (notification.method === 'turn/completed' && turnId)
+            resource.turnThreads.delete(turnId);
+        return origin;
+    }
 }
 function isMethodNotFound(error) {
     return Boolean(error && typeof error === 'object' && error.code === -32601);

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,8 +65,13 @@ 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
-            ? JSON.stringify({ executor: state.executor, blocking: state.blocking })
+            .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);
     }
     findControl(sessionId, controlId) {