gestalt-mobile 0.28.0 → 0.29.0

package/dist/client/index.html

@@ -16,8 +16,8 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-Bz23puhw.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B7x1bL59.css">
+    <script type="module" crossorigin src="/assets/index-CRULnRRB.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BtlbAtm9.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/composition.js

@@ -36,6 +36,8 @@ import { RelaySession, } from './features/sessions/model/relay-session.js';
 import { AgentActivityRegistry } from './features/agent-activity/registry.js';
 import { decodeAgentActivityFacts } from './platform/codex/activity-facts.js';
 import { resolvedServerRequestId, toPendingInteraction } from './platform/codex/server-request.js';
+import { parseOrgPlanCheckpoint, toOrgPlanCheckpointToolResponse, } from '../shared/contracts/org-plan-checkpoint.js';
+import { validOrgPlanCheckpoint } from './features/org-plan-checkpoint/application/validate.js';
 import { isValidInteractionResponse, isValidQuizInteractionResponse, } from './features/sessions/interaction/response-validator.js';
 import { promoteRecentThread } from './features/sessions/promote-recent-thread/use-case.js';
 import { FilesystemSkillProfileStore } from './platform/skills/filesystem-skill-profile-store.js';
@@ -379,7 +381,7 @@ export async function composeRelayApp(options) {
         autopilot.planStatusChanged(sessionId);
     };
     runtime = options.startAppServers
