maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -16,39 +16,33 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * SessionManager — the public Runtime API.
- *
- * Ties together:
- *   SessionStore (storage)           — SQLite persistence
- *   AgentBackend (AiSdkBackend etc) — SDK adapter
- *   ExecutionBoundary                — session sandbox authority
- *
- * `SessionStore` comes from `@maka/storage`; its public interface owns
- * persistence and same-session serialization semantics.
- */
 import { createHash } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
 import { messageContentsEqual, normalizeMessageContent } from '@maka/core/events';
+import { isCanonicalReadOnlyPermissionProfile } from '@maka/core/permission-profile';
 import { DEFAULT_TOOL_MODE } from '@maka/core/tool-mode';
 import { PLAN_USER_ABANDON_REASON, PLAN_USER_CANCEL_REASON, PlanConflictError, } from '@maka/core/plan';
 import { DEFAULT_SESSION_NAME } from '@maka/core/session-name';
 import { DEEP_RESEARCH_SESSION_LABEL, isDeepResearchSession } from '@maka/core/deep-research';
-import { SIDE_CONVERSATION_SESSION_LABEL } from '@maka/core/side-conversation';
-import { SUBAGENT_SESSION_RUNTIME_SCHEMA_VERSION, SUBAGENT_SESSION_SPAWN_SCHEMA_VERSION, childSessionsForParent, deriveTurnRecords, subagentSessionRuntimeSummary, } from '@maka/core/session';
+import { SUBAGENT_SESSION_RUNTIME_SCHEMA_VERSION, SUBAGENT_SESSION_SPAWN_SCHEMA_VERSION, childSessionsForParent, subagentSessionRuntimeSummary, } from '@maka/core/session';
 import { decodeAgentGraphIntentClaim } from '@maka/core/agent-graph-control';
 import { executionBoundaryContains } from '@maka/core/sandbox-boundary';
 import { failureClassFromCompleteStopReason } from '@maka/core/events';
 import { isActiveShellRunStatus } from '@maka/core/shell-run';
-import { isSessionInlineRun } from '@maka/core/agent-run';
 import { isTerminalRuntimeEvent } from '@maka/core/runtime-event';
+import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
+import { readLogicalRuntimeExecutionForRun } from '@maka/core/runtime-logical-execution';
+import { buildInvocationOpenedEvent, isSessionInlineInvocation, runtimeInvocationOutcome, } from '@maka/core/runtime-invocation';
+import { isArtifactChildResultOutput } from '@maka/core/artifacts';
+import { invocationMatchesClaimTarget } from '@maka/core/runtime-boundary';
+import { readRunInvocation, } from '@maka/core/runtime-event-store';
 import { AGENT_GRAPH_OPERATOR_PROVISION_SCHEMA_VERSION } from '@maka/core/agent-graph-topology';
+import { runtimeInvocationFailureClass, } from './runtime-event-read-model.js';
 import { RuntimeReadModel, RuntimeReadModelError, } from './runtime-read-model.js';
 import { inspectAgentRunReadModel } from './agent-run-inspect.js';
-import { cloneConversationRuntimeLedger as cloneConversationLedger, createConversationCopySlice, prepareConversationRuntimeLedgerCopy, } from './conversation-copy.js';
-import { firstRuntimeRepairRunId, RuntimeLedgerRepair } from './runtime-ledger-repair.js';
-import { buildRecoveredTerminalRuntimeEvent, classifyTerminalRuntimeLedger, commitTerminalRunWithRuntimeFact, effectiveRunHeaderFromTerminalFact, terminalRunStatusFromRuntimeEvent, } from './terminal-run-commit.js';
+import { isTranscriptLedgerInvocation, RuntimeLedgerRepair } from './runtime-ledger-repair.js';
+import { buildRecoveredTerminalRuntimeEvent, classifyTerminalRuntimeLedger, commitTerminalRunWithRuntimeFact, terminalRunStatusFromRuntimeEvent, } from './terminal-run-commit.js';
 import { readLatestContextDiagnostics } from './context-diagnostics.js';
 import { attributeSandboxBoundaryRestartClosure, classifyAgentRunRecovery, } from './agent-run-recovery.js';
 import { buildInterruptedCodeModeOutcomeCommits } from './recovery-resolver.js';
@@ -57,7 +51,7 @@ import { RuntimeInteractionInvariantError, } from './interaction-authority.js';
 import { RuntimeKernel, SessionQuiescentMutationBusyError, } from './runtime-kernel.js';
 import { fingerprintAgentGraphRunnableIntent } from './stream-graph-admission.js';
 import { projectAgentGraphRecords } from './stream-graph-projection.js';
-import { buildStatusPatch, buildTurnStateMessage, turnHasRetainedOutput as messagesHaveRetainedOutput, } from './session-projection-helpers.js';
+import { buildStatusPatch } from './session-projection-helpers.js';
 import { assertAgentDefinitionRunnable, buildToolsForAgentDefinition, listBuiltinAgentDefinitions, requireBuiltinAgentDefinition, requireBuiltinAgentDefinitionByProfile, AGENT_WORKSPACE_WORKTREE, } from './agent-catalog.js';
 import { stableHash } from './request-shape.js';
 import { RuntimeContinuationPlanner, } from './runtime-resume.js';
@@ -82,8 +76,8 @@ function runtimeCommitSinkFromEventStore(store) {
         ? candidate
         : undefined;
 }
+export { normalizeStopSessionSource, workHubDirectStopAbortSource, } from './session-projection-helpers.js';
 const CHILD_AGENT_SUMMARY_MAX_CHARS = 4_000;