-        ? new CodexSessionRuntime(options.launchAppServer ?? launchCodexAppServer, undefined, (sessionId, notification) => {
+        ? new CodexSessionRuntime(options.launchAppServer ?? launchCodexAppServer, undefined, (sessionId, notification, origin) => {
             const occurredAt = new Date().toISOString();
             for (const activityFact of decodeAgentActivityFacts(sessionId, occurredAt, notification))
                 activity.observe(activityFact);
@@ -395,7 +397,18 @@ export async function composeRelayApp(options) {
                 }
             }
             const currentSession = sessions.find(sessionId);
-            const normalized = normalizeCodexNotification(sessionId, 0, occurredAt, notification, currentSession?.workspacePath, currentSession?.activeTurnId);
+            const completionTurnId = notification.method === 'turn/completed' &&
+                notification.params &&
+                typeof notification.params === 'object' &&
+                typeof notification.params.turn?.id === 'string'
+                ? notification.params.turn.id
+                : undefined;
+            // A completion with no thread identity is only root-owned when it exactly
+            // matches the durable active root turn; unknown child turns never fall back.
+            const resolvedOrigin = origin.kind === 'unknown' && completionTurnId === currentSession?.activeTurnId
+                ? { ...origin, kind: 'root' }
+                : origin;
+            const normalized = normalizeCodexNotification(sessionId, 0, occurredAt, notification, currentSession?.workspacePath, currentSession?.activeTurnId, resolvedOrigin);
             if (!normalized)
                 return;
             let completedSession;
@@ -412,11 +425,35 @@ export async function composeRelayApp(options) {
             events.publish(journal.append(sessionId, normalized.type, normalized.payload, normalized.occurredAt));
             if (completedSession)
                 events.publish(journal.append(sessionId, 'session.updated', completedSession, occurredAt));
-        }, (sessionId, request) => {
+        }, (sessionId, request, origin) => {
             const rawInteraction = toPendingInteraction(request);
             const session = withPendingInteractions(sessions.find(sessionId));
             if (!rawInteraction || !session)
                 return false;
+            if (rawInteraction.kind === 'orgPlanCheckpoint') {
+                const checkpoint = parseOrgPlanCheckpoint(rawInteraction.payload);
+                const retained = supervisedPlans.find(sessionId);
+                const identity = supervisedPlans.identity(sessionId);
+                const rootOwned = origin.kind === 'root' && origin.physicalTurnId === session.activeTurnId;
+                if (!checkpoint ||
+                    !retained ||
+                    !identity ||
+                    checkpoint.planIdentity !== identity ||
+                    !rootOwned)
+                    return false;
+                const valid = validOrgPlanCheckpoint({
+                    checkpoint,
+                    plan: retained,
+                    planIdentity: identity,
+                    rootOwned,
+                    hasActiveL1Writer: (position) => hasActiveL1Writer(activity.snapshot(sessionId, new Date().toISOString()), position),
+                });
+                if (!valid)
+                    return false;
+                if (!autopilot.checkpointAccepted(sessionId, checkpoint, session.activeTurnId, new Date().toISOString()))
+                    return false;
+                return (runtime?.resolveServerRequest(sessionId, rawInteraction.requestId, toOrgPlanCheckpointToolResponse()) === true);
+            }
             const interaction = {
                 ...rawInteraction,
                 turnId: session.activeTurnId,
@@ -959,3 +996,7 @@ function resolveStateDatabasePath(root, stateHome) {
     const legacyPath = legacyRelayStatePath(root, stateHome);
     return existsSync(legacyPath) ? legacyPath : currentPath;
 }
+function hasActiveL1Writer(snapshot, position) {
+    return snapshot.subagents.some((child) => child.canonicalPosition === position &&
+        ['working', 'awaitingAgent', 'awaitingHuman'].includes(child.state));
+}

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

@@ -59,8 +59,17 @@ export function decideAutopilot(input) {
         return { kind: 'disable', reason: 'manualDisabled' };
     if (!plan)
         return { kind: 'disable', reason: 'planRequired' };
-    if (executionComplete(plan))
+    if (executionComplete(plan)) {
+        // Checkpoint-aware sessions deliberately reserve a later root turn for
+        // terminal whole-branch review.  The Org projection remains authoritative:
+        // this only controls whether a completed L1 may end the current report turn.
+        if (state.checkpoints?.protocolVersion === 1 && !state.checkpoints.terminalReviewAccepted)
+            return {
+                kind: 'scheduleContinuation',
+                at: new Date(Date.parse(now) + policy.backoffMs(state.consecutiveNoProgress)).toISOString(),
+            };
         return { kind: 'complete' };
+    }
     // Quiz, approval, and other held requests are ordinary session work. Only a
     // validated Org attention record may turn an incomplete plan into a human stop.
     if (hasPendingInteraction)

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

@@ -3,6 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { createHash } from 'node:crypto';
 import { autopilotSnapshot, disabledAutopilot, } from '../domain/autopilot-session.js';
 import { classifyExecutorOutcome, decideSupervisedLifecycle, executorIdentity, validStructuredBlock, } from '../domain/supervised-lifecycle.js';
 import { classifyAgentActivity, decideAutopilot, executionComplete, } from './policy.js';
@@ -294,11 +295,31 @@ export class AutopilotCoordinator {
             state?.stopReason === 'planRemoved' ||
             state?.stopReason === 'planReplaced' ||
             state?.stopReason === 'sessionEnded';
+        const checkpointBoundary = Boolean(state?.checkpoints?.pendingTurnId &&
+            state.checkpoints.planIdentity === this.deps.plan(sessionId)?.identity);
         const finalAllowed = !state ||
             !plan ||
             explicitlyStopped ||
-            executionComplete(plan) ||
+            checkpointBoundary ||
+            (!state.checkpoints && executionComplete(plan)) ||
             validStructuredBlock(state.blocking);
+        if (checkpointBoundary && state?.checkpoints) {
+            const occurredAt = this.deps.now();
+            this.persist({
+                ...state,
+                checkpoints: { ...state.checkpoints, pendingTurnId: null },
+                updatedAt: occurredAt,
+            }, undefined, [
+                {
+                    sessionId,
+                    type: state.checkpoints.terminalReviewAccepted
+                        ? 'org-plan.terminal-review-reported'
+                        : 'org-plan.milestone-reported',
+                    payload: { turnId: state.checkpoints.pendingTurnId },
+                    occurredAt,
+                },
+            ]);
+        }
         if (!finalAllowed) {
             const occurredAt = this.deps.now();
             this.commit({
@@ -316,6 +337,46 @@ export class AutopilotCoordinator {
         this.activitySettled(sessionId, 'rootFinalAttempt');
         return finalAllowed;
     }
+    /** Records an already validated root-only checkpoint; it never changes Org state. */
+    checkpointAccepted(sessionId, checkpoint, turnId, occurredAt) {
+        const prior = this.deps.store.find(sessionId);
+        const retained = this.deps.plan(sessionId);
+        if (!prior || !retained || !turnId || checkpoint.planIdentity !== retained.identity)
+            return false;
+        const previous = prior.checkpoints;
+        if (previous && previous.planIdentity !== retained.identity)
+            return false;
+        const reported = previous?.reportedL1Ids ?? [];
+        const key = createHash('sha256').update(JSON.stringify(checkpoint)).digest('hex');
+        const acceptedKeys = previous?.acceptedKeys ?? [];
+        if (acceptedKeys.includes(key))
+            return true;
+        if (checkpoint.kind === 'l1Accepted' && reported.includes(checkpoint.l1Id))
+            return false;
+        if (checkpoint.kind === 'terminalReviewAccepted' && previous?.terminalReviewAccepted)
+            return false;
+        const checkpoints = {
+            protocolVersion: 1,
+            planIdentity: retained.identity,
+            reportedL1Ids: checkpoint.kind === 'l1Accepted' ? [...reported, checkpoint.l1Id] : reported,
+            acceptedKeys: [...acceptedKeys, key],
+            pendingTurnId: turnId,
+            terminalReviewAccepted: checkpoint.kind === 'terminalReviewAccepted' || previous?.terminalReviewAccepted === true,
+        };
+        this.persist({ ...prior, checkpoints, updatedAt: occurredAt }, undefined, [
+            {
+                sessionId,
+                type: checkpoint.kind === 'l1Accepted'
+                    ? 'org-plan.milestone-checkpointed'
+                    : 'org-plan.terminal-review-checkpointed',
+                payload: checkpoint.kind === 'l1Accepted'
+                    ? { l1Id: checkpoint.l1Id, position: checkpoint.position, turnId }
+                    : { turnId },
+                occurredAt,
+            },
+        ]);
+        return true;
+    }
     /** Handles only plan lifecycle safety; ordinary plan mutations are ignored. */
     planStatusChanged(sessionId) {
         const prior = this.deps.store.find(sessionId);

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

@@ -24,8 +24,12 @@ export function parsePersistedSupervisedLifecycle(value) {
     if (blockingValue && !blocking)
         return undefined;
     const executorValue = record(root.executor);
+    const checkpointsValue = record(root.checkpoints);
+    const checkpoints = checkpointsValue ? parseCheckpoints(checkpointsValue) : undefined;
+    if (checkpointsValue && !checkpoints)
+        return undefined;
     if (!executorValue)
-        return blocking ? { blocking } : {};
+        return { ...(blocking ? { blocking } : {}), ...(checkpoints ? { checkpoints } : {}) };
     const processesValue = executorValue.ownedProcesses;
     if (!Array.isArray(processesValue) || processesValue.length > 64)
         return undefined;
@@ -131,6 +135,41 @@ export function parsePersistedSupervisedLifecycle(value) {
             continuationCount,
         },
         ...(blocking ? { blocking } : {}),
+        ...(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/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,6 @@ export function isInteractionKind(value) {
         'userInput',
         'quiz',
         'orgPlanAttention',
+        'orgPlanCheckpoint',
     ].includes(value);
 }

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

@@ -11,7 +11,7 @@ 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')
         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,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';
 export function toPendingInteraction(input) {
     if (!Number.isSafeInteger(input.id) || !isRecord(input.params))
         return null;
@@ -19,6 +20,12 @@ 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;
+        }
         return null;
     }
     const kind = {

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

@@ -9,6 +9,7 @@ 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 { 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 +33,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 +564,11 @@ export class CodexSessionRuntime {
                         ? { approvalPolicy: session.executionPolicy.approvalPolicy }
                         : {}),
                     ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),
-                    dynamicTools: [gestaltQuizDynamicTool, gestaltOrgPlanAttentionDynamicTool],
+                    dynamicTools: [
+                        gestaltQuizDynamicTool,
+                        gestaltOrgPlanAttentionDynamicTool,
+                        gestaltOrgPlanCheckpointDynamicTool,
+                    ],
                 });
                 result = {
                     session: RelaySession.rehydrate(session).restore(now).supportsAttentionTool(now).snapshot,
@@ -629,7 +636,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 +654,11 @@ export class CodexSessionRuntime {
         return {
             cwd: session.workspacePath,
             approvalPolicy: session.executionPolicy?.approvalPolicy ?? 'on-request',
-            dynamicTools: [gestaltQuizDynamicTool, gestaltOrgPlanAttentionDynamicTool],
+            dynamicTools: [
+                gestaltQuizDynamicTool,
+                gestaltOrgPlanAttentionDynamicTool,
+                gestaltOrgPlanCheckpointDynamicTool,
+            ],
             ...(session.model ? { model: session.model } : {}),
             ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),
         };
@@ -709,7 +721,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 +738,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

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