-const MAX_RUNTIME_LEDGER_REPAIR_ATTEMPTS = 8;
 export class SessionConfigurationTransitionError extends Error {
     code;
     name = 'SessionConfigurationTransitionError';
@@ -111,18 +105,21 @@ export class RuntimeRegenerateTurnError extends Error {
     }
 }
 export class BackendRegistry {
-    factories = new Map();
-    register(kind, factory) {
-        this.factories.set(kind, factory);
+    registrations = new Map();
+    register(kind, registration) {
+        this.registrations.set(kind, registration);
     }
-    async build(kind, ctx) {
-        const f = this.factories.get(kind);
-        if (!f)
+    async prepare(kind, ctx) {
+        const registration = this.registrations.get(kind);
+        if (!registration)
             throw new Error(`No backend factory registered for kind="${kind}"`);
-        return await f(ctx);
+        if (typeof registration === 'function') {
+            return { build: registration };
+        }
+        return await registration.prepare(ctx);
     }
     has(kind) {
-        return this.factories.has(kind);
+        return this.registrations.has(kind);
     }
 }
 export class SessionManager {
@@ -147,21 +144,11 @@ export class SessionManager {
             deps.runtimeCommitSink ?? runtimeCommitSinkFromEventStore(deps.runtimeEventStore);
         if (deps.runStore && deps.runtimeEventStore) {
             this.runtimeLedgerRepair = new RuntimeLedgerRepair({
-                runStore: deps.runStore,
                 runtimeEventStore: deps.runtimeEventStore,
-                readMessages: (sessionId) => deps.store.readMessages(sessionId),
-                appendMessage: (sessionId, message) => deps.store.appendMessage(sessionId, message),
-                appendTurnState: (sessionId, turnId, status, lineage, options) => this.appendTurnState(sessionId, turnId, status, lineage, options),
-                newId: deps.newId,
-                now: deps.now,
+                readMessagesAfter: (sessionId, request) => deps.store.readMessagesAfter(sessionId, request),
             });
         }
-        this.runtimeKernel =
-            deps.runtimeKernel ??
-                new RuntimeKernel({
-                    ...deps,
-                    repairRunRuntimeLedger: (sessionId, runId) => this.repairMissingTerminalFactOnce(sessionId, runId),
-                });
+        this.runtimeKernel = deps.runtimeKernel ?? new RuntimeKernel({ ...deps });
     }
     // --------------------------------------------------------------------------
     // Session lifecycle
@@ -254,21 +241,42 @@ export class SessionManager {
         const list = this.deps.listArtifactsForTurn;
         if (!list)
             return [];
-        const artifacts = await list(sessionId, turnId);
-        if (!isTerminalRunStatus(status) || !this.hasWorktreePatchWriteBack())
-            return artifacts;
-        const header = await this.deps.store.readHeader(sessionId);
-        if (!header.subagentWorkspace)
-            return artifacts;
-        const existing = artifacts.find((artifact) => artifact.source === 'subagent_writeback');
-        if (existing)
-            return artifacts;
-        await this.finalizeChildWorkspacePatches(sessionId);
-        const finalized = await list(sessionId, turnId);
-        if (!finalized.some((artifact) => artifact.source === 'subagent_writeback')) {
-            throw new Error(`Child Session ${sessionId} cannot reconstruct the historical workspace patch for Turn ${turnId}`);
-        }
-        return finalized;
+        let artifacts = await list(sessionId, turnId);
+        if (isTerminalRunStatus(status) && this.hasWorktreePatchWriteBack()) {
+            const header = await this.deps.store.readHeader(sessionId);
+            if (header.subagentWorkspace &&
+                !artifacts.some((artifact) => artifact.source === 'subagent_writeback')) {
+                await this.finalizeChildWorkspacePatches(sessionId);
+                artifacts = await list(sessionId, turnId);
+                if (!artifacts.some((artifact) => artifact.source === 'subagent_writeback')) {
+                    throw new Error(`Child Session ${sessionId} cannot reconstruct the historical workspace patch for Turn ${turnId}`);
+                }
+            }
+        }
+        return artifacts.filter(isArtifactChildResultOutput);
+    }
+    /**
+     * The Session's invocations, enumerated from the events that define them.
+     *
+     * There is no run table to consult: an invocation exists because its opening
+     * fact does, and it has ended because its terminal event does.
+     */
+    async listInvocations(sessionId) {
+        const store = this.deps.runtimeEventStore;
+        if (!store)
+            return [];
+        return store.listSessionInvocations(sessionId);
+    }
+    /** One invocation by run id. Absent means no opening fact ever named it. */
+    async readInvocation(sessionId, runId) {
+        const store = this.deps.runtimeEventStore;
+        const invocation = store ? await readRunInvocation(store, sessionId, runId) : undefined;
+        if (!invocation) {
+            const error = new Error(`AgentRun ${runId} not found`);
+            error.code = 'ENOENT';
+            throw error;
+        }
+        return invocation;
     }
     /** Publish the recoverable write-back owed by the latest terminal worktree child Run. */
     async finalizeChildWorkspacePatches(sessionId) {
@@ -278,12 +286,10 @@ export class SessionManager {
         const binding = header.subagentWorkspace;
         if (!binding)
             return;
-        const latest = (await this.deps.runStore.listSessionRuns(sessionId))
-            .filter(isSessionInlineRun)
-            .sort((left, right) => right.createdAt - left.createdAt || right.runId.localeCompare(left.runId))[0];
+        const latest = latestInvocation((await this.listInvocations(sessionId)).filter((run) => isSessionInlineInvocation(run.opening)));
         if (!latest)
             return;
-        if (!isTerminalRunStatus(latest.status)) {
+        if (!latest.terminalEvent) {
             throw new Error(`Child Session ${sessionId} cannot finalize its workspace while Run ${latest.runId} is nonterminal`);
         }
         const artifacts = await this.deps.listArtifactsForTurn(sessionId, latest.turnId);
@@ -317,7 +323,17 @@ export class SessionManager {
     }
     async transitionSessionConfiguration(sessionId, input) {
         const store = this.requireSessionConfigurationStore();
-        const next = await this.commitExecutionResourceTransition(sessionId, input.configuration.permissionMode, async () => {
+        const observed = await store.readHeaderRecordSnapshot(sessionId);
+        if (observed.revision !== input.expectedRevision) {
+            throw new SessionConfigurationRevisionConflictError(input.expectedRevision, observed.revision);
+        }
+        if (!input.clearConnectionBlock &&
+            sessionConfigurationMatches(observed.header, input.configuration)) {
+            return observed;
+        }
+        const permissionModeOnly = input.permissionModeOnly &&
+            sessionConfigurationMatchesExceptPermissionMode(observed.header, input.configuration);
+        const prepareCommit = async () => {
             const current = await store.readHeaderRecordSnapshot(sessionId);
             if (current.revision !== input.expectedRevision) {
                 throw new SessionConfigurationRevisionConflictError(input.expectedRevision, current.revision);
@@ -347,7 +363,10 @@ export class SessionManager {
                     }
                     : { kind: 'preserve' },
             });
-        });
+        };
+        const next = permissionModeOnly
+            ? await this.commitExecutionBoundaryTransition(sessionId, await this.deps.store.readExecutionBoundary(sessionId), input.configuration.permissionMode, prepareCommit)
+            : await this.commitExecutionResourceTransition(sessionId, input.configuration.permissionMode, prepareCommit);
         this.runtimeKernel.updateCachedHeader(sessionId, next.header);
         return next;
     }
@@ -408,7 +427,9 @@ export class SessionManager {
     async getContextDiagnostics(sessionId) {
         const runStore = this.deps.runStore;
         return runStore
-            ? readLatestContextDiagnostics(runStore, sessionId)
+            ? readLatestContextDiagnostics(runStore, sessionId, (await this.listInvocations(sessionId))
+                .filter((run) => isSessionInlineInvocation(run.opening))
+                .map((run) => run.runId))
             : { status: 'unavailable', reason: 'trace_unavailable' };
     }
     async listTurns(sessionId) {
@@ -520,9 +541,6 @@ export class SessionManager {
         const interrupted = (await listSessionsForRecovery(this.deps.store, policy)).filter((session) => !session.isArchived);
         const recovered = new Set();
         for (const session of interrupted) {
-            if (this.runtimeLedgerRepair) {
-                await recoverOr(policy, () => this.runtimeLedgerRepair.repairSteeringMessagesOnce(session.id), 0);
-            }
             if (this.runtimeKernel.hasActiveRuns(session.id))
                 continue;
             // Fail-closed: a request whose live owner died can never be answered, so
@@ -542,39 +560,15 @@ export class SessionManager {
                     }), undefined);
                 }
             }
-            if (this.deps.planStore) {
-                const planRecovery = await recoverOr(policy, () => this.deps.planStore.interruptActiveExecution(session.id, 'runtime_recovery'), null);
-                if (planRecovery)
-                    recovered.add(session.id);
-            }
             if (this.deps.shellRuns) {
                 const recoveredShellRuns = await recoverOr(policy, () => this.deps.shellRuns.recoverOrphanedSession(session.id), 0);
                 if (recoveredShellRuns > 0)
                     recovered.add(session.id);
             }
-            let messages = [];
-            let messagesReadable = true;
-            try {
-                messages =
-                    policy.kind === 'strict'
-                        ? await policy.stores.sessionStore.readMessagesForRecovery(session.id)
-                        : await this.deps.store.readMessages(session.id);
-            }
-            catch (error) {
-                if (policy.kind === 'strict')
-                    throw error;
-                messagesReadable = false;
-            }
-            if (session.revisionState === 'preparing' && messagesReadable) {
-                if (hasRevisionUserMessage(messages)) {
-                    await recoverOr(policy, () => this.commitRevisionVersion(session.id), undefined);
-                }
-                else {
-                    await recoverOr(policy, () => this.remove(session.id), undefined);
-                    recovered.add(session.id);
-                    continue;
-                }
-            }
+            // A revision copy still `preparing` is settled by the Host's revision
+            // coordinator, which reads the admission ledger and runs before this
+            // recovery. Deciding it a second time here — off a transcript scan, and
+            // ending in `remove()` — could only ever contradict it.
             let continuationClaimRecovered = false;
             const continuationAuthority = runtimeContinuationAuthority(this.deps.runtimeEventStore);
             if (this.deps.runStore && continuationAuthority) {
@@ -593,6 +587,24 @@ export class SessionManager {
                 if (continuationClaimRecovered)
                     recovered.add(session.id);
             }
+            if (this.deps.planStore) {
+                const preservesHandoff = await recoverOr(policy, async () => {
+                    if (!continuationAuthority)
+                        return false;
+                    const latest = latestInvocation((await this.listInvocations(session.id)).filter((run) => isSessionInlineInvocation(run.opening)));
+                    if (!latest)
+                        return false;
+                    // Only the current logical execution may preserve a session-owned Plan.
+                    // Read after claim repair: an abandoned successor now has a real failure.
+                    return Boolean((await readLogicalRuntimeExecutionForRun(continuationAuthority, latest))
+                        ?.pendingHandoff);
+                }, false);
+                if (!preservesHandoff) {
+                    const planRecovery = await recoverOr(policy, () => this.deps.planStore.interruptActiveExecution(session.id, 'runtime_recovery'), null);
+                    if (planRecovery)
+                        recovered.add(session.id);
+                }
+            }
             if (this.deps.runStore) {
                 const runRecovery = await recoverOr(policy, () => this.recoverAgentRunsFromLedger(session.id, policy), undefined);
                 if (runRecovery?.hasLedger) {
@@ -600,44 +612,23 @@ export class SessionManager {
                         await recoverOr(policy, () => this.updateStatus(session.id, 'active'), undefined);
                         recovered.add(session.id);
                     }
-                    else if (!messagesReadable &&
-                        (session.status === 'running' || session.status === 'waiting_for_user')) {
-                        await recoverOr(policy, () => this.updateStatus(session.id, 'active'), undefined);
-                        recovered.add(session.id);
-                    }
                     continue;
                 }
             }
-            if (!messagesReadable) {
-                if (session.status === 'running' || session.status === 'waiting_for_user') {
-                    // Recovery may run in BACKGROUND startup (#456): re-check for a
-                    // run the user started while this session's recovery was in
-                    // flight, so we never stomp a live run's status.
-                    if (this.runtimeKernel.hasActiveRuns(session.id))
-                        continue;
-                    await recoverOr(policy, () => this.updateStatus(session.id, 'active'), undefined);
-                    recovered.add(session.id);
-                }
-                continue;
-            }
-            const recoveries = interruptedTurnRecoveries(messages);
-            if (recoveries.length === 0)
-                continue;
-            for (const recovery of recoveries) {
-                await recoverOr(policy, () => this.appendTurnState(session.id, recovery.turnId, 'failed', recovery.lineage, {
-                    errorClass: recovery.errorClass,
-                }), undefined);
-            }
+            // No ledger and nothing to recover from it. A Session whose turns were
+            // interrupted before this process started is settled by the transcript
+            // importer, which converts a turn that never recorded how it ended into
+            // the failed terminal fact it actually was — this recovery has no second
+            // transcript to read that from.
             if (session.status === 'running' || session.status === 'waiting_for_user') {
-                // Same double-check as above: a message sent mid-recovery owns
-                // the session status now (its own transitions will settle it).
-                if (this.runtimeKernel.hasActiveRuns(session.id)) {
-                    recovered.add(session.id);
+                // Recovery may run in BACKGROUND startup (#456): re-check for a run the
+                // user started while this session's recovery was in flight, so we never
+                // stomp a live run's status.
+                if (this.runtimeKernel.hasActiveRuns(session.id))
                     continue;
-                }
                 await recoverOr(policy, () => this.updateStatus(session.id, 'active'), undefined);
+                recovered.add(session.id);
             }
-            recovered.add(session.id);
         }
         return [...recovered];
     }
@@ -674,6 +665,23 @@ export class SessionManager {
         return this.runtimeKernel.listActiveInteractions?.(sessionId) ?? [];
     }
     async setPermissionMode(sessionId, mode) {
+        const readHeaderRecordSnapshot = this.deps.store.readHeaderRecordSnapshot?.bind(this.deps.store);
+        if (!readHeaderRecordSnapshot || !this.deps.store.updateSessionConfiguration) {
+            // Temporary compatibility bridge for SessionStore embeddings that predate
+            // versioned configuration authority. A follow-up PR will shortly remove
+            // setPermissionMode and this redundant fallback after callers migrate.
+            return this.setPermissionModeWithLegacyStore(sessionId, mode);
+        }
+        const current = await readHeaderRecordSnapshot(sessionId);
+        const next = await this.transitionSessionConfiguration(sessionId, {
+            expectedRevision: current.revision,
+            clearConnectionBlock: false,
+            permissionModeOnly: true,
+            configuration: sessionConfigurationWithPermissionMode(current.header, mode),
+        });
+        return headerToSummary(next.header);
+    }
+    async setPermissionModeWithLegacyStore(sessionId, mode) {
         const previous = await this.deps.store.readHeader(sessionId);
         const boundary = await this.deps.store.readExecutionBoundary(sessionId);
         const leavingDeepResearch = isDeepResearchSession(previous.labels) && mode !== 'explore';
@@ -682,54 +690,75 @@ export class SessionManager {
             !leavingDeepResearch) {
             return headerToSummary(previous);
         }
-        if (this.runtimeKernel.hasActiveRuns(sessionId)) {
-            throw new Error('当前任务正在运行，等结束后再切换权限模式。');
-        }
-        if (previous.status === 'waiting_for_user') {
-            throw new Error('当前有工具调用正在等待确认，处理后再切换权限模式。');
-        }
         const labels = leavingDeepResearch
             ? previous.labels.filter((label) => label !== DEEP_RESEARCH_SESSION_LABEL)
             : previous.labels;
-        const nextKind = mode === 'bypass' ? 'bypass' : 'managed';
-        await this.commitExecutionBoundaryTransition(sessionId, boundary, nextKind, {
-            permissionMode: mode,
-            labels,
+        const kind = mode === 'bypass' ? 'bypass' : 'managed';
+        await this.commitExecutionBoundaryTransition(sessionId, boundary, mode, async () => {
+            const current = await this.deps.store.readHeader(sessionId);
+            if (current.status === 'waiting_for_user') {
+                throw new SessionConfigurationTransitionError('session_busy', 'Session has a pending Interaction');
+            }
+            return () => this.deps.store.setExecutionBoundaryKind(sessionId, kind, {
+                permissionMode: mode,
+                labels,
+            });
         });
         const next = await this.deps.store.readHeader(sessionId);
         this.runtimeKernel.updateCachedHeader(sessionId, next);
-        await this.deps.store
-            .appendMessage(sessionId, {
-            type: 'system_note',
-            id: this.deps.newId(),
-            ts: this.deps.now(),
-            kind: 'mode_change',
-            data: { from: previous.permissionMode, to: mode },
-        })
-            .catch(() => undefined);
         return headerToSummary(next);
     }
     async setExecutionBoundaryKind(sessionId, kind) {
-        if (this.runtimeKernel.hasActiveRuns(sessionId)) {
-            throw new Error('当前任务正在运行，等结束后再切换沙箱边界。');
-        }
+        const current = await this.deps.store.readExecutionBoundary(sessionId);
         const header = await this.deps.store.readHeader(sessionId);
+        // Managed includes Explore. Match Storage's default projection, then pass
+        // it explicitly so classification and commit describe the same transition.
+        const permissionMode = kind === 'bypass'
+            ? 'bypass'
+            : header.permissionMode === 'bypass'
+                ? 'ask'
+                : header.permissionMode;
+        const narrows = narrowsExecutionAuthority(current, permissionMode);
+        if (narrows && this.runtimeKernel.hasActiveRuns(sessionId)) {
+            throw new SessionConfigurationTransitionError('session_busy', 'Execution boundary cannot change while a Turn is running');
+        }
         if (header.status === 'waiting_for_user') {
-            throw new Error('当前有沙箱边界请求正在等待确认，处理后再切换。');
+            throw new SessionConfigurationTransitionError('session_busy', 'Execution boundary cannot change while an Interaction is pending');
         }
-        const current = await this.deps.store.readExecutionBoundary(sessionId);
-        const boundary = await this.commitExecutionBoundaryTransition(sessionId, current, kind);
+        const boundary = await this.commitExecutionBoundaryTransition(sessionId, current, permissionMode, async () => () => this.deps.store.setExecutionBoundaryKind(sessionId, kind, { permissionMode }));
         return boundary;
     }
-    async commitExecutionBoundaryTransition(sessionId, current, kind, projection) {
-        const nextPermissionMode = projection?.permissionMode ?? (kind === 'bypass' ? 'bypass' : 'ask');
-        return this.commitExecutionResourceTransition(sessionId, nextPermissionMode, async () => {
+    async commitExecutionBoundaryTransition(sessionId, current, nextPermissionMode, prepareCommit) {
+        const prepareBoundaryCommit = async () => {
             const latest = await this.deps.store.readExecutionBoundary(sessionId);
             if (latest.revision !== current.revision) {
                 throw new SessionConfigurationTransitionError('operation_conflict', 'Session execution boundary changed before the transition');
             }
-            return () => this.deps.store.setExecutionBoundaryKind(sessionId, kind, projection);
-        });
+            return prepareCommit();
+        };
+        if (!narrowsExecutionAuthority(current, nextPermissionMode)) {
+            // Widening needs no quiescence. Every consumer that froze the old, tighter
+            // boundary fails closed against a wider one, and a descendant's admission
+            // check only gets easier — so the grant is just written. Waiting for the
+            // Session to go idle is what let a running Turn, or a Goal's continuation
+            // holding a claim near-continuously, keep the user's own grant out.
+            if (!this.runtimeKernel.runSessionAdmissionMutation) {
+                throw new SessionConfigurationTransitionError('operation_unavailable', 'Session boundary changes require Runtime admission mutation authority');
+            }
+            // Serialize the revision check through commit without requiring an idle
+            // Turn. Otherwise two unversioned writes can both pass the check, then
+            // the later write can narrow the first grant using its stale classification.
+            const result = await this.runtimeKernel.runSessionAdmissionMutation([sessionId], async () => {
+                const commit = await prepareBoundaryCommit();
+                return commit();
+            });
+            // Not `disposeBackend`: disposing a live Turn's backend stops that Turn.
+            // Invalidation refreshes it now when the Session is idle, and otherwise
+            // defers to the next activation, which disposes before it starts.
+            await this.runtimeKernel.invalidateBackend(sessionId);
+            return result;
+        }
+        return this.commitExecutionResourceTransition(sessionId, nextPermissionMode, prepareBoundaryCommit);
     }
     async commitExecutionResourceTransition(sessionId, nextPermissionMode, prepareCommit) {
         const initialBoundary = await this.deps.store.readExecutionBoundary(sessionId);
@@ -812,6 +841,30 @@ export class SessionManager {
             throw error;
         }
     }
+    /**
+     * Fences a Session and every subagent Session under it for one operation.
+     *
+     * Preparing a bundle reads a Session's whole subtree, and a child holds the
+     * result of a tool call its parent made -- so a Turn starting anywhere in
+     * that tree while the read is in progress produces a bundle describing two
+     * moments. Refuses outright if any of them is already running.
+     */
+    async runSessionSubtreeQuiescentMutation(sessionId, operation) {
+        const descendants = await this.listLinkedDescendantSessionIds(sessionId);
+        const fenced = [sessionId, ...descendants];
+        return this.runSessionQuiescentMutation(fenced, async () => {
+            // Discovered again, now that the fence is held. The first walk happened
+            // before it, so a child created in that gap is in the subtree and NOT in
+            // what was fenced -- the operation would read it without it being held
+            // still. Refusing is the only honest answer: fencing it now would be
+            // fencing a set this call never admitted.
+            const current = await this.listLinkedDescendantSessionIds(sessionId);
+            if (current.length !== descendants.length || current.some((id) => !fenced.includes(id))) {
+                throw new SessionConfigurationTransitionError('operation_conflict', 'Session lineage changed while the subtree was being fenced');
+            }
+            return operation(fenced);
+        });
+    }
     async listLinkedDescendantSessionIds(sessionId) {
         const sessions = await this.deps.store.list();
         const childrenByParent = new Map();
@@ -851,29 +904,22 @@ export class SessionManager {
             throw new PlanConflictError('Linked child Sessions cannot enter Plan mode');
         }
         if (this.runtimeKernel.hasActiveRuns(sessionId)) {
-            throw new Error('当前任务正在运行，等结束后再切换协作模式。');
+            throw new SessionConfigurationTransitionError('session_busy', 'Collaboration mode cannot change while a Turn is running');
         }
         if (previous.status === 'waiting_for_user') {
-            throw new Error('当前有工具调用正在等待确认，处理后再切换协作模式。');
+            throw new SessionConfigurationTransitionError('session_busy', 'Collaboration mode cannot change while an Interaction is pending');
         }
         const planState = await this.requirePlanStore().readState(sessionId);
         if (mode === 'plan' && planState.activeExecutionId) {
-            throw new Error('当前计划仍在执行，结束或中断后才能切换到 Plan Mode。');
+            throw new SessionConfigurationTransitionError('session_busy', 'An active Plan execution prevents entering Plan mode');
         }
         const latestProposal = planState.proposals.find((proposal) => proposal.proposalId === planState.latestProposalId);
         if (mode === 'agent' && latestProposal?.status === 'pending_approval') {
-            throw new Error('当前方案正在等待审批，请明确放弃方案后再退出 Plan Mode。');
+            throw new SessionConfigurationTransitionError('operation_conflict', 'A pending Plan proposal must be resolved before leaving Plan mode');
         }
         const next = await this.deps.store.updateHeader(sessionId, {
             collaborationMode: mode,
         });
-        await this.deps.store.appendMessage(sessionId, {
-            type: 'system_note',
-            id: this.deps.newId(),
-            ts: this.deps.now(),
-            kind: 'mode_change',
-            data: { dimension: 'collaboration', from, to: mode },
-        });
         this.runtimeKernel.updateCachedHeader(sessionId, next);
         await this.runtimeKernel.disposeBackend(sessionId);
         return headerToSummary(next);
@@ -890,13 +936,6 @@ export class SessionManager {
             throw new Error('Cannot change orchestration mode while a tool call awaits confirmation.');
         }
         const next = await this.deps.store.updateHeader(sessionId, { orchestrationMode: mode });
-        await this.deps.store.appendMessage(sessionId, {
-            type: 'system_note',
-            id: this.deps.newId(),
-            ts: this.deps.now(),
-            kind: 'mode_change',
-            data: { dimension: 'orchestration', from, to: mode },
-        });
         this.runtimeKernel.updateCachedHeader(sessionId, next);
         return headerToSummary(next);
     }
@@ -931,7 +970,7 @@ export class SessionManager {
         if (!replay)
             await this.runtimeKernel.disposeBackend(sessionId);
         const result = await this.requirePlanStore().abandonProposal(input);
-        await this.finalizePlanAbandonment(sessionId, operationId, replay);
+        await this.finalizePlanAbandonment(sessionId);
         return result;
     }
     async approvePlan(input) {
@@ -1030,12 +1069,45 @@ export class SessionManager {
             : options.admitTurn;
         yield* this.runtimeKernel.startTurn(sessionId, input, { ...options, admitTurn });
     }
-    async planSafeBoundaryContinuation(sessionId, input) {
+    async planSafeBoundaryContinuation(sessionId, input, preview) {
+        let admissionRoute;
+        try {
+            if (!this.deps.runStore)
+                throw new Error('AgentRunStore is not configured');
+            const [header, invocations] = await Promise.all([
+                this.deps.store.readHeader(sessionId),
+                this.listInvocations(sessionId),
+            ]);
+            const targetProviderStateIdentity = (await this.deps.backends.prepare(header.backend, {
+                sessionId,
+                workspaceRoot: header.workspaceRoot,
+                header,
+            })).providerStateIdentity;
+            admissionRoute = {
+                invocations,
+                targetProviderStateIdentity,
+                targetModelId: header.model,
+            };
+        }
+        catch {
+            const plan = {
+                disposition: 'park',
+                rejectionReasons: ['continuation_authority_unavailable'],
+                diagnostics: [
+                    {
+                        code: 'continuation_authority_unavailable',
+                        message: 'provider replay admission authority is unavailable',
+                    },
+                ],
+            };
+            this.recordContinuationPlan(sessionId, input.sourceRunId, plan);
+            return plan;
+        }
         const planner = new RuntimeContinuationPlanner({
-            readSourceRun: async (targetSessionId, runId) => {
+            readSourceInvocation: async (targetSessionId, runId) => {
                 if (!this.deps.runStore)
                     throw new Error('AgentRunStore is not configured');
-                return this.deps.runStore.readRun(targetSessionId, runId);
+                return this.readInvocation(targetSessionId, runId);
             },
             readImmutableRuntimePrefix: async (prefixInput) => {
                 const authority = runtimeContinuationAuthority(this.deps.runtimeEventStore);
@@ -1053,17 +1125,25 @@ export class SessionManager {
             findExistingContinuation: async (targetSessionId, sourceRunId, sourceRuntimeEventHighWater) => {
                 if (!this.deps.runStore)
                     throw new Error('AgentRunStore is not configured');
-                return (await this.deps.runStore.listSessionRuns(targetSessionId)).find((run) => run.continuationSource?.sourceRunId === sourceRunId &&
-                    run.continuationSource.sourceRuntimeEventHighWater === sourceRuntimeEventHighWater);
+                return (await this.listInvocations(targetSessionId)).find((run) => {
+                    const source = run.opening.source;
+                    return (source.kind !== 'fresh' &&
+                        source.sourceRunId === sourceRunId &&
+                        source.sourceRuntimeEventHighWater === sourceRuntimeEventHighWater);
+                });
             },
             newId: this.deps.newId,
         });
-        const plan = await planner.plan({ sessionId, ...input });
-        this.recordContinuationPlan(sessionId, input.sourceRunId, plan);
+        const plannerInput = { sessionId, admissionRoute, ...input };
+        const plan = preview
+            ? await planner.previewHandoff(plannerInput, preview)
+            : await planner.plan(plannerInput);
+        if (!preview)
+            this.recordContinuationPlan(sessionId, input.sourceRunId, plan);
         return plan;
     }
-    async planAuthoritativeSafeBoundaryContinuation(sessionId, input) {
-        if (this.deps.safeBoundaryResumeEnabled !== true) {
+    async planAuthoritativeSafeBoundaryContinuation(sessionId, input, preview) {
+        if (input.purpose !== 'handoff' && this.deps.safeBoundaryResumeEnabled !== true) {
             const plan = resumeFeatureDisabledPlan();
             this.recordContinuationPlan(sessionId, input.sourceRunId, plan);
             return plan;
@@ -1082,9 +1162,7 @@ export class SessionManager {
             this.recordContinuationPlan(sessionId, input.sourceRunId, plan);
             return plan;
         }
-        const sourceRun = await this.deps.runStore
-            .readRun(sessionId, input.sourceRunId)
-            .catch(() => undefined);
+        const sourceRun = await this.readInvocation(sessionId, input.sourceRunId).catch(() => undefined);
         if (!sourceRun) {
             const plan = {
                 disposition: 'park',
@@ -1096,7 +1174,7 @@ export class SessionManager {
             this.recordContinuationPlan(sessionId, input.sourceRunId, plan);
             return plan;
         }
-        if (!sourceRun.workspaceIdentity) {
+        if (!sourceRun.opening.configuration.workspaceIdentity) {
             const plan = {
                 disposition: 'park',
                 rejectionReasons: ['workspace_identity_missing'],
@@ -1130,9 +1208,10 @@ export class SessionManager {
             return plan;
         }
         return this.planSafeBoundaryContinuation(sessionId, {
+            ...(input.purpose ? { purpose: input.purpose } : {}),
             sourceRunId: input.sourceRunId,
             currentCwd: header.cwd,
-            sourceWorkspaceIdentity: sourceRun.workspaceIdentity,
+            sourceWorkspaceIdentity: sourceRun.opening.configuration.workspaceIdentity,
             currentWorkspaceIdentity: observation.workspaceIdentity,
             backgroundOperationsSettled: observation.backgroundOperationsSettled,
             availableToolNames: observation.availableToolNames,
@@ -1142,7 +1221,7 @@ export class SessionManager {
             ...(observation.workspaceCheckpoint
                 ? { workspaceCheckpoint: observation.workspaceCheckpoint }
                 : {}),
-        });
+        }, preview);
     }
     async planLatestAuthoritativeSafeBoundaryContinuation(sessionId) {
         if (this.deps.safeBoundaryResumeEnabled !== true) {
@@ -1164,9 +1243,11 @@ export class SessionManager {
             this.recordContinuationPlan(sessionId, '', plan);
             return plan;
         }
-        const candidate = (await this.deps.runStore.listSessionRuns(sessionId))
-            .filter((run) => (run.status === 'failed' || run.status === 'cancelled') && isSessionInlineRun(run))
-            .sort((left, right) => right.createdAt - left.createdAt || right.runId.localeCompare(left.runId))[0];
+        const candidate = latestInvocation((await this.listInvocations(sessionId)).filter((run) => {
+            const outcome = runtimeInvocationOutcome(run);
+            return ((outcome === 'failed' || outcome === 'cancelled') &&
+                isSessionInlineInvocation(run.opening));
+        }));
         if (!candidate) {
             const plan = {
                 disposition: 'park',
@@ -1185,6 +1266,37 @@ export class SessionManager {
             sourceRunId: candidate.runId,
         });
     }
+    requestRunHandoff(sessionId, runId, intent, signal) {
+        const request = this.runtimeKernel.requestRunHandoff?.(sessionId, runId, intent, signal);
+        if (!request)
+            return undefined;
+        let verified = false;
+        const ready = request.ready.then(async (held) => {
+            if (!held)
+                return false;
+            try {
+                const assessment = await this.planAuthoritativeSafeBoundaryContinuation(sessionId, { sourceRunId: runId, purpose: 'handoff' }, request.preview());
+                request.preview(); // Cancellation or Stop may have released the gate during inspection.
+                verified = assessment.disposition === 'continue' && !signal.aborted;
+                if (!verified)
+                    request.cancel();
+                return verified;
+            }
+            catch {
+                request.cancel();
+                return false;
+            }
+        });
+        return {
+            ready,
+            sealed: request.sealed,
+            commit: () => verified && request.commit(),
+            cancel: () => {
+                verified = false;
+                request.cancel();
+            },
+        };
+    }
     async *resumeSafeBoundaryContinuation(continuation, options = {}) {
         const resume = this.runtimeKernel.resumeContinuation;
         if (!resume)
@@ -1242,6 +1354,9 @@ export class SessionManager {
             // Operational telemetry must never alter resume correctness.
         }
     }
+    runCoordinationOperation(sessionId, input, options, execute) {
+        return this.runtimeKernel.runCoordinationOperation(sessionId, input, options, execute);
+    }
     async *compactSession(sessionId, input = {}) {
         yield* this.runtimeKernel.compactSession(sessionId, input);
     }
@@ -1315,7 +1430,7 @@ export class SessionManager {
         }
         const [parentHeader, sourceRun, parentBoundary] = await Promise.all([
             this.deps.store.readHeader(input.source.sessionId),
-            this.deps.runStore.readRun(input.source.sessionId, input.source.runId),
+            this.readInvocation(input.source.sessionId, input.source.runId),
             this.deps.store.readExecutionBoundary(input.source.sessionId),
         ]);
         if (sourceRun.sessionId !== input.source.sessionId ||
@@ -1414,6 +1529,7 @@ export class SessionManager {
             permissionMode: childPermissionMode,
             collaborationMode: 'agent',
             orchestrationMode: 'default',
+            toolMode: parentHeader.toolMode ?? DEFAULT_TOOL_MODE,
             subagentParent: {
                 kind: 'subagent',
                 parentSessionId: input.source.sessionId,
@@ -1597,7 +1713,7 @@ export class SessionManager {
             });
             return readyNotification;
         };
-        let run = await this.deps.runStore.readRun(child.id, claim.targetRunId).catch((error) => {
+        let run = await this.readInvocation(child.id, claim.targetRunId).catch((error) => {
             if (isNotFoundError(error))
                 return undefined;
             throw error;
@@ -1617,7 +1733,7 @@ export class SessionManager {
                         throw new RuntimeMessageAuthorityInvariantError('Hosted retry attempted to start an existing claimed graph Run');
                     },
                 });
-                run = await this.deps.runStore.readRun(child.id, claim.targetRunId);
+                run = await this.readInvocation(child.id, claim.targetRunId);
                 this.assertClaimedAgentGraphRun(child, snapshot, claim, run);
                 await this.assertClaimedAgentGraphPrompt(child.id, claim.targetTurnId, input.prompt, admission.userMessageId);
                 await notifyReady();
@@ -1625,31 +1741,26 @@ export class SessionManager {
             }
             await this.assertClaimedAgentGraphPrompt(child.id, claim.targetTurnId, input.prompt);
             await notifyReady();
-            while (!isTerminalRunStatus(run.status) &&
+            while (!run.terminalEvent &&
                 this.runtimeKernel.hasActiveRun?.(child.id, run.runId, run.turnId)) {
                 await delay(25, undefined, input.abortSignal ? { signal: input.abortSignal } : undefined);
-                run = await this.deps.runStore.readRun(child.id, claim.targetRunId);
+                run = await this.readInvocation(child.id, claim.targetRunId);
             }
-            if (!isTerminalRunStatus(run.status)) {
+            if (!run.terminalEvent) {
                 await this.recoverAgentRunsFromLedger(child.id);
-                run = await this.deps.runStore.readRun(child.id, claim.targetRunId);
+                run = await this.readInvocation(child.id, claim.targetRunId);
             }
             this.assertClaimedAgentGraphRun(child, snapshot, claim, run);
             await this.assertClaimedAgentGraphPrompt(child.id, claim.targetTurnId, input.prompt);
             return claimedAgentGraphIntentResult(claim, await this.projectExistingChildSpawn(child, run));
         }
         await this.finalizeChildWorkspacePatches(child.id);
-        const [runs, messages] = await Promise.all([
-            this.deps.runStore.listSessionRuns(child.id),
-            this.deps.store.readMessages(child.id),
-        ]);
-        const turnOwner = runs.find((candidate) => candidate.turnId === claim.targetTurnId);
+        // An invocation is what makes a Turn exist on the ledger, so the run listing
+        // is the whole occupancy check: a Turn with durable content has one.
+        const turnOwner = (await this.listInvocations(child.id)).find((candidate) => candidate.turnId === claim.targetTurnId);
         if (turnOwner) {
             throw new Error(`Claimed graph turn ${claim.targetTurnId} is already owned by run ${turnOwner.runId}`);
         }
-        if (messages.some((message) => 'turnId' in message && message.turnId === claim.targetTurnId)) {
-            throw new Error(`Claimed graph turn ${claim.targetTurnId} already has durable messages`);
-        }
         if (child.isArchived || child.status === 'aborted') {
             throw new Error('Claimed graph execution target child session is terminated');
         }
@@ -1719,10 +1830,11 @@ export class SessionManager {
                 await stopPromise;
         }
         const completedAt = this.deps.now();
-        const completedRun = await this.deps.runStore.readRun(child.id, claim.targetRunId);
+        const completedRun = await this.readInvocation(child.id, claim.targetRunId);
         this.assertClaimedAgentGraphRun(child, snapshot, claim, completedRun);
-        const failureClass = completedRun.failureClass ?? summary.failureClass;
-        const artifacts = await this.finalizeAndListChildTurnArtifacts(child.id, claim.targetTurnId, completedRun.status);
+        const completedFacts = invocationListingFacts(completedRun);
+        const failureClass = completedFacts.failureClass ?? summary.failureClass;
+        const artifacts = await this.finalizeAndListChildTurnArtifacts(child.id, claim.targetTurnId, completedFacts.status);
         return {
             claimId: claim.claimId,
             graphId: claim.graphId,
@@ -1734,7 +1846,7 @@ export class SessionManager {
             profile: snapshot.profile,
             turnId: claim.targetTurnId,
             runId: claim.targetRunId,
-            status: agentRunStatusForSpawnResult(completedRun.status),
+            status: agentRunStatusForSpawnResult(completedFacts.status),
             permissionMode: child.permissionMode,
             summary: summary.text(),
             artifactIds: artifacts.map((artifact) => artifact.id),
@@ -1773,17 +1885,18 @@ export class SessionManager {
         return { runId: admission.runId, userMessageId: admission.userMessageId };
     }
     assertClaimedAgentGraphRun(child, snapshot, claim, run) {
+        const lineage = run.opening.lineage;
         if (run.sessionId !== child.id ||
             run.runId !== claim.targetRunId ||
             run.turnId !== claim.targetTurnId ||
-            !isSessionInlineRun(run) ||
-            run.agentId !== snapshot.agentId ||
-            (run.agentName !== undefined && run.agentName !== snapshot.agentName)) {
+            !isSessionInlineInvocation(run.opening) ||
+            lineage?.agentId !== snapshot.agentId ||
+            (lineage?.agentName !== undefined && lineage.agentName !== snapshot.agentName)) {
             throw new Error('Existing AgentRun does not match the claimed graph activation identity');
         }
     }
     async assertClaimedAgentGraphPrompt(sessionId, turnId, prompt, expectedUserMessageId) {
-        const messages = await this.deps.store.readMessages(sessionId);
+        const { messages } = await this.getSessionView(sessionId);
         const userMessages = messages.filter((message) => message.type === 'user' && message.turnId === turnId);
         if (expectedUserMessageId !== undefined) {
             if (userMessages.length !== 1 ||
@@ -1806,7 +1919,7 @@ export class SessionManager {
         }
         const [parentHeader, parentRun, parentBoundary] = await Promise.all([
             this.deps.store.readHeader(parentSessionId),
-            this.deps.runStore.readRun(parentSessionId, input.spawnedBy.parentRunId),
+            this.readInvocation(parentSessionId, input.spawnedBy.parentRunId),
             this.deps.store.readExecutionBoundary(parentSessionId),
         ]);
         this.assertActiveParentRun(parentSessionId, parentRun, input.spawnedBy.parentTurnId);
@@ -1842,6 +1955,7 @@ export class SessionManager {
             permissionMode: definition.permissionMode,
             collaborationMode: 'agent',
             orchestrationMode: 'default',
+            toolMode: parentHeader.toolMode ?? DEFAULT_TOOL_MODE,
             subagentParent: {
                 kind: 'subagent',
                 parentSessionId,
@@ -1925,7 +2039,7 @@ export class SessionManager {
             // crash boundary. Revalidate admission after the lookup: the parent or
             // caller may have settled while durable state was being inspected.
             try {
-                const latestParentRun = await this.deps.runStore.readRun(parentSessionId, input.spawnedBy.parentRunId);
+                const latestParentRun = await this.readInvocation(parentSessionId, input.spawnedBy.parentRunId);
                 this.assertActiveParentRun(parentSessionId, latestParentRun, input.spawnedBy.parentTurnId);
                 if (input.abortSignal?.aborted) {
                     throw new Error('Child session spawn was cancelled before its first run');
@@ -1991,9 +2105,10 @@ export class SessionManager {
             }
             const completedAt = this.deps.now();
             const run = await this.findRunByTurnId(child.id, turnId);
-            const failureClass = run?.failureClass ?? summary.failureClass;
-            const artifacts = run
-                ? await this.finalizeAndListChildTurnArtifacts(child.id, turnId, run.status)
+            const facts = run ? invocationListingFacts(run) : undefined;
+            const failureClass = facts?.failureClass ?? summary.failureClass;
+            const artifacts = facts
+                ? await this.finalizeAndListChildTurnArtifacts(child.id, turnId, facts.status)
                 : [];
             return {
                 childSessionId: child.id,
@@ -2002,7 +2117,7 @@ export class SessionManager {
                 profile: snapshot.profile,
                 turnId,
                 runId,
-                status: run ? agentRunStatusForSpawnResult(run.status) : summary.status(aborted),
+                status: facts ? agentRunStatusForSpawnResult(facts.status) : summary.status(aborted),
                 permissionMode: child.permissionMode,
                 summary: summary.text(),
                 artifactIds: artifacts.map((artifact) => artifact.id),
@@ -2025,7 +2140,7 @@ export class SessionManager {
         if (!snapshot || !spawn) {
             throw new Error('Stored child session is missing its durable runtime or spawn identity');
         }
-        let run = await this.deps.runStore.readRun(child.id, spawn.initialRunId).catch((error) => {
+        let run = await this.readInvocation(child.id, spawn.initialRunId).catch((error) => {
             if (isNotFoundError(error))
                 return undefined;
             throw error;
@@ -2033,14 +2148,14 @@ export class SessionManager {
         if (!run)
             return undefined;
         await notifyReady();
-        while (!isTerminalRunStatus(run.status) &&
+        while (!run.terminalEvent &&
             this.runtimeKernel.hasActiveRun?.(child.id, run.runId, run.turnId)) {
             await delay(25, undefined, input.abortSignal ? { signal: input.abortSignal } : undefined);
-            run = await this.deps.runStore.readRun(child.id, spawn.initialRunId);
+            run = await this.readInvocation(child.id, spawn.initialRunId);
         }
-        if (!isTerminalRunStatus(run.status)) {
+        if (!run.terminalEvent) {
             await this.recoverAgentRunsFromLedger(child.id);
-            run = await this.deps.runStore.readRun(child.id, spawn.initialRunId);
+            run = await this.readInvocation(child.id, spawn.initialRunId);
         }
         return await this.projectExistingChildSpawn(child, run);
     }
@@ -2051,14 +2166,11 @@ export class SessionManager {
         const snapshot = child.subagentRuntime;
         if (!snapshot)
             throw new Error('Stored child session is missing its durable runtime snapshot');
-        const [messages, runtimeEvents, artifacts] = await Promise.all([
-            this.deps.store.readMessages(child.id),
+        const facts = invocationListingFacts(run);
+        const [runtimeEvents, artifacts] = await Promise.all([
             this.deps.runtimeEventStore.readRuntimeEvents(child.id, run.runId),
-            this.finalizeAndListChildTurnArtifacts(child.id, run.turnId, run.status),
+            this.finalizeAndListChildTurnArtifacts(child.id, run.turnId, facts.status),
         ]);
-        const storedSummary = messages
-            .filter((message) => message.type === 'assistant' && message.turnId === run.turnId)
-            .at(-1)?.text ?? '';
         const runtimeText = runtimeEvents.filter((event) => event.role === 'model' && event.content?.kind === 'text');
         const durableRuntimeSummary = runtimeText.filter((event) => !event.partial).at(-1)
             ?.content.text;
@@ -2066,7 +2178,6 @@ export class SessionManager {
             .filter((event) => event.partial)
             .map((event) => event.content.text)
             .join('');
-        const completedAt = run.completedAt ?? run.updatedAt;
         return {
             childSessionId: child.id,
             agentId: snapshot.agentId,
@@ -2074,15 +2185,15 @@ export class SessionManager {
             profile: snapshot.profile,
             turnId: run.turnId,
             runId: run.runId,
-            status: agentRunStatusForSpawnResult(run.status),
+            status: agentRunStatusForSpawnResult(facts.status),
             permissionMode: child.permissionMode,
-            summary: trimSummary(durableRuntimeSummary ?? (storedSummary || partialRuntimeSummary)),
+            summary: trimSummary(durableRuntimeSummary ?? partialRuntimeSummary),
             artifactIds: artifacts.map((artifact) => artifact.id),
-            startedAt: run.createdAt,
-            completedAt,
-            durationMs: Math.max(0, completedAt - run.createdAt),
+            startedAt: facts.createdAt,
+            completedAt: facts.updatedAt,
+            durationMs: facts.durationMs ?? 0,
             eventCount: runtimeEvents.length,
-            ...(run.failureClass ? { failureClass: run.failureClass } : {}),
+            ...(facts.failureClass ? { failureClass: facts.failureClass } : {}),
         };
     }
     transferRuntimeExecution(source, targetSessionId) {
@@ -2132,38 +2243,22 @@ export class SessionManager {
         const presets = this.deps.subagentCatalog ? await this.deps.subagentCatalog.list() : [];
         if (!this.deps.runStore)
             return { definitions, presets, executions: [], runs: [] };
-        const runs = await this.deps.runStore.listSessionRuns(sessionId);
-        const childRuns = await Promise.all(runs
-            .filter((run) => !!run.parentRunId && !isSessionInlineRun(run))
-            .map(async (run) => ({
-            ...(await this.effectiveRunHeaderFromRuntimeLedger(run)),
-            parentRunId: run.parentRunId,
-        })));
-        const legacyRuns = childRuns.map((run) => ({
-            runId: run.runId,
-            turnId: run.turnId,
-            parentRunId: run.parentRunId,
-            ...(run.agentId ? { agentId: run.agentId } : {}),
-            ...(run.agentName ? { agentName: run.agentName } : {}),
-            status: run.status,
-            permissionMode: run.permissionMode,
-            createdAt: run.createdAt,
-            updatedAt: run.updatedAt,
-            ...(run.completedAt !== undefined ? { completedAt: run.completedAt } : {}),
-            ...(run.completedAt !== undefined
-                ? { durationMs: Math.max(0, run.completedAt - run.createdAt) }
-                : {}),
-            ...(run.failureClass ? { failureClass: run.failureClass } : {}),
-        }));
+        const childRuns = (await this.listInvocations(sessionId)).filter((run) => !!run.opening.lineage?.parentRunId && !isSessionInlineInvocation(run.opening));
+        const legacyRuns = childRuns.map((run) => {
+            const facts = invocationListingFacts(run);
+            return {
+                runId: run.runId,
+                turnId: run.turnId,
+                parentRunId: run.opening.lineage.parentRunId,
+                ...(run.opening.lineage?.agentId ? { agentId: run.opening.lineage.agentId } : {}),
+                ...(run.opening.lineage?.agentName ? { agentName: run.opening.lineage.agentName } : {}),
+                ...facts,
+            };
+        });
         const childSessionHeaders = await Promise.all((await this.listChildSessions(sessionId)).map((child) => this.deps.store.readHeader(child.id)));
         const childSessionExecutions = await Promise.all(childSessionHeaders.map(async (child) => {
-            const childRuns = await this.deps.runStore.listSessionRuns(child.id);
-            const latest = childRuns
-                .slice()
-                .sort((left, right) => right.createdAt - left.createdAt ||
-                right.updatedAt - left.updatedAt ||
-                right.runId.localeCompare(left.runId))[0];
-            const run = latest ? await this.effectiveRunHeaderFromRuntimeLedger(latest) : undefined;
+            const run = latestInvocation(await this.listInvocations(child.id));
+            const facts = run ? invocationListingFacts(run) : undefined;
             const currentRunId = run?.runId ?? child.subagentSpawn?.initialRunId;
             return {
                 execution: {
@@ -2177,15 +2272,13 @@ export class SessionManager {
                     : {}),
                 ...(child.subagentRuntime?.profile ? { profile: child.subagentRuntime.profile } : {}),
                 ...(run?.turnId ? { turnId: run.turnId } : {}),
-                status: run?.status ?? (child.status === 'aborted' ? 'cancelled' : 'created'),
-                permissionMode: run?.permissionMode ?? child.permissionMode,
-                createdAt: run?.createdAt ?? child.createdAt,
-                updatedAt: run?.updatedAt ?? child.lastMessageAt ?? child.createdAt,
-                ...(run?.completedAt !== undefined ? { completedAt: run.completedAt } : {}),
-                ...(run?.completedAt !== undefined
-                    ? { durationMs: Math.max(0, run.completedAt - run.createdAt) }
-                    : {}),
-                ...(run?.failureClass ? { failureClass: run.failureClass } : {}),
+                status: facts?.status ?? (child.status === 'aborted' ? 'cancelled' : 'running'),
+                permissionMode: facts?.permissionMode ?? child.permissionMode,
+                createdAt: facts?.createdAt ?? child.createdAt,
+                updatedAt: facts?.updatedAt ?? child.lastMessageAt ?? child.createdAt,
+                ...(facts?.completedAt !== undefined ? { completedAt: facts.completedAt } : {}),
+                ...(facts?.durationMs !== undefined ? { durationMs: facts.durationMs } : {}),
+                ...(facts?.failureClass ? { failureClass: facts.failureClass } : {}),
             };
         }));
         return {
@@ -2193,7 +2286,7 @@ export class SessionManager {
             presets,
             executions: [
                 ...childSessionExecutions,
-                ...childRuns.map((run) => ({
+                ...legacyRuns.map((run) => ({
                     execution: {
                         kind: 'legacy_child_run',
                         sessionId,
@@ -2207,9 +2300,7 @@ export class SessionManager {
                     createdAt: run.createdAt,
                     updatedAt: run.updatedAt,
                     ...(run.completedAt !== undefined ? { completedAt: run.completedAt } : {}),
-                    ...(run.completedAt !== undefined
-                        ? { durationMs: Math.max(0, run.completedAt - run.createdAt) }
-                        : {}),
+                    ...(run.durationMs !== undefined ? { durationMs: run.durationMs } : {}),
                     ...(run.failureClass ? { failureClass: run.failureClass } : {}),
                 })),
             ],
@@ -2226,19 +2317,15 @@ export class SessionManager {
             throw new Error('agent_output requires AgentRunStore and RuntimeEventStore');
         }
         const located = await this.findChildRunForOutput(sessionId, input);
-        const { header } = located;
-        const inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, {
-            sessionId: header.sessionId,
-            runId: header.runId,
-            header,
-        });
-        const artifacts = await this.finalizeAndListChildTurnArtifacts(header.sessionId, header.turnId, inspected.header.status);
+        const { invocation } = located;
+        const inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, { sessionId: invocation.sessionId, runId: invocation.runId, invocation });
+        const artifacts = await this.finalizeAndListChildTurnArtifacts(invocation.sessionId, invocation.turnId, runtimeInvocationOutcome(inspected.invocation) ?? 'running');
         const maxEvents = normalizeAgentOutputMaxEvents(input.maxEvents);
         const maxBytes = normalizeAgentOutputMaxBytes(input.maxBytes);
         const view = input.view ?? 'runtime_events';
         if (view === 'result') {
             const boundedResult = buildAgentOutputCommittedResult({
-                header: inspected.header,
+                invocation: inspected.invocation,
                 runtimeEvents: inspected.runtimeEvents,
                 artifacts,
                 maxArtifacts: maxEvents,
@@ -2247,7 +2334,7 @@ export class SessionManager {
             });
             return {
                 execution: located.execution,
-                header: inspected.header,
+                invocation: inspected.invocation,
                 result: boundedResult.result,
                 events: [],
                 runtimeEvents: [],
@@ -2276,7 +2363,7 @@ export class SessionManager {
         }, maxBytes);
         return {
             execution: located.execution,
-            header: inspected.header,
+            invocation: inspected.invocation,
             events: bounded.events,
             runtimeEvents: bounded.runtimeEvents,
             sourceHealth: inspected.sourceHealth,
@@ -2306,43 +2393,30 @@ export class SessionManager {
         const hostedAuthority = isRuntimeHostedRootAuthority(this.deps.messageAuthority)
             ? this.deps.messageAuthority
             : undefined;
-        const ownStop = hostedAuthority
+        await this.#stopSessionTree(sessionId, hostedAuthority
             ? hostedAuthority.stopSession(sessionId, input)
-            : this.runtimeKernel.stopSession(sessionId, input);
-        let childStops = [];
-        let childLookupError;
-        try {
-            const children = await this.listChildSessions(sessionId);
-            childStops = await Promise.allSettled(children
-                .filter((child) => child.subagentParent?.lifecycle === 'foreground')
-                .map((child) => hostedAuthority
-                ? hostedAuthority.stopSession(child.id, input)
-                : this.runtimeKernel.stopSession(child.id, input)));
-        }
-        catch (error) {
-            childLookupError = error;
-        }
-        await ownStop;
-        const childStopError = childStops.find((result) => result.status === 'rejected')?.reason;
-        if (childLookupError !== undefined)
-            throw childLookupError;
-        if (childStopError !== undefined)
-            throw childStopError;
+            : this.runtimeKernel.stopSession(sessionId, input), (childSessionId) => hostedAuthority
+            ? hostedAuthority.stopSession(childSessionId, input)
+            : this.runtimeKernel.stopSession(childSessionId, input));
     }
     async deliverHostedRootStop(sessionId, input = {}) {
-        const ownStop = this.runtimeKernel.stopSession(sessionId, input);
         const authority = isRuntimeHostedRootAuthority(this.deps.messageAuthority)
             ? this.deps.messageAuthority
             : undefined;
+        await this.#stopSessionTree(sessionId, this.runtimeKernel.stopSession(sessionId, input), (childSessionId) => authority
+            ? authority.stopSession(childSessionId, input)
+            : this.runtimeKernel.stopSession(childSessionId, input));
+    }
+    async #stopSessionTree(sessionId, ownStop, stopChild) {
+        // Observe immediately while child lookup runs; await below still propagates the original error.
+        void ownStop.catch(() => undefined);
         let childStops = [];
         let childLookupError;
         try {
             const children = await this.listChildSessions(sessionId);
             childStops = await Promise.allSettled(children
                 .filter((child) => child.subagentParent?.lifecycle === 'foreground')
-                .map((child) => authority
-                ? authority.stopSession(child.id, input)
-                : this.runtimeKernel.stopSession(child.id, input)));
+                .map((child) => stopChild(child.id)));
         }
         catch (error) {
             childLookupError = error;
@@ -2359,20 +2433,31 @@ export class SessionManager {
             throw new Error('Hosted admission recovery requires execution stores');
         }
         const session = await this.deps.store.readHeader(input.sessionId);
-        const headerExtras = {};
+        let root = { kind: 'user' };
+        let orchestration = {
+            orchestrationMode: session.orchestrationMode ?? 'default',
+            orchestrationSource: 'session',
+            agentSwarmAuthorization: 'none',
+        };
+        const lineage = {};
         let recoveryReason;
         let diagnostic;
         let workspaceIdentity;
         if (input.execution.kind === 'goal') {
-            headerExtras.goalId = input.execution.goalId;
+            root = { kind: 'goal', goalId: input.execution.goalId };
             recoveryReason = 'goal_internal_admission_without_run';
             diagnostic = {
                 executionKind: input.execution.kind,
                 goalId: input.execution.goalId,
             };
         }
+        else if (input.execution.kind === 'workhub_coordination' &&
+            input.execution.operation === 'action') {
+            recoveryReason = 'coordination_action_admission_without_run';
+            diagnostic = { executionKind: input.execution.kind, operation: input.execution.operation };
+        }
         else if (input.execution.kind === 'legacy_automation') {
-            headerExtras.legacyAutomationId = input.execution.automationId;
+            root = { kind: 'legacy_automation', legacyAutomationId: input.execution.automationId };
             recoveryReason = 'legacy_automation_authority_removed';
             diagnostic = {
                 executionKind: input.execution.kind,
@@ -2380,11 +2465,16 @@ export class SessionManager {
             };
         }
         else if (input.execution.kind === 'agent_graph_supervisor_wake') {
-            headerExtras.agentGraphWakeId = input.execution.wakeId;
-            headerExtras.agentGraphWakeAttemptId = input.execution.attemptId;
-            headerExtras.orchestrationMode = 'graph';
-            headerExtras.orchestrationSource = 'turn_override';
-            headerExtras.agentSwarmAuthorization = 'none';
+            root = {
+                kind: 'agent_graph_supervisor_wake',
+                wakeId: input.execution.wakeId,
+                attemptId: input.execution.attemptId,
+            };
+            orchestration = {
+                orchestrationMode: 'graph',
+                orchestrationSource: 'turn_override',
+                agentSwarmAuthorization: 'none',
+            };
             recoveryReason = 'agent_graph_supervisor_internal_admission_without_run';
             diagnostic = {
                 executionKind: input.execution.kind,
@@ -2419,21 +2509,21 @@ export class SessionManager {
             }
             if (input.execution.kind === 'linked_child_resume' ||
                 input.execution.kind === 'linked_child_provider_retry') {
-                const sourceRun = await this.deps.runStore.readRun(input.sessionId, input.execution.sourceRunId);
-                if (sourceRun.agentId !== input.execution.agentId ||
-                    sourceRun.agentName !== input.execution.agentName) {
+                const sourceRun = await this.readInvocation(input.sessionId, input.execution.sourceRunId);
+                if (sourceRun.opening.lineage?.agentId !== input.execution.agentId ||
+                    sourceRun.opening.lineage.agentName !== input.execution.agentName) {
                     throw new Error(`Admitted Turn ${input.turnId} source changed its trusted agent identity`);
                 }
-                workspaceIdentity = sourceRun.workspaceIdentity;
+                workspaceIdentity = sourceRun.opening.configuration.workspaceIdentity;
                 if (input.execution.kind === 'linked_child_resume') {
-                    headerExtras.resumedFromRunId = input.execution.sourceRunId;
+                    lineage.resumedFromRunId = input.execution.sourceRunId;
                 }
                 else {
-                    headerExtras.retriedFromRunId = input.execution.sourceRunId;
+                    lineage.retriedFromRunId = input.execution.sourceRunId;
                 }
             }
-            headerExtras.agentId = input.execution.agentId;
-            headerExtras.agentName = input.execution.agentName;
+            lineage.agentId = input.execution.agentId;
+            lineage.agentName = input.execution.agentName;
             recoveryReason = 'child_internal_admission_without_run';
             diagnostic = {
                 executionKind: input.execution.kind,
@@ -2447,26 +2537,76 @@ export class SessionManager {
             throw new Error('External message recovery closure is not supported');
         }
         const run = {
-            runId: input.runId,
-            invocationId: input.runId,
             sessionId: input.sessionId,
+            invocationId: input.runId,
+            runId: input.runId,
             turnId: input.turnId,
-            status: 'created',
-            backendKind: session.backend,
-            ...(session.llmConnectionId === undefined
-                ? {}
-                : { llmConnectionId: session.llmConnectionId }),
-            llmConnectionSlug: session.llmConnectionSlug,
-            modelId: session.model,
-            cwd: session.cwd,
-            ...(workspaceIdentity !== undefined ? { workspaceIdentity } : {}),
-            permissionMode: session.permissionMode,
-            collaborationMode: session.collaborationMode ?? 'agent',
-            createdAt: input.admittedAt,
-            updatedAt: input.admittedAt,
-            ...headerExtras,
         };
-        await this.deps.runStore.createRun(run, { durable: true });
+        const opening = {
+            kind: 'invocation_opened',
+            protocol: 'invocation_opened_v1',
+            route: session.llmConnectionId === undefined
+                ? {
+                    provenance: 'unknown',
+                    backendKind: session.backend,
+                    llmConnectionSlug: session.llmConnectionSlug,
+                    modelId: session.model,
+                }
+                : {
+                    provenance: 'runtime',
+                    backendKind: session.backend,
+                    llmConnectionId: session.llmConnectionId,
+                    llmConnectionSlug: session.llmConnectionSlug,
+                    modelId: session.model,
+                },
+            configuration: {
+                cwd: session.cwd,
+                permissionMode: session.permissionMode,
+                collaborationMode: session.collaborationMode ?? 'agent',
+                toolMode: session.toolMode ?? DEFAULT_TOOL_MODE,
+                ...orchestration,
+                ...(workspaceIdentity !== undefined ? { workspaceIdentity } : {}),
+            },
+            root,
+            source: { kind: 'fresh' },
+            ...(Object.keys(lineage).length > 0 ? { lineage } : {}),
+        };
+        // The admission never reached an AgentRun, so nothing else will ever open
+        // this invocation. Recovery opens and closes it in one pass so the Turn
+        // ends up on the spine like any other, with its own reason for ending.
+        await this.deps.runtimeEventStore.appendRuntimeEvent(input.sessionId, input.runId, buildInvocationOpenedEvent({
+            id: this.deps.newId(),
+            run,
+            openedAt: input.admittedAt,
+            opening,
+        }));
+        if (input.userMessage) {
+            await this.deps.runtimeEventStore.appendRuntimeEvent(input.sessionId, input.runId, {
+                id: input.userMessage.id,
+                ...run,
+                ts: input.admittedAt,
+                partial: false,
+                role: 'user',
+                author: input.userMessage.origin ? 'host' : 'user',
+                content: {
+                    kind: 'text',
+                    text: input.userMessage.content.text,
+                    ...(input.userMessage.content.displayText !== undefined
+                        ? { displayText: input.userMessage.content.displayText }
+                        : {}),
+                    ...(input.userMessage.content.attachments?.length
+                        ? { attachments: input.userMessage.content.attachments }
+                        : {}),
+                    ...(input.userMessage.content.directoryReferences?.length
+                        ? { directoryReferences: input.userMessage.content.directoryReferences }
+                        : {}),
+                    ...(input.userMessage.content.quotes?.length
+                        ? { quotes: input.userMessage.content.quotes }
+                        : {}),
+                    ...(input.userMessage.origin ? { origin: input.userMessage.origin } : {}),
+                },
+            });
+        }
         const ts = this.deps.now();
         const terminalEvent = buildRecoveredTerminalRuntimeEvent({
             id: this.deps.newId(),
@@ -2479,7 +2619,6 @@ export class SessionManager {
             message: 'app_restarted',
         });
         await commitTerminalRunWithRuntimeFact({
-            runStore: this.deps.runStore,
             runtimeEventStore: this.deps.runtimeEventStore,
             newId: this.deps.newId,
             sessionId: input.sessionId,
@@ -2489,12 +2628,6 @@ export class SessionManager {
             ts,
             terminalEvent,
             failureClass: 'app_restarted',
-            runEventData: {
-                recovered: true,
-                recoveryReason,
-                ...diagnostic,
-            },
-            existingEvents: [],
         });
     }
     async consumeLinkedRootExecution(input, hostedGateAlreadyHeld = false) {
@@ -2578,155 +2711,9 @@ export class SessionManager {
             content: normalizeMessageContent(user),
         };
     }
-    async branchFromTurn(sessionId, input) {
-        const sourceView = await this.getSessionView(sessionId);
-        const slice = createConversationCopySlice(sourceView.messages, input.sourceTurnId, 'through');
-        if (!slice)
-            throw new Error(`Cannot branch from unknown turn ${input.sourceTurnId}`);
-        return this.createBranchSession(sessionId, sourceView, [...slice.messages], input);
-    }
     /** Canonical, repaired source view for a Host-owned cross-Session copy. */
     async readConversationCopySnapshot(sessionId) {
-        const readMessagesSnapshot = this.deps.store.readMessagesSnapshot;
-        if (!readMessagesSnapshot) {
-            throw new Error('Conversation copy requires a side-effect-free message snapshot');
-        }
-        const readMessages = readMessagesSnapshot.bind(this.deps.store);
-        const view = await this.getSessionView(sessionId, { readMessages });
-        if (view.runs.length > 0 || view.messages.length > 0)
-            return view;
-        const messages = await readMessages(sessionId);
-        if (messages.length === 0)
-            return view;
-        return {
-            ...view,
-            messages,
-            turns: deriveTurnRecords(messages),
-        };
-    }
-    async branchBeforeTurn(sessionId, input) {
-        const sourceView = await this.getSessionView(sessionId);
-        const slice = createConversationCopySlice(sourceView.messages, input.sourceTurnId, 'before');
-        if (!slice)
-            throw new Error(`Cannot branch before unknown turn ${input.sourceTurnId}`);
-        return this.createBranchSession(sessionId, sourceView, [...slice.messages], input);
-    }
-    /**
-     * Create a non-destructive edit-and-resend version. Unlike branchBeforeTurn,
-     * this is not a new sidebar conversation: revision lineage lets hosts fold
-     * every version into one conversation slot while keeping old transcripts.
-     */
-    async reviseBeforeTurn(sessionId, input) {
-        const sourceView = await this.getSessionView(sessionId);
-        const slice = createConversationCopySlice(sourceView.messages, input.sourceTurnId, 'before');
-        if (!slice)
-            throw new Error(`Cannot revise before unknown turn ${input.sourceTurnId}`);
-        return this.createRevisionSession(sessionId, sourceView, [...slice.messages], input);
-    }
-    async createRevisionSession(sessionId, sourceView, copied, input) {
-        const plan = await this.prepareConversationRuntimeLedgerClone(sessionId, sourceView, copied);
-        const [header, boundary] = await Promise.all([
-            this.deps.store.readHeader(sessionId),
-            this.deps.store.readExecutionBoundary(sessionId),
-        ]);
-        const revisionRootSessionId = header.revisionRootSessionId ?? sessionId;
-        const family = (await this.deps.store.list()).filter((candidate) => candidate.id === revisionRootSessionId ||
-            candidate.revisionRootSessionId === revisionRootSessionId);
-        const revisionIndex = Math.max(1, ...family.map((candidate) => candidate.revisionIndex ?? 1)) + 1;
-        const next = await this.deps.store.create({
-            cwd: header.cwd,
-            ...(header.projectId !== undefined ? { projectId: header.projectId } : {}),
-            ...(header.llmConnectionId === undefined
-                ? {}
-                : { llmConnectionId: header.llmConnectionId }),
-            llmConnectionSlug: header.llmConnectionSlug,
-            model: header.model,
-            thinkingLevel: header.thinkingLevel,
-            permissionMode: header.permissionMode,
-            collaborationMode: header.collaborationMode,
-            orchestrationMode: header.orchestrationMode ?? 'default',
-            name: header.name,
-            labels: header.labels,
-            // A revision of a real branch remains in that branch's conversation
-            // slot; revision lineage itself must not create a branch banner.
-            parentSessionId: header.parentSessionId,
-            branchOfTurnId: header.branchOfTurnId,
-            revisionRootSessionId,
-            revisionParentSessionId: sessionId,
-            revisionOfTurnId: input.sourceTurnId,
-            revisionIndex,
-            revisionState: 'preparing',
-            status: 'active',
-        }, boundary);
-        try {
-            const rewritten = await this.cloneConversationRuntimeLedger(next.id, copied, plan);
-            if (rewritten.length > 0)
-                await this.deps.store.appendMessages(next.id, [...rewritten]);
-            await this.deps.store.appendMessage(next.id, {
-                type: 'system_note',
-                id: this.deps.newId(),
-                ts: this.deps.now(),
-                kind: 'session_start',
-                data: {
-                    revisionRootSessionId,
-                    revisionParentSessionId: sessionId,
-                    revisionOfTurnId: input.sourceTurnId,
-                    revisionIndex,
-                    revisionState: 'preparing',
-                },
-            });
-            await this.deps.store.updateHeader(next.id, {
-                isFlagged: header.isFlagged,
-                titleIsManual: header.titleIsManual,
-            });
-            return headerToSummary(await this.deps.store.readHeader(next.id));
-        }
-        catch (error) {
-            return this.rollbackLegacyConversationCopy(next.id, error);
-        }
-    }
-    async createBranchSession(sessionId, sourceView, copied, input) {
-        const plan = await this.prepareConversationRuntimeLedgerClone(sessionId, sourceView, copied);
-        const [header, boundary] = await Promise.all([
-            this.deps.store.readHeader(sessionId),
-            this.deps.store.readExecutionBoundary(sessionId),
-        ]);
-        const next = await this.deps.store.create({
-            cwd: header.cwd,
-            ...(header.projectId !== undefined ? { projectId: header.projectId } : {}),
-            ...(header.llmConnectionId === undefined
-                ? {}
-                : { llmConnectionId: header.llmConnectionId }),
-            llmConnectionSlug: header.llmConnectionSlug,
-            model: header.model,
-            thinkingLevel: header.thinkingLevel,
-            permissionMode: header.permissionMode,
-            collaborationMode: header.collaborationMode,
-            orchestrationMode: header.orchestrationMode ?? 'default',
-            name: input.name ?? `${header.name} · 分支`,
-            labels: input.sideConversation
-                ? [...new Set([...header.labels, SIDE_CONVERSATION_SESSION_LABEL])]
-                : header.labels,
-            parentSessionId: sessionId,
-            branchOfTurnId: input.sourceTurnId,
-            status: 'active',
-        }, boundary);
-        try {
-            const rewritten = await this.cloneConversationRuntimeLedger(next.id, copied, plan);
-            if (rewritten.length > 0)
-                await this.deps.store.appendMessages(next.id, [...rewritten]);
-            await this.deps.store.appendMessage(next.id, {
-                type: 'system_note',
-                id: this.deps.newId(),
-                ts: this.deps.now(),
-                kind: 'session_start',
-                data: { parentSessionId: sessionId, branchOfTurnId: input.sourceTurnId },
-            });
-            return headerToSummary(await this.deps.store.readHeader(next.id));
-        }
-        catch (error) {
-            return this.rollbackLegacyConversationCopy(next.id, error);
-        }
+        return this.getSessionView(sessionId);
     }
     async respondToSandboxBoundary(sessionId, response) {
         if (this.deps.interactionAuthority) {
@@ -2746,9 +2733,8 @@ export class SessionManager {
     async findRunByTurnId(sessionId, turnId) {
         if (!this.deps.runStore)
             return undefined;
-        const runs = await this.deps.runStore.listSessionRuns(sessionId).catch(() => []);
-        const run = runs.find((candidate) => candidate.turnId === turnId);
-        return run ? this.effectiveRunHeaderFromRuntimeLedger(run) : undefined;
+        const runs = await this.listInvocations(sessionId).catch(() => []);
+        return runs.find((candidate) => candidate.turnId === turnId);
     }
     assertActiveParentRun(parentSessionId, parentRun, parentTurnId) {
         if (parentRun.sessionId !== parentSessionId ||
@@ -2795,14 +2781,10 @@ export class SessionManager {
         catch (error) {
             if (!(error instanceof RuntimeReadModelError))
                 throw error;
-            // ShellRun hydration is a best-effort UI projection. A legacy RuntimeEvent
-            // incompatibility must not turn its retry loop into a permanent IPC error.
-            try {
-                return await this.deps.store.readMessages(sessionId);
-            }
-            catch {
-                return null;
-            }
+            // ShellRun hydration is a best-effort UI projection. A ledger the read
+            // model cannot project yet must not turn its retry loop into a permanent
+            // IPC error; there is no second transcript to fall back to.
+            return null;
         }
     }
     async findChildRunForOutput(sessionId, input) {
@@ -2821,24 +2803,19 @@ export class SessionManager {
                 child.subagentParent.parentSessionId !== sessionId) {
                 throw new Error('agent_output could not find the requested child session');
             }
-            const runs = await this.deps.runStore?.listSessionRuns(child.id);
+            const runs = await this.listInvocations(child.id);
             const selected = execution.currentRunId
-                ? runs?.find((run) => run.runId === execution.currentRunId)
-                : runs
-                    ?.slice()
-                    .sort((left, right) => right.createdAt - left.createdAt ||
-                    right.updatedAt - left.updatedAt ||
-                    right.runId.localeCompare(left.runId))[0];
-            if (!selected || !isSessionInlineRun(selected)) {
+                ? runs.find((run) => run.runId === execution.currentRunId)
+                : latestInvocation(runs);
+            if (!selected || !isSessionInlineInvocation(selected.opening)) {
                 throw new Error('agent_output could not find the requested child session run');
             }
-            const header = await this.effectiveRunHeaderFromRuntimeLedger(selected);
             return {
-                header,
+                invocation: selected,
                 execution: {
                     kind: 'child_session',
                     sessionId: child.id,
-                    currentRunId: header.runId,
+                    currentRunId: selected.runId,
                 },
                 ...(child.subagentParent.graph ? { graph: child.subagentParent.graph } : {}),
             };
@@ -2847,39 +2824,27 @@ export class SessionManager {
         if (legacyExecution && legacyExecution.sessionId !== sessionId) {
             throw new Error('agent_output could not find the requested legacy child run');
         }
-        const runs = await this.deps.runStore?.listSessionRuns(sessionId);
-        const header = runs?.find((run) => legacyExecution
+        const invocation = (await this.listInvocations(sessionId)).find((run) => legacyExecution
             ? run.runId === legacyExecution.runId
             : input.runId
                 ? run.runId === input.runId
                 : input.turnId
                     ? run.turnId === input.turnId
                     : false);
-        if (!header)
+        if (!invocation)
             throw new Error('agent_output could not find the requested child agent run');
-        if (!header.parentRunId || isSessionInlineRun(header)) {
+        if (!invocation.opening.lineage?.parentRunId || isSessionInlineInvocation(invocation.opening)) {
             throw new Error('agent_output only reads child agent runs');
         }
         return {
-            header: await this.effectiveRunHeaderFromRuntimeLedger(header),
+            invocation,
             execution: {
                 kind: 'legacy_child_run',
                 sessionId,
-                runId: header.runId,
+                runId: invocation.runId,
             },
         };
     }
-    async effectiveRunHeaderFromRuntimeLedger(run) {
-        if (!this.deps.runtimeEventStore)
-            return run;
-        const runtimeEvents = await this.deps.runtimeEventStore
-            .readRuntimeEvents(run.sessionId, run.runId)
-            .catch(() => undefined);
-        if (!runtimeEvents)
-            return run;
-        const ledger = classifyTerminalRuntimeLedger(run, runtimeEvents);
-        return ledger.kind === 'fact' ? effectiveRunHeaderFromTerminalFact(run, ledger.fact) : run;
-    }
     async updateStatus(sessionId, status, blockedReason, ts = this.deps.now()) {
         await this.updateHeader(sessionId, buildStatusPatch(status, ts, blockedReason));
     }
@@ -2901,37 +2866,12 @@ export class SessionManager {
             : header;
         this.runtimeKernel.updateCachedHeader(sessionId, next);
     }
-    async finalizePlanAbandonment(sessionId, operationId, replay) {
+    async finalizePlanAbandonment(sessionId) {
         const header = await this.deps.store.readHeader(sessionId);
-        const from = header.collaborationMode ?? 'agent';
-        const changed = from !== 'agent';
-        const next = changed
-            ? await this.deps.store.updateHeader(sessionId, { collaborationMode: 'agent' })
-            : header;
+        const next = (header.collaborationMode ?? 'agent') === 'agent'
+            ? header
+            : await this.deps.store.updateHeader(sessionId, { collaborationMode: 'agent' });
         this.runtimeKernel.updateCachedHeader(sessionId, next);
-        if (!changed && !replay)
-            return;
-        if (!operationId) {
-            await this.deps.store.appendMessage(sessionId, {
-                type: 'system_note',
-                id: this.deps.newId(),
-                ts: this.deps.now(),
-                kind: 'mode_change',
-                data: { dimension: 'collaboration', from, to: 'agent' },
-            });
-            return;
-        }
-        const noteId = planAbandonmentNoteId(operationId);
-        const messages = await this.deps.store.readMessages(sessionId);
-        if (messages.some((message) => message.id === noteId))
-            return;
-        await this.deps.store.appendMessage(sessionId, {
-            type: 'system_note',
-            id: noteId,
-            ts: this.deps.now(),
-            kind: 'mode_change',
-            data: { dimension: 'collaboration', from: 'plan', to: 'agent' },
-        });
     }
     requirePlanStore() {
         if (!this.deps.planStore)
@@ -2963,23 +2903,6 @@ export class SessionManager {
             throw new SessionConfigurationTransitionError('operation_conflict', 'A pending Plan proposal must be resolved before leaving Plan mode');
         }
     }
-    async appendTurnState(sessionId, turnId, status, lineage = {}, options = {}) {
-        const ts = options.ts ?? this.deps.now();
-        await this.deps.store.appendMessage(sessionId, buildTurnStateMessage({
-            id: this.deps.newId(),
-            turnId,
-            ts,
-            status,
-            lineage,
-            ...(options.abortSource ? { abortSource: options.abortSource } : {}),
-            ...(options.errorClass !== undefined ? { errorClass: options.errorClass } : {}),
-            partialOutputRetained: await this.turnHasRetainedOutput(sessionId, turnId),
-        }));
-    }
-    async turnHasRetainedOutput(sessionId, turnId) {
-        const messages = await this.deps.store.readMessages(sessionId).catch(() => []);
-        return messagesHaveRetainedOutput(messages, turnId);
-    }
     async requireTurnForAction(sessionId, turnId, allowed, action) {
         const turn = (await this.getSessionView(sessionId)).turns.find((candidate) => candidate.turnId === turnId);
         if (!turn)
@@ -2989,46 +2912,40 @@ export class SessionManager {
         }
         return turn;
     }
-    async getSessionView(sessionId, projectionCache = this.deps.store) {
-        const repaired = new Set();
-        for (let attempt = 0; attempt < MAX_RUNTIME_LEDGER_REPAIR_ATTEMPTS; attempt += 1) {
-            try {
-                const view = await this.readModel(projectionCache).getSessionView(sessionId);
-                const runId = firstRuntimeRepairRunId(view.diagnostics, repaired);
-                if (!runId)
-                    return view;
-                if (!(await this.repairMissingTerminalFactOnce(sessionId, runId)))
-                    return view;
-                repaired.add(runId);
-            }
-            catch (error) {
-                if (!(error instanceof RuntimeReadModelError))
-                    throw error;
-                const runId = firstRuntimeRepairRunId(error.diagnostics, repaired);
-                if (!runId)
-                    throw error;
-                if (!(await this.repairMissingTerminalFactOnce(sessionId, runId)))
-                    throw error;
-                repaired.add(runId);
-            }
-        }
-        return this.readModel(projectionCache).getSessionView(sessionId);
+    /**
+     * The Session as its ledger tells it.
+     *
+     * A transcript written before the ledger owned execution facts is converted
+     * here, on the first read, because there is no second transcript left to read
+     * it from: the importer is what gives those turns an invocation to be
+     * projected from, so a read that skipped it would report the Session empty.
+     */
+    async getSessionView(sessionId) {
+        await this.ensureTranscriptLedgerForRead(sessionId);
+        return this.readModel().getSessionView(sessionId);
     }
-    readModel(projectionCache = this.deps.store) {
+    readModel() {
         if (!this.deps.runStore || !this.deps.runtimeEventStore) {
             throw new Error('RuntimeReadModel requires AgentRunStore and RuntimeEventStore');
         }
         return new RuntimeReadModel({
-            runStore: this.deps.runStore,
             runtimeEventStore: this.deps.runtimeEventStore,
-            projectionCache,
             ...(this.deps.canonicalPermissionOutcomes
                 ? { canonicalPermissionOutcomes: this.deps.canonicalPermissionOutcomes }
                 : {}),
         });
     }
-    async repairMissingTerminalFactOnce(sessionId, runId) {
-        return ((await this.runtimeLedgerRepair?.repairMissingTerminalFactOnce(sessionId, runId)) ?? false);
+    /**
+     * Convert a transcript written before the ledger owned execution facts, so a
+     * reader that goes straight to the ledger still sees the whole Session.
+     *
+     * Idempotent and cheap after the first call: the conversion is remembered per
+     * Session, and a Session born on the ledger has nothing to convert.
+     */
+    async ensureTranscriptLedgerForRead(sessionId) {
+        const repair = this.runtimeLedgerRepair;
+        if (repair)
+            await this.ensureTranscriptLedger(sessionId, repair, 'compatibility');
     }
     async prepareImportedSessionHistory(sessionId) {
         const repair = this.runtimeLedgerRepair;
@@ -3043,49 +2960,20 @@ export class SessionManager {
         if (header.transcriptLedgerVersion === 0 && source !== 'import') {
             throw new Error('Imported Session history is still being prepared');
         }
+        // Version 1 says a conversion ran, not that every legacy fact reached the
+        // ledger. A released build set it on the first send and went on writing
+        // context notes to the transcript alone, so those notes stay behind on
+        // Sessions it touched. Re-running the converter cannot reach them: they
+        // belong to turns a real run already sealed, and a sealed run refuses the
+        // append. They are hidden from the model and describe context, so they are
+        // the accepted cost of the cutover — do not read this marker as proof that
+        // nothing is left in `session_messages`.
         if (header.transcriptLedgerVersion !== 1) {
             await repair.materializeTranscriptLedger(header);
             await this.updateHeader(sessionId, { transcriptLedgerVersion: 1 });
         }
         this.preparedTranscriptLedgers.add(sessionId);
     }
-    async prepareConversationRuntimeLedgerClone(sourceSessionId, sourceView, copiedMessages) {
-        if (!this.deps.runStore || !this.deps.runtimeEventStore)
-            return undefined;
-        return prepareConversationRuntimeLedgerCopy({
-            sourceSessionId,
-            sourceEvents: sourceView.events,
-            copiedMessages,
-            runStore: this.deps.runStore,
-            runtimeEventStore: this.deps.runtimeEventStore,
-        });
-    }
-    async cloneConversationRuntimeLedger(childSessionId, copiedMessages, plan) {
-        if (!plan || !this.deps.runStore || !this.deps.runtimeEventStore)
-            return copiedMessages;
-        const copied = await cloneConversationLedger({
-            plan,
-            copiedMessages,
-            referenceMap: {
-                mode: 'preserve_external',
-                sourceSessionId: plan.sourceSessionId,
-                targetSessionId: childSessionId,
-            },
-            runStore: this.deps.runStore,
-            runtimeEventStore: this.deps.runtimeEventStore,
-            newId: this.deps.newId,
-        });
-        return copied.copiedMessages;
-    }
-    async rollbackLegacyConversationCopy(sessionId, error) {
-        try {
-            await this.deps.store.remove(sessionId);
-        }
-        catch (cleanupError) {
-            throw new AggregateError([error, cleanupError], `Conversation copy ${sessionId} failed and could not be removed`);
-        }
-        throw error;
-    }
     /**
      * Closes only the two provably pre-provider crash windows owned by B2:
      * claim-only and target-Run-created-without-start. A repaired claim never
@@ -3105,33 +2993,18 @@ export class SessionManager {
         let recovered = false;
         for (const initialState of states) {
             const { claim } = initialState;
-            let run;
-            try {
-                run = await this.deps.runStore.readRun(sessionId, claim.target.runId);
-            }
-            catch (error) {
-                if (!isMissingRunError(error))
-                    throw error;
-                try {
-                    await this.deps.runStore.createRun(claim.targetRunHeader, { durable: true });
-                    run = await this.deps.runStore.readRun(sessionId, claim.target.runId);
-                }
-                catch (createError) {
-                    try {
-                        run = await this.deps.runStore.readRun(sessionId, claim.target.runId);
-                    }
-                    catch {
-                        throw createError;
-                    }
-                }
-                recovered = true;
-            }
+            // The target's opening fact rides its continuation-start event, so an
+            // invocation that does not exist yet is exactly the case the repair
+            // start below commits. There is no separate run record to create.
+            const invocation = await this.readInvocation(sessionId, claim.target.runId).catch((error) => {
+                if (isMissingRunError(error))
+                    return undefined;
+                throw error;
+            });
             let state = (await authority.readContinuationClaimStateByBoundary(claim.boundaryDigest)) ??
                 initialState;
-            if (state.startEventId
-                ? !claimTargetRunHeaderIsCompatible(run, claim.targetRunHeader)
-                : !isDeepStrictEqual(run, claim.targetRunHeader)) {
-                throw new Error(`Continuation claim target Run header conflicts with claim ${claim.claimId}`);
+            if (invocation && !invocationMatchesClaimTarget(invocation, claim)) {
+                throw new Error(`Continuation claim target invocation conflicts with claim ${claim.claimId}`);
             }
             let targetEvents = await readImmutableRuntimeEventsOrEmpty(authority, claim.target.sessionId, claim.target.runId);
             if (!state.startEventId) {
@@ -3158,7 +3031,7 @@ export class SessionManager {
             const failureClass = 'continuation_abandoned_before_provider_dispatch';
             const expectedTerminal = buildRecoveredTerminalRuntimeEvent({
                 id: continuationRepairEventId('terminal', claim.claimId),
-                run,
+                run: claim.target,
                 status: 'failed',
                 ts: Math.max(start.ts + 1, claim.claimedAt + 1),
                 recoveryReason: failureClass,
@@ -3170,15 +3043,9 @@ export class SessionManager {
             if (terminal && !isDeepStrictEqual(terminal, expectedTerminal)) {
                 throw new Error(`Continuation claim ${claim.claimId} has a conflicting repair terminal`);
             }
-            const existingRunEvents = await this.deps.runStore.readEvents(claim.target.sessionId, claim.target.runId);
-            const projectionComplete = terminal !== undefined &&
-                run.status === 'failed' &&
-                run.failureClass === failureClass &&
-                existingRunEvents.some((event) => event.type === 'run_failed');
-            if (projectionComplete)
+            if (terminal)
                 continue;
             await commitTerminalRunWithRuntimeFact({
-                runStore: this.deps.runStore,
                 runtimeEventStore: authority,
                 newId: () => continuationRepairEventId('run-terminal', claim.claimId),
                 sessionId: claim.target.sessionId,
@@ -3188,12 +3055,6 @@ export class SessionManager {
                 ts: expectedTerminal.ts,
                 terminalEvent: expectedTerminal,
                 failureClass,
-                runEventData: {
-                    recovered: true,
-                    recoveryReason: failureClass,
-                    continuationClaimId: claim.claimId,
-                },
-                existingEvents: existingRunEvents,
             });
             recovered = true;
         }
@@ -3202,9 +3063,9 @@ export class SessionManager {
     async recoverAgentRunsFromLedger(sessionId, policy = { kind: 'best_effort' }) {
         if (!this.deps.runStore || !this.deps.runtimeEventStore)
             return { hasLedger: false, recovered: false };
-        const runs = policy.kind === 'strict'
-            ? await policy.stores.agentRunStore.listSessionRunsForRecovery(sessionId)
-            : await this.deps.runStore.listSessionRuns(sessionId);
+        // The importer may have committed only a prefix before a restart. Sealing
+        // that prefix here would make the next read skip the unconverted history.
+        const runs = (await this.listInvocations(sessionId)).filter((run) => !isTranscriptLedgerInvocation(run));
         if (runs.length === 0)
             return { hasLedger: false, recovered: false };
         const continuationAuthority = runtimeContinuationAuthority(this.deps.runtimeEventStore);
@@ -3233,7 +3094,7 @@ export class SessionManager {
             if (policy.kind === 'strict') {
                 await policy.stores.agentRunStore.readEventsForRecovery(sessionId, run.runId);
             }
-            let inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, { sessionId, runId: run.runId, header: run });
+            let inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, { sessionId, runId: run.runId, invocation: run });
             if (inspected.sourceHealth.runtimeLedger === 'read_failed') {
                 if (policy.kind === 'strict') {
                     throw new Error(`RuntimeEvent ledger is unreadable for run ${run.runId}`);
@@ -3245,6 +3106,14 @@ export class SessionManager {
                     diagnostic.code === 'operational_event_corrupt')) {
                 throw new Error(`AgentRun event ledger is unreadable for run ${run.runId}`);
             }
+            if (run.terminalEvent && runtimeHandoffPause(run.terminalEvent)) {
+                if (inspected.runtimeEvents.at(-1)?.id !== run.terminalEvent.id) {
+                    throw new Error(`Handoff source has events after its seal: ${run.runId}`);
+                }
+                // The original Root admission owns this logical execution. Generic
+                // restart repair must neither replay its tools nor manufacture failure.
+                continue;
+            }
             if (claimOwnedUnsettledRunIds.has(run.runId) &&
                 !inspected.runtimeEvents.some(isTerminalRuntimeEvent)) {
                 // Every unresolved claim target belongs to the claim saga. This
@@ -3253,7 +3122,7 @@ export class SessionManager {
                 continue;
             }
             if (this.runtimeCommitSink) {
-                const interruptedOutcomes = buildInterruptedCodeModeOutcomeCommits(inspected.runtimeEvents, this.deps.now(), run.toolMode ?? DEFAULT_TOOL_MODE);
+                const interruptedOutcomes = buildInterruptedCodeModeOutcomeCommits(inspected.runtimeEvents, this.deps.now(), run.opening.configuration.toolMode);
                 let outcomeCommitFailed = false;
                 for (const outcome of interruptedOutcomes) {
                     const committed = await commitInterruptedOutcomeWithRetry(policy, () => this.runtimeCommitSink.commitToolOutcome(outcome));
@@ -3270,23 +3139,13 @@ export class SessionManager {
                     continue;
                 }
                 if (interruptedOutcomes.length > 0) {
-                    inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, { sessionId, runId: run.runId, header: run });
+                    inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, { sessionId, runId: run.runId, invocation: run });
                 }
             }
             const terminalLedger = classifyTerminalRuntimeLedger(run, inspected.runtimeEvents);
-            if (terminalLedger.kind === 'ambiguous') {
+            if (terminalLedger.kind === 'corrupt') {
                 if (policy.kind === 'strict') {
-                    throw new Error(`RuntimeEvent ledger has ambiguous terminal facts for run ${run.runId}`);
-                }
-                continue;
-            }
-            if (isTerminalRunStatus(run.status) && !inspected.terminalRuntimeFact) {
-                const repaired = await this.repairMissingTerminalFactOnce(sessionId, run.runId);
-                if (repaired) {
-                    recovered = true;
-                }
-                else if (policy.kind === 'strict') {
-                    throw new Error(`Unable to repair the terminal RuntimeEvent fact for run ${run.runId}`);
+                    throw new Error(`RuntimeEvent ledger has more than one terminal event for run ${run.runId}`);
                 }
                 continue;
             }
@@ -3304,19 +3163,15 @@ export class SessionManager {
         return { hasLedger: true, recovered };
     }
     classifyRuntimeEventRecovery(inspected) {
-        if (isTerminalRunStatus(inspected.header.status) || !inspected.terminalRuntimeFact)
+        if (!inspected.terminalRuntimeFact)
             return undefined;
-        return runtimeTerminalFactToRecoveryDecision(inspected.header, inspected.terminalRuntimeFact);
+        return runtimeTerminalFactToRecoveryDecision(inspected.invocation, inspected.terminalRuntimeFact);
     }
     async applyAgentRunRecovery(sessionId, decision, inspected, policy = { kind: 'best_effort' }) {
         if (!this.deps.runStore || !this.deps.runtimeEventStore)
             return false;
         const ts = this.deps.now();
-        const terminalLedger = classifyTerminalRuntimeLedger(inspected.header, inspected.runtimeEvents);
-        const existingTerminal = inspected.terminalRuntimeFact?.terminalEvent ??
-            (terminalLedger.kind === 'incomplete_single_terminal'
-                ? terminalLedger.terminalEvent
-                : undefined);
+        const existingTerminal = inspected.terminalRuntimeFact?.terminalEvent;
         const status = existingTerminal
             ? (terminalRunStatusFromRuntimeEvent(existingTerminal) ?? decision.status)
             : decision.status;
@@ -3325,7 +3180,7 @@ export class SessionManager {
         const terminalEvent = existingTerminal ??
             buildRecoveredTerminalRuntimeEvent({
                 id: this.deps.newId(),
-                run: inspected.header,
+                run: inspected.invocation,
                 status,
                 ts,
                 recoveryReason: diagnosticRecoveryReason(decision.diagnostic),
@@ -3338,7 +3193,6 @@ export class SessionManager {
             });
         try {
             await commitTerminalRunWithRuntimeFact({
-                runStore: this.deps.runStore,
                 runtimeEventStore: this.deps.runtimeEventStore,
                 newId: this.deps.newId,
                 sessionId,
@@ -3349,8 +3203,6 @@ export class SessionManager {
                 terminalEvent,
                 ...(failureClass ? { failureClass } : {}),
                 ...(abortSource ? { abortSource } : {}),
-                runEventData: { recovered: true, ...decision.diagnostic },
-                existingEvents: inspected.events,
             });
         }
         catch (error) {
@@ -3358,25 +3210,11 @@ export class SessionManager {
                 throw error;
             return false;
         }
-        await recoverOr(policy, () => this.appendTerminalTurnStateIfNeeded(sessionId, inspected.header, decision, terminalTurnStatus(status), {
-            ts,
-            ...(failureClass ? { errorClass: failureClass } : {}),
-            ...(abortSource ? { abortSource } : {}),
-        }, policy), undefined);
-        return true;
+        // A run that already carried a complete terminal fact had nothing to
+        // recover. Saying otherwise makes recovery rewrite the Session status of
+        // every healthy run it walks past.
+        return inspected.terminalRuntimeFact === undefined;
     }
-    async appendTerminalTurnStateIfNeeded(sessionId, run, decision, status, options, policy = { kind: 'best_effort' }) {
-        if (!isSessionInlineRun(run))
-            return;
-        const messages = await recoverOr(policy, () => this.deps.store.readMessages(sessionId), []);
-        const latest = latestTurnState(messages, decision.turnId);
-        if (latest && isTerminalTurnStatus(latest.status) && latest.status === status)
-            return;
-        await this.appendTurnState(sessionId, decision.turnId, status, decision.lineage, options);
-    }
-}
-function planAbandonmentNoteId(operationId) {
-    return `plan-abandonment-${createHash('sha256').update(operationId).digest('hex')}`;
 }
 function resumeFeatureDisabledPlan() {
     return {
@@ -3440,6 +3278,8 @@ function buildContinuationRepairStartEvent(claim) {
         partial: false,
         role: 'system',
         author: 'system',
+        modelVisibility: 'hidden',
+        content: claim.targetOpening,
         actions: {
             continuationStart: {
                 protocol: 'continuation_start_v2',
@@ -3471,47 +3311,29 @@ function assertClaimOwnsHostedLinkedChildAdmission(input, claim) {
         claim.target.turnId !== input.turnId) {
         throw new Error('Linked child admission conflicts with its continuation claim target');
     }
-    const header = claim.targetRunHeader;
+    const { lineage, source: openSource } = claim.targetOpening;
     const source = claim.boundary.segments.at(-1);
-    const continuationSource = header.continuationSource;
-    const continuationSourceV2 = continuationSource !== undefined &&
-        'protocol' in continuationSource &&
-        continuationSource.protocol === 'continuation_source_v2'
-        ? continuationSource
-        : undefined;
-    if (header.sessionId !== claim.target.sessionId ||
-        header.invocationId !== claim.target.invocationId ||
-        header.runId !== claim.target.runId ||
-        header.turnId !== claim.target.turnId ||
-        header.status !== 'created' ||
-        header.agentId !== input.execution.agentId ||
-        header.agentName !== input.execution.agentName ||
+    if (lineage?.agentId !== input.execution.agentId ||
+        lineage.agentName !== input.execution.agentName ||
         source.identity.sessionId !== input.sessionId ||
         source.identity.runId !== input.execution.sourceRunId ||
-        !continuationSourceV2 ||
-        continuationSourceV2.claimId !== claim.claimId ||
-        continuationSourceV2.boundaryDigest !== claim.boundaryDigest ||
-        continuationSourceV2.sourceRunId !== input.execution.sourceRunId) {
+        openSource.kind !== 'continuation' ||
+        openSource.claimId !== claim.claimId ||
+        openSource.boundaryDigest !== claim.boundaryDigest ||
+        openSource.sourceRunId !== input.execution.sourceRunId) {
         throw new Error('Linked child admission continuation claim identity is inconsistent');
     }
     if (input.execution.kind === 'linked_child_resume'
-        ? header.resumedFromRunId !== input.execution.sourceRunId ||
-            header.retriedFromRunId !== undefined
-        : header.retriedFromRunId !== input.execution.sourceRunId ||
-            header.resumedFromRunId !== undefined) {
+        ? lineage.resumedFromRunId !== input.execution.sourceRunId ||
+            lineage.retriedFromRunId !== undefined
+        : lineage.retriedFromRunId !== input.execution.sourceRunId ||
+            lineage.resumedFromRunId !== undefined) {
         throw new Error('Linked child admission continuation lineage is inconsistent');
     }
 }
 async function readImmutableRuntimeEventsOrEmpty(authority, sessionId, runId) {
     return authority.readImmutableRuntimeEvents(sessionId, runId);
 }
-function claimTargetRunHeaderIsCompatible(actual, expected) {
-    const immutable = (header) => {
-        const { status: _status, updatedAt: _updatedAt, completedAt: _completedAt, failureClass: _failureClass, failureMessage: _failureMessage, abortSource: _abortSource, traceWriteError: _traceWriteError, ...rest } = header;
-        return rest;
-    };
-    return isDeepStrictEqual(immutable(actual), immutable(expected));
-}
 function isMissingRunError(error) {
     return (isNotFoundError(error) ||
         (error instanceof Error && /unknown run|run does not exist|missing run/i.test(error.message)));
@@ -3560,6 +3382,34 @@ export function headerToSummary(h) {
     }
     return summary;
 }
+/**
+ * What a listing shows about one invocation, read entirely off its own facts.
+ *
+ * Every field here used to be a mutable column on the Run header that a writer
+ * had to keep in step with the events. Deriving them means a listing cannot
+ * disagree with the ledger it is listing.
+ */
+function invocationListingFacts(invocation) {
+    const completedAt = invocation.terminalEvent?.ts;
+    const failureClass = runtimeInvocationFailureClass(invocation);
+    return {
+        status: runtimeInvocationOutcome(invocation) ?? 'running',
+        permissionMode: invocation.opening.configuration.permissionMode,
+        createdAt: invocation.openedAt,
+        updatedAt: completedAt ?? invocation.openedAt,
+        ...(completedAt !== undefined ? { completedAt } : {}),
+        ...(completedAt !== undefined
+            ? { durationMs: Math.max(0, completedAt - invocation.openedAt) }
+            : {}),
+        ...(failureClass ? { failureClass } : {}),
+    };
+}
+/** The most recently opened invocation, breaking ties on run id. */
+function latestInvocation(invocations) {
+    return invocations
+        .slice()
+        .sort((left, right) => right.openedAt - left.openedAt || right.runId.localeCompare(left.runId))[0];
+}
 function isNotFoundError(error) {
     return error instanceof Error && 'code' in error && error.code === 'ENOENT';
 }
@@ -3638,6 +3488,33 @@ function claimedAgentGraphIntentResult(claim, result) {
         ...result,
     };
 }
+function sessionConfigurationWithPermissionMode(header, permissionMode) {
+    return {
+        backend: header.backend,
+        ...(header.llmConnectionId === undefined ? {} : { llmConnectionId: header.llmConnectionId }),
+        llmConnectionSlug: header.llmConnectionSlug,
+        connectionLocked: header.connectionLocked,
+        model: header.model,
+        thinkingLevel: header.thinkingLevel,
+        permissionMode,
+        collaborationMode: header.collaborationMode ?? 'agent',
+        orchestrationMode: header.orchestrationMode ?? 'default',
+    };
+}
+function sessionConfigurationMatchesExceptPermissionMode(header, configuration) {
+    return (header.backend === configuration.backend &&
+        header.llmConnectionId === configuration.llmConnectionId &&
+        header.llmConnectionSlug === configuration.llmConnectionSlug &&
+        header.connectionLocked === configuration.connectionLocked &&
+        header.model === configuration.model &&
+        header.thinkingLevel === configuration.thinkingLevel &&
+        (header.collaborationMode ?? 'agent') === configuration.collaborationMode &&
+        (header.orchestrationMode ?? 'default') === configuration.orchestrationMode);
+}
+function sessionConfigurationMatches(header, configuration) {
+    return (header.permissionMode === configuration.permissionMode &&
+        sessionConfigurationMatchesExceptPermissionMode(header, configuration));
+}
 function executionBoundaryMatchesPermissionMode(boundary, mode) {
     if (mode === 'bypass')
         return boundary.kind === 'bypass';
@@ -3652,7 +3529,7 @@ function narrowsExecutionAuthority(boundary, nextPermissionMode) {
         return false;
     if (boundary.kind !== 'managed')
         return true;
-    return nextPermissionMode === 'explore' && boundary.profile.name !== 'read-only';
+    return (nextPermissionMode === 'explore' && !isCanonicalReadOnlyPermissionProfile(boundary.profile));
 }
 function agentRunStatusForSpawnResult(status) {
     if (status === 'waiting_for_user')
@@ -3661,7 +3538,7 @@ function agentRunStatusForSpawnResult(status) {
         return 'cancelled';
     if (status === 'failed')
         return 'failed';
-    if (status === 'running' || status === 'created')
+    if (status === 'running')
         return 'running';
     return 'completed';
 }
@@ -3729,92 +3606,16 @@ class ChildAgentSummaryAccumulator {
         this.textDeltaTail = this.textDeltaTail.slice(-CHILD_AGENT_SUMMARY_MAX_CHARS);
     }
 }
-function hasRevisionUserMessage(messages) {
-    let boundary = -1;
-    for (let index = 0; index < messages.length; index += 1) {
-        const message = messages[index];
-        if (message.type === 'system_note' &&
-            message.kind === 'session_start' &&
-            message.data &&
-            typeof message.data === 'object' &&
-            'revisionRootSessionId' in message.data) {
-            boundary = index;
-        }
-    }
-    return boundary >= 0 && messages.slice(boundary + 1).some((message) => message.type === 'user');
-}
-function interruptedTurnRecoveries(messages) {
-    const byTurn = new Map();
-    for (const message of messages) {
-        const turnId = message.turnId;
-        if (!turnId)
-            continue;
-        const bucket = byTurn.get(turnId) ?? { hasAssistant: false, states: [] };
-        if (message.type === 'assistant')
-            bucket.hasAssistant = true;
-        if (message.type === 'turn_state')
-            bucket.states.push(message);
-        byTurn.set(turnId, bucket);
-    }
-    const recoveries = [];
-    for (const [turnId, bucket] of byTurn) {
-        const latest = bucket.states.at(-1);
-        if (!latest)
-            continue;
-        if (latest.status === 'running') {
-            recoveries.push({
-                turnId,
-                errorClass: 'app_restarted',
-                lineage: turnStateLineage(latest),
-            });
-            continue;
-        }
-        const failed = [...bucket.states].reverse().find((state) => state.status === 'failed');
-        if (latest.status === 'completed' && !bucket.hasAssistant && failed) {
-            recoveries.push({
-                turnId,
-                errorClass: failed.errorClass ?? 'unknown',
-                lineage: turnStateLineage(failed),
-            });
-        }
-    }
-    return recoveries;
-}
-function turnStateLineage(state) {
-    return {
-        ...(state.parentTurnId ? { parentTurnId: state.parentTurnId } : {}),
-        ...(state.retriedFromTurnId ? { retriedFromTurnId: state.retriedFromTurnId } : {}),
-        ...(state.regeneratedFromTurnId ? { regeneratedFromTurnId: state.regeneratedFromTurnId } : {}),
-        ...(state.branchOfTurnId ? { branchOfTurnId: state.branchOfTurnId } : {}),
-        ...(state.parentSessionId ? { parentSessionId: state.parentSessionId } : {}),
-    };
-}
 function isTerminalRunStatus(status) {
     return status === 'completed' || status === 'failed' || status === 'cancelled';
 }
-function isTerminalTurnStatus(status) {
-    return status === 'completed' || status === 'failed' || status === 'aborted';
-}
-function terminalTurnStatus(status) {
-    if (status === 'cancelled')
-        return 'aborted';
-    return status;
-}
 function diagnosticRecoveryReason(diagnostic) {
     const recoveryReason = diagnostic?.recoveryReason;
     return typeof recoveryReason === 'string' && recoveryReason.length > 0
         ? recoveryReason
         : 'agent_run_recovery';
 }
-function latestTurnState(messages, turnId) {
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const message = messages[index];
-        if (message?.type === 'turn_state' && message.turnId === turnId)
-            return message;
-    }
-    return undefined;
-}
-function runtimeTerminalFactToRecoveryDecision(header, fact) {
+function runtimeTerminalFactToRecoveryDecision(invocation, fact) {
     return {
         runId: fact.runId,
         turnId: fact.turnId,
@@ -3826,19 +3627,22 @@ function runtimeTerminalFactToRecoveryDecision(header, fact) {
             runtimeEventId: fact.terminalEvent.id,
             runtimeEventStatus: fact.terminalEvent.status,
         },
-        lineage: headerLineage(header),
+        lineage: openingLineage(invocation),
     };
 }
-function headerLineage(header) {
+function openingLineage(invocation) {
+    const lineage = invocation.opening.lineage;
+    if (!lineage)
+        return {};
     return {
-        ...(header.parentRunId ? { parentRunId: header.parentRunId } : {}),
-        ...(header.parentTurnId ? { parentTurnId: header.parentTurnId } : {}),
-        ...(header.retriedFromTurnId ? { retriedFromTurnId: header.retriedFromTurnId } : {}),
-        ...(header.regeneratedFromTurnId
-            ? { regeneratedFromTurnId: header.regeneratedFromTurnId }
+        ...(lineage.parentRunId ? { parentRunId: lineage.parentRunId } : {}),
+        ...(lineage.parentTurnId ? { parentTurnId: lineage.parentTurnId } : {}),
+        ...(lineage.retriedFromTurnId ? { retriedFromTurnId: lineage.retriedFromTurnId } : {}),
+        ...(lineage.regeneratedFromTurnId
+            ? { regeneratedFromTurnId: lineage.regeneratedFromTurnId }
             : {}),
-        ...(header.branchOfTurnId ? { branchOfTurnId: header.branchOfTurnId } : {}),
-        ...(header.parentSessionId ? { parentSessionId: header.parentSessionId } : {}),
+        ...(lineage.branchOfTurnId ? { branchOfTurnId: lineage.branchOfTurnId } : {}),
+        ...(lineage.parentSessionId ? { parentSessionId: lineage.parentSessionId } : {}),
     };
 }
 function normalizeAgentOutputMaxEvents(value) {
@@ -3866,9 +3670,9 @@ function buildAgentOutputCommittedResult(input) {
                 {
                     operator: {
                         operatorId: input.graph.operatorId,
-                        sessionId: input.header.sessionId,
+                        sessionId: input.invocation.sessionId,
                     },
-                    run: input.header,
+                    run: input.invocation,
                     events: input.runtimeEvents,
                 },
             ],
@@ -3882,7 +3686,7 @@ function buildAgentOutputCommittedResult(input) {
     let artifactIds = tail(input.artifacts.map((artifact) => artifact.id), input.maxArtifacts);
     const base = () => ({
         schemaVersion: 1,
-        status: input.header.status,
+        status: runtimeInvocationOutcome(input.invocation) ?? 'running',
         ...(input.graph ? { graph: { ...input.graph } } : {}),
         ...(outputRecord || terminalRecord
             ? { resultRecordId: (outputRecord ?? terminalRecord).recordId }
@@ -3893,7 +3697,9 @@ function buildAgentOutputCommittedResult(input) {
         textTruncated: false,
         artifactIds,
         omittedArtifactIds: Math.max(0, input.artifacts.length - artifactIds.length),
-        ...(input.header.failureClass ? { failureClass: input.header.failureClass } : {}),
+        ...(runtimeInvocationFailureClass(input.invocation)
+            ? { failureClass: runtimeInvocationFailureClass(input.invocation) }
+            : {}),
     });
     while (artifactIds.length > 0 && serializedBytes(base()) > input.maxBytes) {
         artifactIds = artifactIds.slice(1);
@@ -3916,7 +3722,12 @@ function buildAgentOutputCommittedResult(input) {
             truncated: withoutText.omittedArtifactIds > 0,
         };
     }
-    const codePoints = Array.from(text);
+    const codePoints = [];
+    for (const point of text) {
+        if (codePoints.length >= input.maxBytes)
+            break;
+        codePoints.push(point);
+    }
     let low = 0;
     let high = codePoints.length;
     let best = { ...withoutText, textTruncated: true };