@chainingintention/pi-web-cn 1.202610.4 → 2.202610.0

package/dist/server/sessions/piSessionService.js

@@ -1,11 +1,23 @@
+import { parsePersistedChildSubsessionLink, parsePersistedParentSubsessionLink } from "./subsessionProvenance.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash, randomUUID } from "node:crypto";
+import { readSessionUiMetadata, requireSessionUiMetadata, SESSION_UI_METADATA_CUSTOM_TYPE } from "./sessionMetadata.js";
 import { UserFacingError, createTranslator, userFacingErrorMessage } from "../../shared/i18n.js";
 import { realpathSync, statSync } from "node:fs";
 import { clientSessionFirstMessagePreview } from "./clientSessionPreview.js";
 import { readFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEventBus, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, getAgentDir, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, loadSkills, ProjectTrustStore, hasTrustRequiringProjectResources, readStoredCredential, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { QueueCompatibilityGuard, mirroredQueueEntries, mutableQueueAgent, mutableTextMirror, parseQueueMessageMutation, queuedMessageAttachmentCount, queuedMessageAttachmentCounts, snapshotAgentQueues } from "./queuedMessageMutation.js";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEventBus, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, getAgentDir, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, loadSkills, ProjectTrustStore, hasTrustRequiringProjectResources, readStoredCredential, SessionManager, VERSION, } from "../../piSdk.js";
 import { projectBrowserMessage } from "../browserMessageProjection.js";
+import { projectTranscriptMarkdown } from "./transcriptMarkdown.js";
+import { messageHistoryTargetId } from "./messageHistoryTarget.js";
+import { normalSessionReadAllowed } from "./sessionReadAccess.js";
+import { isSessionMediaId } from "../../shared/sessionMedia.js";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
+import { McpAuthFlowService } from "./mcpAuthFlowService.js";
+import { mcpOAuthStorageDirectory } from "./mcpOAuthCredentialAdapter.js";
+import { getBuiltinExtensionFactories } from "./builtinExtensionFactories.js";
 import { eventScopeFromManagementContext, managementContextKey, NORMAL_SESSION_EVENT_SCOPE } from "../realtime/sessionEventScope.js";
 import { builtinCommands } from "./builtinCommands.js";
 import { loadNodeTranslator } from "../../localization.js";
@@ -13,8 +25,8 @@ import { SessionCommandService } from "./sessionCommandService.js";
 import { SessionActivityMarker } from "./sessionActivityMarker.js";
 import { projectSessionTree } from "./sessionTreeProjection.js";
 import { SessionArchiveStore } from "./sessionArchiveStore.js";
-import { findArchiveCandidateByIdOrPrefix, planSessionArchiveTree } from "./sessionArchiveTree.js";
-import { deterministicSessionName, fallbackSessionName, generateShortSessionName } from "./sessionNameGenerator.js";
+import { findArchiveCandidateByExactId, planSessionArchiveTree } from "./sessionArchiveTree.js";
+import { fallbackSessionName, generateShortSessionName, requireInitialSessionName } from "./sessionNameGenerator.js";
 import { computeEditPreview } from "./editPreview.js";
 import { attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachmentService.js";
 import { loadEffectiveProjectAttachmentsConfig } from "../workspaces/projectPiWebConfig.js";
@@ -35,7 +47,10 @@ import { DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS, piWebDataDir } from "../../config
 import { createScopedSettingsManager, resolveSettingsScopeDirectory } from "./projectSettingsScope.js";
 import { parseSessionDefaults, parseSessionDefaultsUpdate } from "../../shared/sessionDefaults.js";
 import { createAskUserToolDefinition } from "./askUserTool.js";
-import { PendingAskStore, renderAskUserAnswersText } from "./pendingAskStore.js";
+import { createAskUserOutcome, renderAskUserAnswersText, resolveAskUserRequest } from "./askUserDomain.js";
+import { createSubsessionCompletionDelivery } from "./subsessionCompletionDelivery.js";
+import { completionReceiptIds, persistedSubsessionCompletions, renderSubsessionCompletions, SUBSESSION_COMPLETION_ENTRY_TYPE, SUBSESSION_NOTIFICATION_CUSTOM_TYPE, SUBSESSION_RECEIPT_ENTRY_TYPE, SubsessionCompletionInbox } from "./subsessionCompletionInbox.js";
+import { createExtensionSessionDispatch } from "./extensionSessionDispatch.js";
 import { PendingExtensionDialogStore } from "./pendingExtensionDialogStore.js";
 import { ExtensionDialogWaiters, effectiveExtensionDialogTimeoutMs, extensionDialogCancelValue } from "./extensionDialogWaiters.js";
 import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
@@ -46,10 +61,10 @@ import { createManagedAgentToolOptions, createManagedBashToolDefinition, createM
 import { PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR, managementAgentToolNames, privilegedManagementToolNames, withRuntimeCreationEnvironment, writeManagementPermissionSystemPolicy } from "./managementPermissionSystem.js";
 import { SessionNotificationStore } from "./sessionNotificationStore.js";
 import { plainTextTheme } from "./plainTextTheme.js";
-import { deduplicateBundledRelaySkills, ensureManagedRelaySkills, MANAGED_RELAY_SKILL_NAMES } from "./relaySkill.js";
+import { deduplicateBundledRelaySkills, ensureManagedRelaySkills, MANAGED_RELAY_SKILL_NAMES, removeUnmodifiedManagedRelaySkills } from "./relaySkill.js";
 import { SessionUnreadStore } from "./sessionUnreadStore.js";
 import { archiveCandidateFromActiveSession, archiveCandidateFromArchivedRecord, archiveCandidateFromListEntry, archiveInputFromActiveSession, archiveInputFromCandidate, archiveInputFromListEntry, clientSessionFromArchivedRecord, } from "./sessionArchiveMapping.js";
-import { getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
+import { annotateAssistantStreamId, getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
 import { annotateAssistantThinkingLevel, historyMessagesFromEntries } from "./transcriptMessages.js";
 import { createWorkbenchToolDefinitions } from "../workbench/workbenchTools.js";
 import { applyEnabledModelToggle, catalogWithEnabledFirst, modelScopeId, persistedEnabledModelPatterns, resolveEnabledModelIds, resolveSessionModelOptions, scopedModelsFromEnabledIds } from "./sessionModelScope.js";
@@ -405,6 +420,7 @@ async function createNormalPermissionSessionServices(options) {
         resourceLoaderOptions: {
             ...piWebResourceLoaderOptions(options.appendSystemPromptSections),
             eventBus: options.eventBus,
+            extensionFactories: [...await getBuiltinExtensionFactories(options.mcpScope), ...(options.extensionFactories ?? [])],
             ...(options.agentsFilesOverride === undefined ? {} : { agentsFilesOverride: options.agentsFilesOverride }),
             skillsOverride: (base) => deduplicateBundledRelaySkills(cwd, base),
         },
@@ -422,11 +438,11 @@ async function createNormalPermissionSessionServices(options) {
     });
     return { services, projectTrustDiagnostics };
 }
-function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUser, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd, appendSystemPromptSections = [], managementAllowPrivileged = false) {
+function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled = false, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd, appendSystemPromptSections = [], managementAllowPrivileged = false) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, initialThinkingLevel, delegationToolsEnabled }) => {
         const scopedModelRuntime = managementContext === undefined ? await normalModelRuntimeForCwd(cwd) : await managementModelRuntime();
         if (managementContext !== undefined) {
-            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged, appendSystemPromptSections)({
+            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged, appendSystemPromptSections)({
                 cwd,
                 agentDir,
                 sessionManager,
@@ -449,6 +465,8 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
             // Only normal runtimes register a host connection; privileged management
             // packages keep their own event bus without exposing a normal-mode session.
             const eventBus = createEventBus();
+            let dispatchEnabled = false;
+            const sessionDispatch = createExtensionSessionDispatch(cwd, { ...(spawn === undefined ? {} : { spawn }), isEnabled: () => dispatchEnabled });
             const { services, projectTrustDiagnostics } = await createNormalPermissionSessionServices({
                 cwd,
                 agentDir,
@@ -457,6 +475,8 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
                 projectTrustRequiring,
                 appendSystemPromptSections,
                 eventBus,
+                mcpScope: { directory: mcpOAuthStorageDirectory(await resolveSettingsScope(cwd, "normal")) },
+                extensionFactories: [sessionDispatch, ...(subsessions === undefined ? [] : [createSubsessionCompletionDelivery(subsessions)])],
             });
             const modelOptions = await resolveSessionModelOptions({
                 services,
@@ -467,7 +487,8 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
             services.diagnostics.push(...modelOptions.diagnostics);
             const resolvedDelegationToolsEnabled = delegationToolsEnabled
                 ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
-            const customTools = createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions, askUser);
+            dispatchEnabled = resolvedDelegationToolsEnabled;
+            const customTools = createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions, askUserEnabled);
             const result = await createAgentSessionFromServices({
                 services,
                 sessionManager,
@@ -484,13 +505,15 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
         });
     };
 }
-function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged = false, appendSystemPromptSections = []) {
+function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged = false, appendSystemPromptSections = []) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled }) => {
         const normalPermissions = managementUsesNormalPermissions(managementContext, { allowPrivileged: managementAllowPrivileged });
         const privileges = managementPrivileges(managementContext, { allowPrivileged: managementAllowPrivileged });
         const resolvedDelegationToolsEnabled = delegationToolsEnabled
             ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
-        if (!normalPermissions)
+        if (normalPermissions)
+            await removeUnmodifiedManagedRelaySkills(cwd);
+        else
             await ensureManagedRelaySkills(cwd);
         const auditIdentity = await resolveManagementAuditIdentity(cwd, managementContext, managementProjectIdForCwd, logger);
         const accessHandle = workbenchAccessHandle(managementContext);
@@ -523,16 +546,19 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
             : {
                 spawn: (input) => subsessions.spawn({ ...input, managementContext }),
                 list: (parentSessionId, parentSessionFile) => subsessions.list(parentSessionId, parentSessionFile, managementContext),
-                check: (parentSessionId, sessionId, parentSessionFile) => subsessions.check(parentSessionId, sessionId, parentSessionFile, managementContext),
-                read: (parentSessionId, sessionId, query, parentSessionFile) => subsessions.read(parentSessionId, sessionId, query, parentSessionFile, managementContext),
+                join: (parentSessionId, parentSessionFile, toolCallId) => subsessions.join(parentSessionId, parentSessionFile, toolCallId, managementContext),
+                prepare: (parentSessionId, parentSessionFile) => subsessions.prepare(parentSessionId, parentSessionFile, managementContext),
+                check: (parentSessionId, sessionId, parentSessionFile, toolCallId) => subsessions.check(parentSessionId, sessionId, parentSessionFile, toolCallId, managementContext),
+                read: (parentSessionId, sessionId, query, parentSessionFile, toolCallId) => subsessions.read(parentSessionId, sessionId, query, parentSessionFile, toolCallId, managementContext),
             };
-        const scopedAskUser = askUser === undefined ? undefined : {
-            open: (input) => askUser.open({ ...input, managementContext }),
-        };
+        const managementFactories = [
+            ...(normalPermissions ? [createExtensionSessionDispatch(cwd, { ...(scopedSpawn === undefined ? {} : { spawn: scopedSpawn }), isEnabled: () => resolvedDelegationToolsEnabled })] : []),
+            ...(scopedSubsessions === undefined ? [] : [createSubsessionCompletionDelivery(scopedSubsessions)]),
+        ];
         const controlledManagementTools = [
             ...(resolvedDelegationToolsEnabled && scopedSpawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn: scopedSpawn }))] : []),
             ...(resolvedDelegationToolsEnabled && scopedSubsessions !== undefined ? createSubsessionToolDefinitions(cwd, scopedSubsessions).map((tool) => defineTool(tool)) : []),
-            ...(scopedAskUser === undefined ? [] : [createAskUserToolDefinition(scopedAskUser)]),
+            ...(askUserEnabled ? [createAskUserToolDefinition()] : []),
             ...workbenchTools,
         ];
         const controlledManagementToolNames = controlledManagementTools.map((tool) => tool.name);
@@ -563,6 +589,11 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
                 projectTrustRequiring: false,
                 appendSystemPromptSections,
                 eventBus: createEventBus(),
+                mcpScope: (() => {
+                    const directory = mcpOAuthStorageDirectory(settingsManager.piWebScopeKey, eventScopeFromManagementContext(managementContext));
+                    return { directory, configAgentDir: directory };
+                })(),
+                extensionFactories: managementFactories,
                 agentsFilesOverride: (base) => filterPrivilegedManagementContextFiles(cwd, managementContext, base),
             }) : { services: await createAgentSessionServices({
                     cwd,
@@ -570,6 +601,7 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
                     modelRuntime,
                     settingsManager,
                     resourceLoaderOptions: {
+                        extensionFactories: managementFactories,
                         agentsFilesOverride: (base) => filterManagedGlobalContextFiles(cwd, agentDir, base),
                         skillsOverride: (base) => receipt === undefined ? filterManagedProjectSkills(cwd, base, agentDir) : filterManagedWorkbenchSkills(cwd, base, receipt, agentDir),
                     },
@@ -581,7 +613,7 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
                 ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
             });
             services.diagnostics.push(...modelOptions.diagnostics);
-            const customTools = normalPermissions ? createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, scopedSpawn, scopedSubsessions, scopedAskUser) : [
+            const customTools = normalPermissions ? createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, scopedSpawn, scopedSubsessions, askUserEnabled) : [
                 ...managedAgentToolDefinitions(cwd, createManagedAgentToolOptions(cwd)),
                 createManagedPythonToolDefinition(cwd, managementContext, { network: privileges.network }),
                 createManagedBashToolDefinition(cwd, managementContext, { network: privileges.network, hostFilesystem: privileges.bash }),
@@ -601,7 +633,9 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
             // SDK reload re-executes extensions, so it needs the same scoped environment as startup.
             const reload = result.session.reload.bind(result.session);
             result.session.reload = (options) => withRuntimeCreationEnvironment(resourceEnvironment, async () => {
-                if (!normalPermissions)
+                if (normalPermissions)
+                    await removeUnmodifiedManagedRelaySkills(cwd);
+                else
                     await ensureManagedRelaySkills(cwd);
                 return reload(options);
             });
@@ -609,12 +643,12 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
         });
     };
 }
-export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions, askUser) {
+export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions, askUserEnabled = false) {
     return [
         ...managedAgentToolDefinitions(cwd),
         ...(delegationEnabled && spawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))] : []),
         ...(delegationEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool)) : []),
-        ...(askUser === undefined ? [] : [createAskUserToolDefinition(askUser)]),
+        ...(askUserEnabled ? [createAskUserToolDefinition()] : []),
     ];
 }
 function managedAgentToolDefinitions(cwd, options) {
@@ -655,6 +689,8 @@ export class PiSessionService {
         this.events = events;
         this.active = new Map();
         this.runtimeBySession = new WeakMap();
+        /** Media cold reads must not reopen files observed under a management identity. */
+        this.managementMediaFiles = new Set();
         this.pendingSessionOpens = new Map();
         /** Sessions whose extension binding is parked on a `session_start` dialog. */
         this.startupSessions = new Map();
@@ -664,6 +700,14 @@ export class PiSessionService {
         this.unpersistedTreeBranchLeaves = new WeakMap();
         /** Counts async operations that may append an entry before they settle. */
         this.sessionEntryMutationCounts = new WeakMap();
+        this.manualCompactionEnded = new WeakSet();
+        this.extensionCommandExecution = new AsyncLocalStorage();
+        this.runtimeMessageCounts = new WeakMap();
+        this.snapshotMessageCounts = new WeakMap();
+        this.pendingPromptEchoes = new WeakMap();
+        this.publishedAssistantPartials = new WeakMap();
+        this.assistantStreamIds = new WeakMap();
+        this.suggestedInputs = new Map();
         /** Serializes enabled-model read/modify/write operations. */
         this.modelScopeMutationQueue = Promise.resolve();
         /** Effective enabled-model state keyed by the project-scoped settings store. */
@@ -674,7 +718,10 @@ export class PiSessionService {
         /** Runtime/session-identity reservations for operations that must not overlap tree navigation. */
         this.treeExclusiveRuntimeOperationCounts = new WeakMap();
         this.treeExclusiveSessionOperationCounts = new Map();
-        this.deferredSubsessionNotifications = new WeakMap();
+        this.subsessionInboxes = new Map();
+        this.subsessionStoppedParents = new WeakSet();
+        this.subsessionDeliveringParents = new WeakSet();
+        this.subsessionDeliveryScheduled = new WeakSet();
         this.deferredGeneratedSessionNames = new WeakMap();
         this.compactionPromptQueues = new Map();
         this.compactionDrainTimers = new Map();
@@ -690,14 +737,19 @@ export class PiSessionService {
         /** Session file path -> its parsed header. Headers are written once, so successful reads are cached. */
         /**
          * Tracked subsession id -> whether a completion notification is armed.
-         * Armed when the child starts working; firing on completion disarms it so a
-         * child that works again (and stops again) notifies the parent each time.
+         * Armed by agent_start or early prompt failure, never standalone commands
+         * or compaction. Completion disarms the latch until the next run.
          */
         this.subsessionNotifyArmed = new Map();
+        this.queueCompatibility = new QueueCompatibilityGuard((session) => {
+            this.logger.info({ sessionId: session.sessionId, category: "incompatible-queue-interface" }, "Disabled SDK-dependent queue controls after an incompatible queue interface");
+        }, (key, fallback, values) => this.t(key, fallback, values));
         this.scopedNotificationStores = new Map();
         this.scopedUnreadStores = new Map();
         this.sessionEventScopes = new WeakMap();
         this.sessionManagementContexts = new WeakMap();
+        this.mcpAuthFlows = new McpAuthFlowService({ translator: (key, fallback, values) => this.t(key, fallback, values) });
+        this.mcpAuthOwners = new WeakMap();
         this.notificationGenerationBySession = new WeakMap();
         this.idleSessionFileResolutions = new WeakMap();
         /** The parked extension Promise resolvers behind the store's open dialogs. */
@@ -706,11 +758,13 @@ export class PiSessionService {
         this.unreadPublicationFlushRequested = false;
         this.unreadPublicationStopped = false;
         this.t = deps.translator ?? loadNodeTranslator("server");
+        this.managementAllowPrivileged = deps.managementAllowPrivileged === true;
         this.archiveStore = deps.archiveStore ?? new SessionArchiveStore();
         this.pinStore = deps.pinStore ?? new SessionPinStore(join(deps.dataDir ?? piWebDataDir(), "session-pins.json"));
         this.agentDir = deps.agentDir ?? getAgentDir();
         this.dataDir = deps.dataDir ?? piWebDataDir();
         this.projectPathForCwd = deps.projectPathForCwd;
+        this.managementProjectRoot = deps.managementProjectRoot;
         this.sessionManager = deps.sessionManager ?? createPiSessionManagerGateway({
             agentDir: this.agentDir,
             env: process.env,
@@ -739,7 +793,6 @@ export class PiSessionService {
         this.notificationStore = deps.notificationStore ?? new SessionNotificationStore();
         this.unreadStore = deps.unreadStore ?? new SessionUnreadStore();
         this.onUnreadChanged = deps.onUnreadChanged;
-        this.pendingAskStore = deps.pendingAskStore ?? new PendingAskStore();
         this.pendingExtensionDialogStore = deps.pendingExtensionDialogStore ?? new PendingExtensionDialogStore();
         this.extensionDialogsTimeoutMs = deps.extensionDialogsTimeoutMs ?? DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS;
         this.catalogRefreshStatus = deps.catalogRefreshStatus;
@@ -753,21 +806,26 @@ export class PiSessionService {
         this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.sessionEvents, this.normalModelRuntimeForCwd, this.managementModelRuntime, (cwd, mode) => this.resolveSettingsScopeDirectory(cwd, mode), this.sessionManager, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
             spawn: (input) => this.spawnSubsession(input),
             list: (parentSessionId, parentSessionFile, managementContext) => this.listSubsessions(parentSessionId, parentSessionFile, managementContext),
-            check: (parentSessionId, sessionId, parentSessionFile, managementContext) => this.checkSubsession(parentSessionId, sessionId, parentSessionFile, managementContext),
-            read: (parentSessionId, sessionId, query, parentSessionFile, managementContext) => this.readSubsession(parentSessionId, sessionId, query, parentSessionFile, managementContext),
-        }, deps.askUserEnabled === true ? { open: (input) => this.openAsk(input, input.managementContext) } : undefined, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd, deps.appendSystemPromptSections ?? [], deps.managementAllowPrivileged === true);
+            join: (parentSessionId, parentSessionFile, toolCallId, managementContext) => this.joinSubsessions(parentSessionId, parentSessionFile, toolCallId, managementContext),
+            prepare: (parentSessionId, parentSessionFile, managementContext) => this.prepareSubsessionDelivery(parentSessionId, parentSessionFile, managementContext),
+            check: (parentSessionId, sessionId, parentSessionFile, toolCallId, managementContext) => this.checkSubsession(parentSessionId, sessionId, parentSessionFile, toolCallId, managementContext),
+            read: (parentSessionId, sessionId, query, parentSessionFile, toolCallId, managementContext) => this.readSubsession(parentSessionId, sessionId, query, parentSessionFile, toolCallId, managementContext),
+        }, deps.askUserEnabled === true, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd, deps.appendSystemPromptSections ?? [], deps.managementAllowPrivileged === true);
         this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
         this.workspaceActivity = deps.workspaceActivity;
         this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
         this.commandService = new SessionCommandService((sessionId, eventScope) => this.getActiveForCommand(sessionId, eventScope), (sessionId, text, eventScope) => this.submitCommandPrompt(sessionId, text, eventScope), events, {
             onCompactionStart: (session) => {
                 this.beginSessionEntryMutation(session, this.t("session.action.compact", "compact the session"));
+                this.manualCompactionEnded.delete(session);
                 this.publishActivity(session, this.t("activity.compacting", "Compacting context"), "active");
                 this.publishStatus(session);
             },
             onCompactionEnd: (session, result, detail) => {
                 this.endSessionEntryMutation(session);
-                this.publishActivity(session, result === "success" ? this.t("activity.compacted", "Context compacted") : this.t("activity.compactionFailed", "Context compaction failed"), result === "success" ? "idle" : "error", detail);
+                if (!this.manualCompactionEnded.delete(session) && result === "error") {
+                    this.publishCompactionOutcome(session, { reason: "manual", errorMessage: this.t("command.compactionFailed", "Compaction failed: {value0}", { value0: detail ?? "Unknown error" }) });
+                }
                 this.publishStatus(session);
             },
             reloadSession: (session) => this.reloadSessionRuntime(session),
@@ -840,6 +898,7 @@ export class PiSessionService {
         });
     }
     async dispose() {
+        this.mcpAuthFlows.dispose();
         this.unreadPublicationStopped = true;
         this.clearUnreadPublicationRetry();
         clearInterval(this.heartbeat);
@@ -854,12 +913,12 @@ export class PiSessionService {
         const activeSessions = Array.from(new Set(this.active.values()));
         for (const active of activeSessions) {
             this.forgetUnreadActivity(active.runtime.session);
-            this.pendingAskStore.forgetSession(this.dialogSessionKey(active.runtime.session));
             this.endSessionExtensionDialogs(active.runtime.session);
         }
         this.active.clear();
         this.pendingSessionOpens.clear();
         this.startupSessions.clear();
+        this.suggestedInputs.clear();
         this.activities.clear();
         this.compactionPromptQueues.clear();
         this.authLossWarnings.clear();
@@ -868,6 +927,7 @@ export class PiSessionService {
         this.subsessionLinks.clear();
         this.subsessionHydratedParents.clear();
         this.subsessionNotifyArmed.clear();
+        this.subsessionInboxes.clear();
         this.notificationStore.clearAll("service-dispose");
         for (const store of this.scopedNotificationStores.values())
             store.clearAll("service-dispose");
@@ -881,7 +941,11 @@ export class PiSessionService {
             finally {
                 await active.runtime.dispose();
             }
-        })).finally(() => this.activityMarker.dispose());
+        })).finally(async () => {
+            this.extensionCommandExecution.disable();
+            this.events.mediaIndex.clear();
+            await this.activityMarker.dispose();
+        });
         await this.publishUnreadMutations([]);
     }
     async list(cwd, managementContext) {
@@ -942,7 +1006,27 @@ export class PiSessionService {
         for (const record of archivedForCwd) {
             this.publishNotificationMutations(this.notificationsForScope(eventScopeFromManagementContext(managementContext)).clearSession(record.sessionId, "archive-reconcile"));
         }
-        const unarchivedSessions = sessions.filter((session) => !archivedById.has(session.id)).map(clientSessionFromListEntry);
+        const unarchivedById = new Map(sessions.filter((session) => !archivedById.has(session.id)).map((session) => [session.id, clientSessionFromListEntry(session)]));
+        const eventScope = eventScopeFromManagementContext(managementContext);
+        for (const active of new Set(this.active.values())) {
+            if (active.eventScope !== eventScope)
+                continue;
+            const session = active.runtime.session;
+            if (!cwdPathsEqual(session.sessionManager.getCwd(), cwd) || archivedById.has(session.sessionId))
+                continue;
+            const listed = unarchivedById.get(session.sessionId);
+            const tracked = this.subsessionLinkForActiveChild(session) !== undefined;
+            if (listed !== undefined) {
+                if (tracked && session.sessionFile !== undefined && sessionPathsEqual(listed.path, session.sessionFile))
+                    listed.agentSubsession = true;
+                continue;
+            }
+            const info = clientSessionFromActiveSession(session);
+            if (tracked)
+                info.agentSubsession = true;
+            unarchivedById.set(session.sessionId, info);
+        }
+        const unarchivedSessions = [...unarchivedById.values()].sort((a, b) => Date.parse(b.modified) - Date.parse(a.modified));
         const reconcilableSessionIds = this.reconcilableSessionIds(cwd, unarchivedSessions.map((session) => session.id), archivedById);
         this.workspaceActivity?.reconcileSessionActivity(cwd, reconcilableSessionIds, eventScopeFromManagementContext(managementContext));
         if (managementContext === undefined) {
@@ -958,6 +1042,53 @@ export class PiSessionService {
             archivedById,
         };
     }
+    /** Read-only plugin catalog: do not open runtimes or reconcile unread/activity state. */
+    async listCatalogSessions(cwd, signal) {
+        signal?.throwIfAborted();
+        await this.assertNormalSessionReadAccess(cwd);
+        signal?.throwIfAborted();
+        const [entries, archives] = await Promise.all([this.sessionManager.list(cwd), this.archiveStore.list()]);
+        signal?.throwIfAborted();
+        const managementFiles = [...new Set(this.active.values())]
+            .filter((active) => active.eventScope !== NORMAL_SESSION_EVENT_SCOPE)
+            .map((active) => active.runtime.session.sessionFile)
+            .filter((path) => path !== undefined);
+        const archived = archives.filter((record) => cwdPathsEqual(record.cwd, cwd));
+        const archivedIds = new Set(archived.map((record) => record.sessionId));
+        const rows = new Map(entries.filter((entry) => !archivedIds.has(entry.id)
+            && !managementFiles.some((path) => sessionPathsEqual(path, entry.path))).map((entry) => [entry.id, clientSessionFromListEntry(entry)]));
+        const runtimes = new Map();
+        for (const active of new Set(this.active.values())) {
+            if (active.eventScope !== NORMAL_SESSION_EVENT_SCOPE)
+                continue;
+            const session = active.runtime.session;
+            if (!cwdPathsEqual(session.sessionManager.getCwd(), cwd) || archivedIds.has(session.sessionId))
+                continue;
+            const row = rows.get(session.sessionId);
+            // A disk clone with the same id must not inherit another file's runtime.
+            if (row !== undefined && (session.sessionFile === undefined || !sessionPathsEqual(row.path, session.sessionFile)))
+                continue;
+            runtimes.set(session.sessionId, session);
+            rows.set(session.sessionId, clientSessionFromActiveSession(session));
+        }
+        const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
+        for (const record of archived) {
+            const row = clientSessionFromArchivedRecord(record, entriesById.get(record.sessionId));
+            if (row !== undefined)
+                rows.set(row.id, row);
+        }
+        return [...rows.values()].sort((a, b) => Date.parse(b.modified) - Date.parse(a.modified)).map((row) => {
+            const runtime = runtimes.get(row.id);
+            return Object.freeze({
+                id: row.id,
+                cwd: row.cwd,
+                ...(row.name === undefined ? {} : { name: row.name }),
+                ...(row.metadata === undefined ? {} : { metadata: structuredClone(row.metadata) }),
+                archived: row.archived === true,
+                runtime: runtime === undefined ? "not-hosted" : this.hasActiveWork(runtime) ? "busy" : "idle",
+            });
+        });
+    }
     async start(cwd, options = {}) {
         if (options.managementContext === undefined)
             await this.normalModelRuntimeForCwd(cwd);
@@ -998,26 +1129,32 @@ export class PiSessionService {
             throw error;
         }
     }
-    announceCreatedSession(active, cwd, parentSession) {
+    announceCreatedSession(active, cwd, parentSession, agentSubsession) {
         const { session } = active.runtime;
         const created = {
-            id: session.sessionId,
-            path: session.sessionFile ?? "",
+            ...clientSessionFromActiveSession(session),
             cwd,
-            persisted: sessionFileExists(session.sessionFile),
-            created: new Date().toISOString(),
-            modified: new Date().toISOString(),
-            messageCount: session.messages.length,
-            firstMessage: "",
-            // Include the parent so listeners can nest the new session in the tree
-            // immediately, instead of showing it flat until the next reload.
             ...(parentSession === undefined ? {} : { parentSessionPath: parentSession }),
+            ...(agentSubsession === true ? { agentSubsession: true } : {}),
         };
         this.events.publishGlobal({ type: "session.created", session: created }, active.eventScope);
         return created;
     }
     async startSession(cwd, options) {
-        const active = await this.create(this.sessionManager.create(cwd, options.parentSession === undefined ? undefined : { parentSession: options.parentSession }), cwd, {
+        const metadata = options.metadata === undefined ? undefined : requireSessionUiMetadata(options.metadata);
+        const name = options.name === undefined ? undefined : requireInitialSessionName(options.name);
+        const manager = this.sessionManager.create(cwd, options.parentSession === undefined ? undefined : { parentSession: options.parentSession });
+        if (metadata !== undefined) {
+            if (manager.appendCustomEntry === undefined)
+                throw new UserFacingError("session.metadataUnsupported", "Session manager does not support UI metadata initialization");
+            manager.appendCustomEntry(SESSION_UI_METADATA_CUSTOM_TYPE, { version: 1, metadata });
+        }
+        if (name !== undefined) {
+            if (manager.appendSessionInfo === undefined)
+                throw new UserFacingError("session.initialNameUnsupported", "Session manager does not support initial naming");
+            manager.appendSessionInfo(name);
+        }
+        const active = await this.create(manager, cwd, {
             ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
             ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
@@ -1025,7 +1162,9 @@ export class PiSessionService {
             ...(options.startupToken === undefined ? {} : { startupToken: options.startupToken }),
             startupIntent: "create",
         });
-        return this.announceCreatedSession(active, cwd, options.parentSession);
+        return options.deferAnnouncement === true
+            ? clientSessionFromActiveSession(active.runtime.session)
+            : this.announceCreatedSession(active, cwd, options.parentSession);
     }
     /**
      * Start a new session on behalf of a LLM and deliver an initial prompt to it.
@@ -1047,6 +1186,8 @@ export class PiSessionService {
         const created = await this.start(decision.cwd, {
             ...(model === undefined ? {} : { initialModel: model }),
             ...(input.thinkingLevel === undefined ? {} : { initialThinkingLevel: input.thinkingLevel }),
+            ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+            ...(input.name === undefined ? {} : { name: input.name }),
             ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
         });
         const modelUsed = this.activeForLookup(created.id, input.managementContext)?.runtime.session.model;
@@ -1081,6 +1222,7 @@ export class PiSessionService {
             ...(input.thinkingLevel === undefined ? {} : { initialThinkingLevel: input.thinkingLevel }),
             ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
             creationProvenance: "tracked-subsession",
+            deferAnnouncement: true,
         });
         const modelUsed = this.activeForLookup(created.id, input.managementContext)?.runtime.session.model;
         const parentSessionFile = nonEmptyString(input.parentSessionFile);
@@ -1094,6 +1236,10 @@ export class PiSessionService {
         const scopedLink = await this.registerVerifiedSubsession(link, input.managementContext);
         this.persistSubsessionLink(scopedLink);
         this.persistSubsessionChildMarker(scopedLink);
+        const active = this.activeForLookup(created.id, input.managementContext);
+        if (active === undefined)
+            throw new Error("Created subsession is no longer active");
+        this.announceCreatedSession(active, decision.cwd, input.parentSessionFile, this.subsessionLinkForActiveChild(active.runtime.session) !== undefined);
         await this.prompt(created.id, input.prompt, undefined, undefined, {
             ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
         });
@@ -1219,85 +1365,22 @@ export class PiSessionService {
             throw unknownSpawnModelError(modelSpec, this.t);
         return model;
     }
-    /**
-     * Register the question set an agent wants the user to answer as the session's
-     * open ask. Deliberately does not wait for the user: `ask_user` terminates the
-     * run and the submitted answers come back later as a follow-up message.
-     *
-     * Rejected question sets throw {@link PendingAskValidationError}, which the
-     * agent loop reports to the model as an error tool result.
-     */
-    // eslint-disable-next-line @typescript-eslint/require-await -- async so a rejected question set becomes a rejection rather than a synchronous throw from a promise-returning method.
-    async openAsk(input, managementContext) {
-        const scope = eventScopeFromManagementContext(managementContext);
-        const sessionKey = scope === NORMAL_SESSION_EVENT_SCOPE ? input.sessionId : activeSessionKey(input.sessionId, scope);
-        const result = this.pendingAskStore.open({ ...input, sessionId: sessionKey });
-        // A supersede closes the earlier ask, so the browsers watching it must hear
-        // that before they hear about its replacement.
-        if (result.superseded !== undefined)
-            this.publishAskClosed(input.sessionId, result.superseded, scope);
-        this.events.publish(input.sessionId, { type: "ask.opened", ask: result.ask }, scope);
-        this.publishStatusForSessionId(input.sessionId, scope);
-        return result;
-    }
-    /**
-     * Record the user's answers to the session's open ask and hand them to the
-     * model. The answers travel as a system-authored custom message rather than a
-     * user message, so they are not attributed to the human in the transcript;
-     * they still wake an idle session (`triggerTurn`) and queue behind in-flight
-     * work (`deliverAs: "followUp"`), which is how the run that `ask_user`
-     * terminated continues.
-     */
+    /** Reply to a durable request on the active branch; repeated answers remain ordinary replies. */
     async submitAsk(ref, askId, submission, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
-        // Checked before the store closes the ask so a refused delivery cannot
-        // discard answers the user already submitted.
         this.assertTreeNavigationInactive(session, this.t("session.action.answer", "answer questions"));
-        return this.closeAsk(session, this.pendingAskStore.submit(this.dialogSessionKey(session), askId, submission));
+        const ask = resolveAskUserRequest(await this.readableSessionBranch(session), askId);
+        const outcome = createAskUserOutcome(ask, submission, this.now().toISOString());
+        return this.deliverAskOutcome(session, outcome);
     }
-    /**
-     * Close the open ask without answers. The model is still told, naming every
-     * question as unanswered: it was promised a follow-up message and would
-     * otherwise wait for one that never comes.
-     */
+    /** Record a skip as a new reply without consuming the original request. */
     async cancelAsk(ref, askId, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
-        this.assertTreeNavigationInactive(session, this.t("session.action.dismiss", "dismiss questions"));
-        return this.closeAsk(session, this.pendingAskStore.cancel(this.dialogSessionKey(session), askId));
-    }
-    /**
-     * Publish and deliver a closed ask. A stale close is reported rather than
-     * thrown: losing the race against a supersede, another browser, or a session
-     * that went away is ordinary, and the returned status tells the browser what
-     * the session's open ask is now.
-     */
-    async closeAsk(session, result) {
-        if (result.status === "stale")
-            return { result: "stale", sessionStatus: this.statusFromSession(session) };
-        const { outcome } = result;
-        this.publishAskClosed(session.sessionId, outcome, this.eventScopeForSession(session));
-        await this.runSessionEntryMutation(session, this.t("server.main.07f784061918", "deliver answers to your questions"), () => session.sendCustomMessage({ customType: ASK_USER_ANSWERS_CUSTOM_TYPE, content: renderAskUserAnswersText(outcome), display: true, details: outcome }, { triggerTurn: true, deliverAs: "followUp" }));
-        this.publishStatus(session);
-        return { result: "closed", outcome, sessionStatus: this.statusFromSession(session) };
-    }
-    publishAskClosed(sessionId, outcome, scope) {
-        this.events.publish(sessionId, { type: "ask.closed", askId: outcome.askId, reason: outcome.reason }, scope);
-    }
-    /**
-     * Void the session's open ask because the user sent a chat message instead of
-     * answering it. Every browser closes the card as cancelled, and the model is
-     * told — without being woken — so the notice rides into the turn the message
-     * itself triggers rather than becoming a turn of its own.
-     */
-    async voidOpenAskForUserMessage(session) {
-        const outcome = this.pendingAskStore.cancelOpen(this.dialogSessionKey(session));
-        if (outcome === undefined)
-            return;
-        this.publishAskClosed(session.sessionId, outcome, this.eventScopeForSession(session));
-        await this.runSessionEntryMutation(session, this.t("server.main.90b5a8ac7c7d", "void the open questions"), () => session.sendCustomMessage({ customType: ASK_USER_ANSWERS_CUSTOM_TYPE, content: renderAskUserAnswersText(outcome), display: true, details: outcome }, { triggerTurn: false, deliverAs: "followUp" }));
-        this.publishStatus(session);
+        this.assertTreeNavigationInactive(session, this.t("session.action.dismiss", "skip questions"));
+        const ask = resolveAskUserRequest(await this.readableSessionBranch(session), askId);
+        return this.deliverAskOutcome(session, createAskUserOutcome(ask, undefined, this.now().toISOString()));
     }
     /**
      * Record the user's answer to an open extension dialog and resolve the
@@ -1306,7 +1389,7 @@ export class PiSessionService {
      * (or an idle handler), so no custom message and no turn are triggered.
      */
     async answerDialog(ref, dialogId, value, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.sessionForStatusOrDialogClose(ref, managementContext);
         const result = this.pendingExtensionDialogStore.answer(this.dialogSessionKey(session), dialogId, value);
         if (result.status === "stale")
@@ -1320,7 +1403,7 @@ export class PiSessionService {
     }
     /** Close an open extension dialog without an answer; the extension's wait settles with its kind's cancel value. */
     async cancelDialog(ref, dialogId, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.sessionForStatusOrDialogClose(ref, managementContext);
         const result = this.pendingExtensionDialogStore.cancel(this.dialogSessionKey(session), dialogId, "cancelled");
         if (result.status === "stale")
@@ -1439,27 +1522,41 @@ export class PiSessionService {
         return Promise.all(authorizedChildIds.map(async (childId) => ({ sessionId: childId, ...(await this.subsessionSummaryFields(childId, scope)) })));
     }
     /** Status and final result of a subsession, scoped to the caller's children. */
-    async checkSubsession(parentSessionId, sessionId, parentSessionFile, managementContext) {
+    async checkSubsession(parentSessionId, sessionId, parentSessionFile, toolCallId, managementContext) {
+        const scope = eventScopeFromManagementContext(managementContext);
         const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext);
+        // Finalize the same completion even if its event/heartbeat notification has
+        // not run yet. Inspection must not leave a future notice armed for this run.
+        this.reconcileSubsessionCompletion(session);
+        const status = this.subsessionStatus(session);
         const messages = historyMessages(session);
+        const completion = this.subsessionCompletionForOutput(parentSessionId, parentSessionFile, session, messages, scope);
+        if (status !== "working" && completion !== undefined)
+            this.receiveSubsessionCompletions(parentSessionId, parentSessionFile, [completion], toolCallId, scope);
         return {
             sessionId,
             cwd: session.sessionManager.getCwd(),
-            status: this.subsessionStatus(session),
+            status,
             finalText: finalAssistantText(messages),
             messageCount: messages.length,
+            ...(status === "working" || completion?.errorDetail === undefined ? {} : { errorDetail: completion.errorDetail }),
         };
     }
     /** Filtered, paginated transcript of a subsession, scoped to the caller's children. */
-    async readSubsession(parentSessionId, sessionId, query, parentSessionFile, managementContext) {
+    async readSubsession(parentSessionId, sessionId, query, parentSessionFile, toolCallId, managementContext) {
+        const scope = eventScopeFromManagementContext(managementContext);
         const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext);
-        const view = buildTranscriptView(historyMessages(session), query);
-        return {
-            sessionId,
-            cwd: session.sessionManager.getCwd(),
-            status: this.subsessionStatus(session),
-            ...view,
-        };
+        this.reconcileSubsessionCompletion(session);
+        const messages = historyMessages(session);
+        const view = buildTranscriptView(messages, query);
+        const status = this.subsessionStatus(session);
+        const completion = this.subsessionCompletionForOutput(parentSessionId, parentSessionFile, session, messages, scope);
+        const errorDetail = status === "working" ? undefined : completion?.errorDetail;
+        if (status !== "working" && completion !== undefined
+            && (transcriptReturnsFinalOutput(messages, view, completion.finalText) || (completion.finalText === "" && errorDetail !== undefined))) {
+            this.receiveSubsessionCompletions(parentSessionId, parentSessionFile, [completion], toolCallId, scope);
+        }
+        return { sessionId, cwd: session.sessionManager.getCwd(), status, ...view, ...(errorDetail === undefined ? {} : { errorDetail }) };
     }
     /** Open a session after verifying it is one of the caller's tracked children. */
     async openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext) {
@@ -1514,6 +1611,14 @@ export class PiSessionService {
         this.subsessionLinks.set(childKey, scopedLink);
         if (!this.subsessionNotifyArmed.has(childKey))
             this.subsessionNotifyArmed.set(childKey, false);
+        const childManager = this.activeChildForSubsessionLink(scopedLink)?.runtime.session.sessionManager
+            ?? (link.childSessionFile === undefined ? undefined : this.sessionManager.open(link.childSessionFile));
+        if (childManager !== undefined) {
+            for (const completion of persistedSubsessionCompletions(childManager.getEntries?.() ?? childManager.getBranch())) {
+                if (completion.sessionId === childSessionId)
+                    this.subsessionInbox(parentSessionId, link.parentSessionFile, scope).record(completion);
+            }
+        }
         const cwd = this.cwdForVerifiedSubsession(scopedLink);
         await this.publishUnreadMutations(this.unreadForScope(scope).excludeSession(childSessionId, cwd));
         return scopedLink;
@@ -1540,6 +1645,10 @@ export class PiSessionService {
         this.subsessionParents.delete(childKey);
         this.subsessionLinks.delete(childKey);
         this.subsessionNotifyArmed.delete(childKey);
+        for (const [key, inbox] of this.subsessionInboxes) {
+            if (key.startsWith(activeSessionKey(parentSessionId ?? "", scope) + "\0"))
+                inbox.forgetChild(childSessionId);
+        }
         if (parentSessionId === undefined)
             return;
         const parentKey = activeSessionKey(parentSessionId, scope);
@@ -1696,34 +1805,72 @@ export class PiSessionService {
             return active !== undefined && this.hasActiveWork(active.runtime.session);
         });
     }
-    /**
-     * Drive parent notifications from a tracked child's status. Arms a pending
-     * notification while the child is working, and when it stops fires a single
-     * follow-up message to the parent via {@link prompt} (which queues if the
-     * parent is busy and delivers immediately when it is idle).
-     */
-    updateSubsessionTracking(session) {
+    /** Persist one immutable result per agent run, shared by all delivery paths. */
+    updateSubsessionTracking(session, agentStarted = false, agentSettled = false) {
         const link = this.subsessionLinkForActiveChild(session);
         if (link === undefined)
             return;
         const childId = link.childSessionId;
         const childKey = activeSessionKey(childId, link.eventScope);
-        if (this.hasActiveWork(session)) {
+        if (agentStarted) {
             this.subsessionNotifyArmed.set(childKey, true);
             return;
         }
+        // Native settlement is authoritative even while the host prompt Promise's
+        // mutation receipt is unwinding. Capture now, before another run can start.
+        if (!agentSettled && this.hasActiveWork(session))
+            return;
         if (this.subsessionNotifyArmed.get(childKey) !== true)
             return;
+        const activity = this.activityForSession(session);
+        const messages = historyMessages(session);
+        const completion = {
+            completionId: randomUUID(), sessionId: childId, cwd: session.sessionManager.getCwd(),
+            status: activity?.phase === "error" ? "error" : "idle",
+            finalText: finalAssistantText(messages), messageCount: messages.length,
+            ...(activity?.phase !== "error" || activity.detail === undefined ? {} : { errorDetail: activity.detail }),
+        };
+        try {
+            session.sessionManager.appendCustomEntry?.(SUBSESSION_COMPLETION_ENTRY_TYPE, completion);
+        }
+        catch (error) {
+            // Keep the latch armed so a later reconciliation can retry persistence.
+            this.logSubsessionNotificationFailure(link.parentSessionId, childId, error);
+            return;
+        }
         this.subsessionNotifyArmed.set(childKey, false);
-        const status = this.activityForSession(session)?.phase === "error" ? "error" : "idle";
-        const finalText = finalAssistantText(historyMessages(session));
-        const outputSection = formatSubsessionNotificationOutput(childId, finalText);
-        const workingIds = this.workingSubsessionIds(link.parentSessionId, link.eventScope);
-        const next = workingIds.length === 0
-            ? "No other tracked subsessions are working."
-            : `Still working: ${workingIds.join(", ")}. Continue working, or call yield_to_subsessions alone and last at the next join point. Further completion notices arrive automatically; do not poll.`;
-        const text = `Subsession ${childId} stopped working (${status}).\n${next}\n\n${outputSection}`;
-        void this.notifyParentOfSubsession(link, text);
+        this.subsessionInbox(link.parentSessionId, link.parentSessionFile, link.eventScope).record(completion);
+        void this.wakeParentForSubsession(link);
+    }
+    async wakeParentForSubsession(link) {
+        try {
+            const session = await this.getOrOpenParentForSubsession(link);
+            this.scheduleSubsessionDelivery(session);
+        }
+        catch (error) {
+            this.logSubsessionNotificationFailure(link.parentSessionId, link.childSessionId, error);
+        }
+    }
+    subsessionReceiptOwner(session) {
+        return {
+            parentSessionId: session.sessionId,
+            parentSessionFile: session.sessionFile ?? null,
+            scopeHash: createHash("sha256").update(this.eventScopeForSession(session)).digest("hex"),
+        };
+    }
+    subsessionReceiptMatches(session, entry) {
+        if (!isRecord(entry))
+            return true;
+        const data = entry["type"] === "custom" && entry["customType"] === SUBSESSION_RECEIPT_ENTRY_TYPE
+            ? entry["data"] : entry["type"] === "custom_message" && entry["customType"] === SUBSESSION_NOTIFICATION_CUSTOM_TYPE ? entry["details"] : undefined;
+        if (!isRecord(data))
+            return true;
+        const owner = data["receiptOwner"];
+        if (owner === undefined)
+            return this.eventScopeForSession(session) === NORMAL_SESSION_EVENT_SCOPE;
+        const expected = this.subsessionReceiptOwner(session);
+        return isRecord(owner) && owner["parentSessionId"] === expected.parentSessionId
+            && owner["parentSessionFile"] === expected.parentSessionFile && owner["scopeHash"] === expected.scopeHash;
     }
     async getOrOpenParentForSubsession(link) {
         const { parentSessionId } = link;
@@ -1741,33 +1888,98 @@ export class PiSessionService {
             ...(link.managementContext === undefined ? {} : { managementContext: link.managementContext }),
         })).runtime.session;
     }
-    /**
-     * Deliver a subsession-completion notice to the parent as a system-authored
-     * custom message rather than a user message, so it is not attributed to the
-     * human in the transcript. It still wakes an idle parent (`triggerTurn`) and
-     * queues behind in-flight work (`deliverAs: "followUp"`), preserving the
-     * established "queue if busy, send and act if idle" behavior.
-     */
-    async notifyParentOfSubsession(link, text) {
-        const { parentSessionId: parentId, childSessionId: childId } = link;
-        try {
-            const session = await this.getOrOpenParentForSubsession(link);
-            if (this.treeNavigations.has(session)) {
-                const pending = this.deferredSubsessionNotifications.get(session) ?? [];
-                pending.push({ parentId, childId, text });
-                this.deferredSubsessionNotifications.set(session, pending);
-                return;
-            }
-            await this.deliverSubsessionNotification(session, { parentId, childId, text });
-        }
-        catch (error) {
-            this.logSubsessionNotificationFailure(parentId, childId, error);
-        }
+    browserTranscriptMessage(session, message) {
+        return projectTranscriptMarkdown(message, session.extensionRunner.getMarkdownTransformers?.() ?? [], (_error, transformerIndex) => {
+            this.logger.info({ sessionId: session.sessionId, transformerIndex, category: "markdown-transformer-failed" }, "Transcript Markdown transformer failed");
+        });
+    }
+    async transcriptSnapshot(ref, page, managementContext) {
+        const session = await this.getOrOpen(ref, managementContext);
+        const seqBeforeRead = this.events.currentSeq(session.sessionId, this.eventScopeForSession(session));
+        const activeAtCapture = this.hasActiveWork(session);
+        const diskBranch = activeAtCapture ? undefined : await this.readableSessionBranch(session);
+        // Disk reads yield, even if a whole turn starts AND ends while they run.
+        // From the final runtime read through the watermark capture nothing may yield.
+        const branch = diskBranch === undefined || this.hasActiveWork(session) || this.events.currentSeq(session.sessionId, this.eventScopeForSession(session)) !== seqBeforeRead
+            ? session.sessionManager.getBranch()
+            : diskBranch;
+        const messages = historyMessagesFromEntries(branch);
+        const userCount = messages.filter((message) => isRecord(message) && message["role"] === "user").length;
+        const echoes = (this.pendingPromptEchoes.get(session) ?? []).filter((echo) => echo.userIndex >= userCount);
+        messages.push(...echoes.map((echo) => echo.message));
+        const messagePage = pageMessagesAtSafeBoundary(messages, page);
+        return {
+            page: { ...messagePage, messages: messagePage.messages.map((message) => this.browserTranscriptMessage(session, message)), leafId: session.sessionManager.getLeafId() },
+            status: this.statusFromSession(session, transcriptMessageCount(branch) + echoes.length),
+            seq: this.events.currentSeq(session.sessionId, this.eventScopeForSession(session)),
+            partial: this.publishedAssistantPartials.get(session) ?? null,
+        };
     }
     async messages(ref, page, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
         const branch = await this.readableSessionBranch(session);
-        return { ...pageMessagesAtSafeBoundary(historyMessagesFromEntries(branch), page), leafId: session.sessionManager.getLeafId() };
+        const messagePage = pageMessagesAtSafeBoundary(historyMessagesFromEntries(branch), page);
+        return { ...messagePage, messages: messagePage.messages.map((message) => this.browserTranscriptMessage(session, message)), leafId: session.sessionManager.getLeafId() };
+    }
+    async media(ref, mediaId, managementContext) {
+        if (!isSessionMediaId(mediaId))
+            throw new Error(this.t("session.media.invalidId", "Invalid media id"));
+        if (managementContext === undefined)
+            await this.assertNormalSessionReadAccess(ref.cwd);
+        const index = this.events.mediaIndex;
+        const session = this.activeForLookup(ref, managementContext)?.runtime.session ?? this.startupSessionForLookup(ref, managementContext);
+        const eventScope = eventScopeFromManagementContext(managementContext);
+        const unavailable = () => new Error(this.t("routing.sessionNotFound", "Session not found"));
+        // No durable management ownership marker exists. Management binary reads
+        // require an already-hosted owner rather than inferring identity from disk.
+        if (managementContext !== undefined && session === undefined)
+            throw unavailable();
+        const assertVisible = (path) => {
+            if (eventScope !== NORMAL_SESSION_EVENT_SCOPE)
+                return;
+            if (session === undefined && ([...this.active.values()].some((active) => active.eventScope !== eventScope && active.runtime.session.sessionId === ref.id && lookupMatchesActiveSession(ref, active))
+                || [...this.startupSessions.values()].some((startup) => startup.eventScope !== eventScope && startup.session.sessionId === ref.id && lookupMatchesStartupSession(ref, startup.session))))
+                throw unavailable();
+            if (path !== undefined && [...this.managementMediaFiles].some((managed) => sessionPathsEqual(managed, path)))
+                throw unavailable();
+        };
+        assertVisible(session?.sessionFile ?? session?.sessionManager.getSessionFile());
+        // Verify session/cwd ownership before consulting the session-scoped cache.
+        // Cold binary reads do not construct an SDK runtime (which can migrate files).
+        const archived = session === undefined ? await this.getArchived(ref) : undefined;
+        const resolved = session === undefined && archived?.archivePath === undefined
+            ? await this.sessionManager.resolveSessionFile(ref.cwd, ref.id)
+            : undefined;
+        const sessionId = session?.sessionId ?? archived?.sessionId ?? resolved?.id;
+        if (sessionId === undefined || (resolved !== undefined && !cwdPathsEqual(resolved.cwd, ref.cwd)))
+            throw new Error(this.t("routing.sessionNotFound", "Session not found"));
+        assertVisible(archived?.originalPath);
+        assertVisible(session?.sessionFile ?? session?.sessionManager.getSessionFile() ?? archived?.archivePath ?? resolved?.path);
+        const scope = { id: sessionId, eventScope, cwd: canonicalizeStoredCwd(session?.sessionManager.getCwd() ?? archived?.cwd ?? resolved?.cwd ?? ref.cwd) };
+        const cached = index.get(scope, mediaId);
+        if (cached !== undefined)
+            return cached;
+        if (session !== undefined) {
+            const live = index.find(scope, mediaId, [
+                session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch(),
+                session.messages,
+                session.state.streamingMessage,
+                this.publishedAssistantPartials.get(session),
+                ...(this.pendingPromptEchoes.get(session) ?? []).map((echo) => echo.message),
+            ]);
+            if (live !== undefined)
+                return live;
+        }
+        // Read disk on misses even for a cached idle runtime: other processes can
+        // append images on any branch without emitting events through this daemon.
+        const path = session?.sessionFile ?? session?.sessionManager.getSessionFile() ?? archived?.archivePath ?? resolved?.path
+            ?? (session === undefined ? undefined : (await this.sessionManager.resolveSessionFile(ref.cwd, sessionId))?.path);
+        if (path === undefined)
+            return undefined;
+        assertVisible(path);
+        const entries = await this.sessionManager.readEntries?.(path);
+        assertVisible(path);
+        return entries === undefined ? undefined : index.find(scope, mediaId, entries);
     }
     async status(ref, managementContext) {
         const session = await this.sessionForStatusOrDialogClose(ref, managementContext);
@@ -1777,7 +1989,12 @@ export class PiSessionService {
         if (this.hasActiveWork(session))
             return this.statusFromSession(session);
         const branch = await this.readableSessionBranch(session);
-        return this.statusFromSession(session, transcriptMessageCount(branch));
+        return this.statusFromSession(session, this.snapshotMessageCount(branch));
+    }
+    async assertNormalSessionReadAccess(cwd) {
+        if (!await normalSessionReadAllowed(cwd, this.projectPathForCwd, this.managementProjectRoot)) {
+            throw new Error(this.t("routing.sessionNotFound", "Session not found"));
+        }
     }
     async searchCandidates(cwd, normalizedQuery, managementContext) {
         const listing = await this.listWorkspaceSessions(cwd, managementContext);
@@ -1805,7 +2022,7 @@ export class PiSessionService {
         const streamingMessage = session.state.streamingMessage;
         const partial = streamingMessage === undefined || streamingMessage === null
             ? null
-            : annotateAssistantThinkingLevel(projectBrowserMessage(streamingMessage), session.thinkingLevel);
+            : annotateAssistantStreamId(annotateAssistantThinkingLevel(projectBrowserMessage(streamingMessage), session.thinkingLevel), this.assistantStreamIds.get(session));
         return { seq, partial };
     }
     async getSessionDefaults(ref, managementContext) {
@@ -1815,7 +2032,7 @@ export class PiSessionService {
     }
     async setSessionDefaults(ref, defaults, managementContext) {
         const update = parseSessionDefaultsUpdate({ ...defaults });
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
         return this.runModelScopeMutation(async () => {
             const settings = await this.freshSessionDefaultsSettings(session);
@@ -1875,7 +2092,7 @@ export class PiSessionService {
     async setModelEnabled(ref, provider, modelId, enabled, managementContext) {
         if (managementContext !== undefined)
             throw new Error(this.t("server.main.2a7cb0e35521", "Enabled model scope cannot be changed in management embed mode"));
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref);
         return this.runModelScopeMutation(async () => {
             const scope = this.modelScopeContext(session);
@@ -1901,7 +2118,7 @@ export class PiSessionService {
     async setModelScope(ref, mode, managementContext) {
         if (managementContext !== undefined)
             throw new Error(this.t("server.main.2a7cb0e35521", "Enabled model scope cannot be changed in management embed mode"));
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref);
         return this.runModelScopeMutation(async () => {
             const scope = this.modelScopeContext(session);
@@ -1924,7 +2141,7 @@ export class PiSessionService {
         });
     }
     async setModel(ref, provider, modelId, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
         this.assertTreeNavigationInactive(session, this.t("server.main.130226a572df", "change models"));
         const candidates = await this.sessionModelCandidates(session);
@@ -1939,7 +2156,7 @@ export class PiSessionService {
         return this.statusFromSession(session);
     }
     async cycleModel(ref, direction, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
         const result = await this.runModelScopeMutation(async () => {
             await session.modelRuntime.refresh({ allowNetwork: false });
@@ -1957,7 +2174,7 @@ export class PiSessionService {
         return session.getAvailableThinkingLevels();
     }
     async setThinkingLevel(ref, level, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
         this.assertTreeNavigationInactive(session, this.t("session.action.changeThinking", "change the thinking level"));
         // pi owns the valid set; validate against the session's live levels rather
@@ -1975,7 +2192,7 @@ export class PiSessionService {
         return this.statusFromSession(session);
     }
     async cycleThinkingLevel(ref, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
         const level = await this.runSessionEntryMutation(session, this.t("session.action.changeThinking", "change the thinking level"), () => Promise.resolve(session.cycleThinkingLevel()));
         if (level === undefined)
@@ -2013,7 +2230,7 @@ export class PiSessionService {
         const requestedBehavior = parsePromptStreamingBehavior(streamingBehavior);
         const parsedAttachments = parsePromptAttachments(attachments, { enforceInlineSizeLimit: false });
         const images = (await attachmentsToInlineImages(parsedAttachments)).map((entry) => entry.image);
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, options?.managementContext);
         const session = await this.getOrOpen(ref, options?.managementContext);
         this.assertTreeNavigationInactive(session, this.t("server.main.94306b2fc35c", "send a prompt"));
         this.maybeGenerateSessionName(session, promptText);
@@ -2028,7 +2245,6 @@ export class PiSessionService {
         // the form is void: keeping it open would invite answers to questions the
         // conversation has already moved past. Ignored duplicates skip this on
         // purpose: they must not void an ask posted after the queued original.
-        await this.voidOpenAskForUserMessage(session);
         if (session.isCompacting) {
             this.enqueuePromptDuringCompaction(session, promptText, behavior ?? "followUp", images, echoUserMessage);
             return;
@@ -2040,18 +2256,58 @@ export class PiSessionService {
         void promptPromise;
         return promptPromise;
     }
-    beginPromptSubmission(session, text, behavior, images = [], echoUserMessage = true) {
-        this.auditUserPrompt(session, text);
+    beginPromptSubmission(session, text, behavior, images = [], echoUserMessage = true, options = {}) {
+        if (options.auditUserPrompt !== false)
+            this.auditUserPrompt(session, text);
         this.publishActivity(session, behavior === "steer" ? this.t("activity.steerQueued", "Steering message queued") : behavior === "followUp" ? this.t("activity.messageQueued", "Message queued") : this.t("activity.messageReceived", "Message received"), "active");
         const eventScope = this.eventScopeForSession(session);
-        if (behavior === undefined && echoUserMessage)
-            this.events.publish(session.sessionId, { type: "message.append", message: userMessage(text, images) }, eventScope);
-        const promptOptions = buildPromptOptions(behavior, images);
-        const promptPromise = this.runSessionEntryMutation(session, this.t("server.main.94306b2fc35c", "send a prompt"), () => session.prompt(text, promptOptions));
+        const echoes = this.pendingPromptEchoes.get(session) ?? [];
+        const userCount = historyMessagesFromEntries(session.sessionManager.getBranch()).filter((message) => isRecord(message) && message["role"] === "user").length;
+        const echo = behavior === undefined && echoUserMessage
+            ? { userIndex: Math.max(userCount, ...echoes.map((pending) => pending.userIndex + 1)), message: userMessage(text, images) }
+            : undefined;
+        if (echo !== undefined) {
+            // SDK input hooks may await before appending the user message. Keep the
+            // already-published echo visible in snapshots until that append occurs.
+            this.pendingPromptEchoes.set(session, [...echoes, echo]);
+            this.events.publish(session.sessionId, { type: "message.append", message: this.browserTranscriptMessage(session, echo.message) }, eventScope, { id: session.sessionId, cwd: session.sessionManager.getCwd(), eventScope });
+        }
+        const promptOptions = options.expandPromptTemplates === false
+            ? { ...buildPromptOptions(behavior, images), expandPromptTemplates: false }
+            : buildPromptOptions(behavior, images);
+        const submission = { session, active: true };
+        const commandName = text.trim().split(/\s+/)[0]?.replace(/^\//, "");
+        const isExtensionCommand = options.expandPromptTemplates !== false && text.trim().startsWith("/") && session.extensionRunner.getRegisteredCommands().some((command) => command.invocationName === commandName);
+        const trackEarlyFailure = behavior === undefined && this.subsessionLinkForActiveChild(session) !== undefined && !isExtensionCommand;
+        let agentStarted = false;
+        const unsubscribe = !trackEarlyFailure ? undefined : session.subscribe((event) => {
+            if (getString(event, "type") === "agent_start")
+                agentStarted = true;
+        });
+        const promptPromise = this.runSessionEntryMutation(session, this.t("server.main.94306b2fc35c", "send a prompt"), () => isExtensionCommand
+            ? this.extensionCommandExecution.run({ submission }, () => session.prompt(text, promptOptions))
+            : session.prompt(text, promptOptions)).finally(() => {
+            submission.active = false;
+            unsubscribe?.();
+            if (echo !== undefined) {
+                const remaining = (this.pendingPromptEchoes.get(session) ?? []).filter((pending) => pending !== echo);
+                if (remaining.length === 0)
+                    this.pendingPromptEchoes.delete(session);
+                else
+                    this.pendingPromptEchoes.set(session, remaining);
+            }
+        });
         void promptPromise.catch((error) => {
+            this.subsessionStoppedParents.add(session);
             const message = error instanceof Error ? error.message : String(error);
             this.publishActivity(session, this.t("activity.error", "An error occurred"), "error", message);
             this.events.publish(session.sessionId, { type: "session.error", message }, eventScope);
+            if (this.isCurrentActiveSession(session)) {
+                const link = this.subsessionLinkForActiveChild(session);
+                if (trackEarlyFailure && !agentStarted && link !== undefined)
+                    this.subsessionNotifyArmed.set(activeSessionKey(link.childSessionId, link.eventScope), true);
+                this.updateSubsessionTracking(session);
+            }
         });
         return promptPromise;
     }
@@ -2115,7 +2371,7 @@ export class PiSessionService {
         const parsed = parsePromptAttachments(attachments, { enforceInlineSizeLimit: false, allowFileAttachments: true });
         if (parsed.length === 0)
             return [];
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const active = await this.getActive(ref, managementContext);
         const cwd = active.runtime.cwd;
         const effectiveFolder = folder ?? (await this.workspaceAttachmentsConfig(cwd)).defaultFolder;
@@ -2126,7 +2382,7 @@ export class PiSessionService {
         return loadEffectiveProjectAttachmentsConfig(cwd, globalConfig);
     }
     async shell(ref, text, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const active = await this.getActive(ref, managementContext);
         const { session } = active.runtime;
         this.assertTreeNavigationInactive(session, this.t("session.action.shell", "run a shell command"));
@@ -2163,25 +2419,30 @@ export class PiSessionService {
         });
     }
     async runCommand(ref, text, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const active = await this.getActive(ref, managementContext);
         return this.commandService.run(active.runtime.session.sessionId, text, active.eventScope);
     }
     async respondToCommand(ref, requestId, value, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const active = await this.getActive(ref, managementContext);
         return this.commandService.respond(active.runtime.session.sessionId, requestId, value, active.eventScope);
     }
     async navigateTree(ref, request, managementContext) {
-        if (request.targetId.trim() === "")
+        return this.navigateSessionTree(ref, request.targetId, request.expectedLeafId, sessionTreeNavigationOptions(request, this.t), managementContext, undefined, request.retainCheckpoint);
+    }
+    async navigateSessionTree(ref, targetId, expectedLeafId, options, managementContext, expectedSession, retainCheckpoint = false) {
+        if (targetId.trim() === "")
             throw new Error(this.t("server.main.f39f37acdac1", "Session tree target is required"));
         if (this.isTreeExclusiveSessionIdentityActive(sessionIdFromLookup(ref))) {
             throw new Error(this.t("server.main.e39e6b98e072", "Stop current session activity before navigating the session tree"));
         }
-        await this.assertWritable(ref);
-        const options = sessionTreeNavigationOptions(request, this.t);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
-        if (typeof session.navigateTree !== "function")
+        if (expectedSession !== undefined && session !== expectedSession)
+            throw new Error(this.t("session.extensionUnavailable", "This extension command belongs to an unavailable session runtime"));
+        const navigateTree = session.navigateTree?.bind(session);
+        if (navigateTree === undefined)
             throw new Error(this.t("session.treeUnsupported", "Session tree navigation is not supported by this Pi runtime"));
         if (this.hasActiveWork(session))
             throw new Error(this.t("server.main.e39e6b98e072", "Stop current session activity before navigating the session tree"));
@@ -2190,26 +2451,34 @@ export class PiSessionService {
         this.treeNavigations.add(session);
         try {
             const oldLeafId = session.sessionManager.getLeafId();
-            if (oldLeafId !== request.expectedLeafId) {
+            if (oldLeafId !== expectedLeafId) {
                 throw new Error(this.t("session.treeStale", "The session changed since /tree was opened. Reopen /tree and try again."));
             }
-            const activeEditableTargetParentId = activeEditableTreeTargetParentId(session.sessionManager, request.targetId, oldLeafId);
-            this.publishActivity(session, options.summarize ? this.t("activity.summarizing", "Summarizing branch") : this.t("activity.navigating", "Navigating session tree"), "active");
+            if (retainCheckpoint)
+                targetId = messageHistoryTargetId(session.sessionManager.getBranch(), targetId);
+            const checkpointTail = retainCheckpoint ? session.sessionManager.getBranch().find((entry) => isRecord(entry) && entry["id"] === targetId) : undefined;
+            const retainCustomMessage = isRecord(checkpointTail) && checkpointTail["type"] === "custom_message";
+            if (retainCustomMessage && options.summarize === true)
+                throw new Error(this.t("session.checkpointSummary", "Retaining a custom-message checkpoint requires navigation without a branch summary"));
+            const activeEditableTargetParentId = retainCustomMessage ? undefined : activeEditableTreeTargetParentId(session.sessionManager, targetId, oldLeafId);
+            this.publishActivity(session, options.summarize === true ? this.t("activity.summarizing", "Summarizing branch") : this.t("activity.navigating", "Navigating session tree"), "active");
             this.publishStatus(session);
-            let result = await session.navigateTree(request.targetId, options);
+            let result = retainCustomMessage
+                ? await navigateTreeRetainingCustomMessage(session.sessionManager, targetId, checkpointTail["parentId"], () => navigateTree(targetId, options))
+                : await navigateTree(targetId, options);
             if (activeEditableTargetParentId !== undefined && !result.cancelled
                 && result.editorText === undefined && result.summaryEntry === undefined
                 && session.sessionManager.getLeafId() === oldLeafId) {
                 setSessionTreeLeaf(session.sessionManager, activeEditableTargetParentId);
                 try {
-                    result = await session.navigateTree(request.targetId, options);
+                    result = await navigateTree(targetId, options);
                 }
                 catch (error) {
-                    session.sessionManager.branch(request.targetId);
+                    session.sessionManager.branch(targetId);
                     throw error;
                 }
                 if (result.cancelled)
-                    session.sessionManager.branch(request.targetId);
+                    session.sessionManager.branch(targetId);
             }
             if (result.cancelled) {
                 if (this.isCurrentActiveSession(session)) {
@@ -2217,13 +2486,6 @@ export class PiSessionService {
                 }
                 return { cancelled: true, ...(result.aborted === undefined ? {} : { aborted: result.aborted }) };
             }
-            if (session.sessionManager.getLeafId() !== oldLeafId) {
-                // Questions belong to the branch we left. Close them without appending a
-                // cancellation message or waking the rewound session.
-                const outcome = this.pendingAskStore.cancelOpen(this.dialogSessionKey(session));
-                if (outcome !== undefined)
-                    this.publishAskClosed(session.sessionId, outcome, this.eventScopeForSession(session));
-            }
             if (result.summaryEntry !== undefined) {
                 this.unpersistedTreeBranchLeaves.delete(session);
             }
@@ -2232,12 +2494,14 @@ export class PiSessionService {
                 if (selectedLeafId !== oldLeafId)
                     this.unpersistedTreeBranchLeaves.set(session, selectedLeafId);
             }
+            this.setSuggestedInput(session, result.editorText);
+            this.events.publish(session.sessionId, { type: "session.tree.changed" }, this.eventScopeForSession(session));
             if (this.isCurrentActiveSession(session))
                 this.publishActivity(session, this.t("activity.navigated", "Session tree changed"), "idle");
             return { cancelled: false, ...(result.editorText === undefined ? {} : { editorText: result.editorText }) };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+            const message = userFacingErrorMessage(error, this.t);
             if (this.isCurrentActiveSession(session)) {
                 this.publishActivity(session, this.t("server.main.8cae209986b4", "tree navigation failed"), "error", message);
                 this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
@@ -2248,23 +2512,29 @@ export class PiSessionService {
             this.treeNavigations.delete(session);
             if (this.isCurrentActiveSession(session)) {
                 this.flushDeferredTreeNavigationWork(session);
+                this.reconcileRuntimeMessageCount(session);
                 this.publishStatus(session);
             }
             else {
                 this.deferredGeneratedSessionNames.delete(session);
-                this.deferredSubsessionNotifications.delete(session);
+                this.subsessionInbox(session.sessionId, session.sessionFile, this.eventScopeForSession(session)).releaseClaims();
             }
         }
     }
     async forkFromTree(ref, request, managementContext) {
+        return this.forkSessionTree(ref, request, managementContext);
+    }
+    async forkSessionTree(ref, request, managementContext, options, expectedSession) {
         if (request.entryId.trim() === "")
             throw new Error(this.t("server.main.f10a242f597a", "Session tree entry is required"));
         const requestedSessionId = sessionIdFromLookup(ref);
         if (this.isTreeExclusiveSessionIdentityActive(requestedSessionId)) {
             throw new Error(this.t("server.main.3f5b7f08e91c", "Stop current session activity before forking the session tree"));
         }
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
+        if (expectedSession !== undefined && session !== expectedSession)
+            throw new Error(this.t("session.extensionUnavailable", "This extension command belongs to an unavailable session runtime"));
         if (this.hasActiveWork(session))
             throw new Error(this.t("server.main.3f5b7f08e91c", "Stop current session activity before forking the session tree"));
         if (session.sessionManager.getLeafId() !== request.expectedLeafId) {
@@ -2276,8 +2546,9 @@ export class PiSessionService {
         this.publishActivity(session, this.t("server.main.4de911d3b72a", "forking session from entry"), "active");
         this.publishStatus(session);
         try {
-            const result = await this.commandService.forkEntry(session.sessionId, request.entryId, sourceEventScope, {
-                expectedLeafId: request.expectedLeafId,
+            const entryId = request.retainCheckpoint === true ? messageHistoryTargetId(session.sessionManager.getBranch(), request.entryId) : request.entryId;
+            const result = await this.commandService.forkEntry(session.sessionId, entryId, sourceEventScope, {
+                ...options, expectedLeafId: request.expectedLeafId, expectedSession: session,
             });
             if (result.type === "unsupported")
                 throw new Error(result.message);
@@ -2291,6 +2562,9 @@ export class PiSessionService {
                 return { cancelled: true };
             }
             const forked = this.activeForLookup({ id: result.session.id, cwd: result.session.cwd }, managementContext)?.runtime.session;
+            if (forked !== undefined)
+                this.setSuggestedInput(forked, result.promptDraft);
+            this.events.publish(sourceSessionId, { type: "session.tree.changed" }, sourceEventScope);
             if (forked !== undefined && this.isCurrentActiveSession(forked)) {
                 this.publishActivity(forked, this.t("command.forked", "Session forked"), "idle");
                 this.publishStatus(forked);
@@ -2304,7 +2578,7 @@ export class PiSessionService {
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+            const message = userFacingErrorMessage(error, this.t);
             if (this.isCurrentActiveSession(session)) {
                 this.publishActivity(session, this.t("server.main.08e8f3ea9eaa", "fork failed"), "error", message);
                 this.events.publish(session.sessionId, { type: "session.error", message }, sourceEventScope);
@@ -2424,7 +2698,7 @@ export class PiSessionService {
     async archiveTree(ref, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
         const catalog = await this.workspaceArchiveCandidates(session.sessionManager.getCwd());
-        const root = findArchiveCandidateByIdOrPrefix(catalog, session.sessionId) ?? archiveCandidateFromActiveSession(session, false, this.t);
+        const root = findArchiveCandidateByExactId(catalog, session.sessionId) ?? archiveCandidateFromActiveSession(session, false, this.t);
         const plan = planSessionArchiveTree(root, catalog);
         const busy = plan.targets.map((target) => target.activeSession).find((target) => target !== undefined && this.hasActiveWork(target));
         if (busy !== undefined)
@@ -2517,7 +2791,7 @@ export class PiSessionService {
         };
     }
     async reload(ref, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const active = await this.getActive(ref, managementContext);
         const session = active.runtime.session;
         if (this.hasActiveWork(session))
@@ -2554,7 +2828,7 @@ export class PiSessionService {
         this.publishStatus(reopenedSession);
     }
     async detachParent(ref, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
         const sessionFile = session.sessionFile;
         if (sessionFile === undefined || sessionFile === "")
@@ -2569,6 +2843,10 @@ export class PiSessionService {
         const active = this.activeForLookup(ref, managementContext);
         if (active === undefined)
             return;
+        this.subsessionStoppedParents.add(active.runtime.session);
+        const mcpOwner = this.mcpAuthOwners.get(active.runtime.session);
+        if (mcpOwner !== undefined)
+            this.mcpAuthFlows.cancelSession(mcpOwner);
         this.clearCompactionPromptQueue(active.runtime.session);
         clearSessionQueue(active.runtime.session);
         this.abortRunScopedExtensionDialogs(active.runtime.session);
@@ -2585,8 +2863,136 @@ export class PiSessionService {
             this.publishStatus(active.runtime.session);
         }
     }
+    async mutateQueueMessage(ref, input, managementContext) {
+        const mutation = parseQueueMessageMutation(input);
+        await this.assertWritable(ref, managementContext);
+        const session = await this.getOrOpen(ref, managementContext);
+        await this.assertWritable(ref, managementContext);
+        if (this.activeForLookup(ref, managementContext)?.runtime.session !== session
+            || !cwdPathsEqual(ref.cwd, session.sessionManager.getCwd())
+            || this.eventScopeForSession(session) !== eventScopeFromManagementContext(managementContext)) {
+            throw new UserFacingError("routing.sessionNotFound", "Session not found");
+        }
+        // Compare the entire execution-order queue after all awaits, then mutate
+        // synchronously so neither another request nor the agent loop can interleave.
+        const current = this.queuedMessages(session);
+        if (this.queueCompatibility.reason(session) !== undefined) {
+            this.publishStatus(session);
+            this.queueCompatibility.assertAvailable(session);
+        }
+        if (current.length !== mutation.expectedQueue.length || current.some((entry, index) => {
+            const expected = mutation.expectedQueue[index];
+            if (expected === undefined)
+                return true;
+            return entry.kind !== expected.kind || entry.text !== expected.text
+                || (mutation.action === "edit" && index === mutation.index && (entry.hasAttachments === true) !== (expected.hasAttachments === true));
+        }))
+            throw new UserFacingError("queueControls.changed", "Queued messages changed; refresh the queue and try again");
+        if (mutation.index >= current.length)
+            throw new UserFacingError("queueControls.invalidIndex", "Invalid queue index");
+        this.beginSessionEntryMutation(session, this.t("queueControls.mutateAction", "change queued messages"));
+        try {
+            this.queueCompatibility.run(session, () => { this.applyQueueMessageMutation(session, mutation); });
+        }
+        catch (error) {
+            this.publishStatus(session);
+            throw error;
+        }
+        finally {
+            this.endSessionEntryMutation(session);
+        }
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    applyQueueMessageMutation(session, mutation) {
+        const agent = mutableQueueAgent(session.agent);
+        const mirrors = { steer: mutableTextMirror(session.getSteeringMessages()), followUp: mutableTextMirror(session.getFollowUpMessages()) };
+        if (session.getSteeringMessages() !== mirrors.steer || session.getFollowUpMessages() !== mirrors.followUp) {
+            throw new Error("SDK queue getters no longer expose stable backing arrays");
+        }
+        const queues = snapshotAgentQueues(agent);
+        const originalQueues = { steer: [...queues.steer], followUp: [...queues.followUp] };
+        const originalMirrors = { steer: [...mirrors.steer], followUp: [...mirrors.followUp] };
+        const held = this.compactionQueuedMessages(session).map((prompt) => ({ ...prompt }));
+        const entries = ["steer", "followUp"].flatMap((kind) => [
+            ...mirroredQueueEntries(queues[kind], mirrors[kind]).map((entry) => ({ ...entry, kind })),
+            ...held.filter((prompt) => prompt.kind === kind).map((prompt) => ({ kind, text: prompt.text, prompt })),
+        ]);
+        const selected = entries[mutation.index];
+        if (selected === undefined)
+            throw new UserFacingError("queueControls.invalidIndex", "Invalid queue index");
+        const removed = mutation.action === "edit" ? entries.slice(mutation.index) : [selected];
+        const remaining = entries.filter((entry) => !removed.includes(entry));
+        for (const entry of removed) {
+            if (entry.message !== undefined) {
+                const queue = queues[entry.kind];
+                queue.splice(queue.indexOf(entry.message), 1);
+            }
+            if (entry.prompt !== undefined)
+                held.splice(held.indexOf(entry.prompt), 1);
+        }
+        if (mutation.action === "toggle") {
+            const kind = selected.kind === "steer" ? "followUp" : "steer";
+            // Destination includes held prompts: append there when necessary to keep
+            // status order and eventual execution order identical.
+            if (selected.prompt !== undefined) {
+                selected.prompt.kind = kind;
+                held.push(selected.prompt);
+                remaining.push({ ...selected, kind });
+            }
+            else if (selected.message !== undefined) {
+                if (held.some((prompt) => prompt.kind === kind)) {
+                    const prompt = { kind, text: selected.text, message: selected.message };
+                    held.push(prompt);
+                    remaining.push({ kind, text: selected.text, prompt });
+                }
+                else {
+                    queues[kind].push(selected.message);
+                    remaining.push({ ...selected, kind });
+                }
+            }
+        }
+        try {
+            agent.clearAllQueues();
+            for (const message of queues.steer)
+                agent.steer(message);
+            for (const message of queues.followUp)
+                agent.followUp(message);
+            for (const kind of ["steer", "followUp"]) {
+                mirrors[kind].splice(0, mirrors[kind].length, ...remaining.filter((entry) => entry.kind === kind && entry.message !== undefined).map((entry) => entry.text));
+            }
+        }
+        catch (error) {
+            // Best-effort rollback when a callable SDK method fails during replacement.
+            // Restoration itself can fail after an incompatible behavioral change.
+            const failures = [error];
+            try {
+                agent.clearAllQueues();
+                for (const message of originalQueues.steer)
+                    agent.steer(message);
+                for (const message of originalQueues.followUp)
+                    agent.followUp(message);
+            }
+            catch (restoreError) {
+                failures.push(restoreError);
+            }
+            for (const kind of ["steer", "followUp"]) {
+                try {
+                    mirrors[kind].splice(0, mirrors[kind].length, ...originalMirrors[kind]);
+                }
+                catch (restoreError) {
+                    failures.push(restoreError);
+                }
+            }
+            throw new AggregateError(failures, "Could not replace SDK queues; attempted to restore their original contents", { cause: error });
+        }
+        if (held.length === 0)
+            this.clearCompactionPromptQueue(session);
+        else
+            this.compactionPromptQueues.set(activeSessionKey(session.sessionId, this.eventScopeForSession(session)), held);
+    }
     async clearQueue(ref, managementContext) {
-        await this.assertWritable(ref);
+        await this.assertWritable(ref, managementContext);
         const session = await this.getOrOpen(ref, managementContext);
         this.clearCompactionPromptQueue(session);
         clearSessionQueue(session);
@@ -2767,9 +3173,14 @@ export class PiSessionService {
             this.publishNotificationMutations(mutations);
         }
         this.forgetUnreadActivity(active.runtime.session);
-        this.pendingAskStore.forgetSession(this.dialogSessionKey(active.runtime.session));
         this.endSessionExtensionDialogs(active.runtime.session);
+        const mcpOwner = this.mcpAuthOwners.get(active.runtime.session);
+        if (mcpOwner !== undefined)
+            this.mcpAuthFlows.cancelSession(mcpOwner);
+        this.rememberManagementMediaFile(active.runtime.session, active.eventScope);
         this.active.delete(activeSessionKey(sessionId, active.eventScope));
+        this.suggestedInputs.delete(this.dialogSessionKey(active.runtime.session));
+        this.events.mediaIndex.forgetSession({ id: sessionId, cwd: active.runtime.session.sessionManager.getCwd(), eventScope: active.eventScope });
         this.activities.delete(activeSessionKey(sessionId, active.eventScope));
         this.workspaceActivity?.removeSession(sessionId, active.runtime.session.sessionManager.getCwd(), active.eventScope);
         this.clearAuthLossWarningsForSession(sessionId);
@@ -2813,9 +3224,13 @@ export class PiSessionService {
         if (branchSummaryAbortFailed)
             throw branchSummaryAbortError;
     }
-    async assertWritable(ref) {
+    async assertWritable(ref, managementContext) {
         if (await this.getArchived(ref) !== undefined)
             throw new Error(this.t("session.archiveReadOnly", "Archived sessions are read-only. Restore the session to continue."));
+        const session = this.activeForLookup(ref, managementContext)?.runtime.session;
+        const owner = session === undefined ? undefined : this.mcpAuthOwners.get(session);
+        if (owner !== undefined)
+            this.mcpAuthFlows.assertSessionAvailable(owner);
     }
     async getOrOpen(ref, managementContext) {
         return (await this.getActive(ref, managementContext)).runtime.session;
@@ -2827,12 +3242,6 @@ export class PiSessionService {
         const exact = this.startupSessions.get(activeSessionKey(sessionId, eventScope));
         if (exact !== undefined && exact.managementContextKey === contextKey && lookupMatchesStartupSession(ref, exact.session))
             return exact.session;
-        for (const startup of this.startupSessions.values()) {
-            if (startup.managementContextKey !== contextKey || !startup.session.sessionId.startsWith(sessionId))
-                continue;
-            if (lookupMatchesStartupSession(ref, startup.session))
-                return startup.session;
-        }
         return undefined;
     }
     /** Resolve status and dialog-close calls even while extension startup is waiting for the browser. */
@@ -2900,7 +3309,7 @@ export class PiSessionService {
         }
         const match = isPiSessionRef(ref)
             ? await this.sessionManager.resolveSessionFile(ref.cwd, ref.id)
-            : findSessionByIdOrPrefix(await this.sessionManager.listAll(), ref);
+            : findSessionByExactId(await this.sessionManager.listAll(), ref);
         if (!match)
             throw new Error(this.t("routing.sessionNotFound", "Session not found"));
         return this.openPending(match.id, match.cwd, managementContext, () => this.sessionManager.open(match.path));
@@ -2948,11 +3357,6 @@ export class PiSessionService {
         const exact = this.active.get(activeSessionKey(sessionId, eventScope));
         if (exact !== undefined && lookupMatchesActiveSession(ref, exact) && exact.managementContextKey === key)
             return exact;
-        for (const active of this.active.values()) {
-            const candidateId = active.runtime.session.sessionId;
-            if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active) && active.managementContextKey === key)
-                return active;
-        }
         return undefined;
     }
     activeForLookupAny(ref) {
@@ -2960,11 +3364,6 @@ export class PiSessionService {
         const exact = this.activeForSessionId(sessionId);
         if (exact !== undefined && lookupMatchesActiveSession(ref, exact))
             return exact;
-        for (const active of this.active.values()) {
-            const candidateId = active.runtime.session.sessionId;
-            if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active))
-                return active;
-        }
         return undefined;
     }
     getActiveForCommand(sessionId, eventScope) {
@@ -3030,8 +3429,14 @@ export class PiSessionService {
             await session.bindExtensions({
                 uiContext,
                 mode: "rpc",
+                commandContextActions: this.extensionCommandActions(session),
                 onError: (error) => {
                     const message = `${error.extensionPath}: ${error.error}`;
+                    const operation = McpAuthFlowService.current(session);
+                    if (operation !== undefined) {
+                        operation.error(message);
+                        return;
+                    }
                     this.publishActivity(session, this.t("activity.extensionError", "Extension error"), "error", message);
                     this.events.publish(session.sessionId, { type: "session.error", message }, owner.eventScope);
                 },
@@ -3045,9 +3450,89 @@ export class PiSessionService {
                 this.startupSessions.delete(key);
         }
     }
+    extensionCommandActions(session) {
+        const ref = { id: session.sessionId, cwd: session.sessionManager.getCwd() };
+        const managementContext = this.sessionManagementContexts.get(session);
+        return {
+            waitForIdle: () => {
+                this.assertCurrentExtensionSession(session);
+                return session.waitForIdle();
+            },
+            navigateTree: (targetId, options) => {
+                const expectedLeafId = session.sessionManager.getLeafId();
+                return this.runExtensionSessionControl(session, async () => {
+                    const result = await this.navigateSessionTree(ref, targetId, expectedLeafId, options ?? { summarize: false }, managementContext, session);
+                    return { cancelled: result.cancelled };
+                });
+            },
+            fork: (entryId, options) => {
+                const expectedLeafId = session.sessionManager.getLeafId();
+                const withSession = options?.withSession;
+                let completeReplacement;
+                const forkOptions = {
+                    ...options,
+                    position: options?.position ?? "before",
+                    // Capture Pi's fresh context, but run user code after the host's
+                    // replacement reservation is released so fresh controls can work.
+                    ...(withSession === undefined ? {} : { withSession: (ctx) => {
+                            completeReplacement = () => withSession(ctx);
+                            return Promise.resolve();
+                        } }),
+                };
+                return this.runExtensionSessionControl(session, async () => {
+                    const runtime = this.activeForLookup(ref, managementContext)?.runtime;
+                    const result = await this.forkSessionTree(ref, { entryId, expectedLeafId }, managementContext, forkOptions, session);
+                    if (!result.cancelled) {
+                        try {
+                            await completeReplacement?.();
+                        }
+                        catch (error) {
+                            // The fork is committed. Report callback failure on the current
+                            // runtime (which may have forked again), including its recoverable inbox.
+                            const current = runtime?.session;
+                            if (current !== undefined && this.isCurrentActiveSession(current)) {
+                                const message = userFacingErrorMessage(error, this.t);
+                                current.extensionRunner.getUIContext().notify(message, "error");
+                                this.publishActivity(current, "extension callback failed", "error", message);
+                                this.events.publish(current.sessionId, { type: "session.error", message }, this.eventScopeForSession(current));
+                            }
+                            throw error;
+                        }
+                    }
+                    return { cancelled: result.cancelled };
+                });
+            },
+            reload: () => this.runExtensionSessionControl(session, () => this.reloadSessionRuntime(session)),
+            // These need host-owned creation/selection policies, not SDK runtime-only
+            // replacement. Fail visibly until PI WEB supplies that integration.
+            newSession: () => Promise.reject(new Error(this.t("session.extensionNewUnsupported", "ctx.newSession() is not supported in PI WEB. Start a new session from the web UI."))),
+            switchSession: () => Promise.reject(new Error(this.t("session.extensionSwitchUnsupported", "ctx.switchSession() is not supported in PI WEB. Select a session from the web UI."))),
+        };
+    }
+    assertCurrentExtensionSession(session) {
+        if (!this.isCurrentActiveSession(session) || this.startupSessions.has(activeSessionKey(session.sessionId, this.eventScopeForSession(session)))) {
+            throw new Error(this.t("session.extensionUnavailable", "This extension command belongs to an unavailable session runtime"));
+        }
+    }
+    runExtensionSessionControl(session, operation) {
+        return this.extensionCommandExecution.run({ ...this.extensionCommandExecution.getStore(), sessionControl: true }, async () => {
+            this.assertCurrentExtensionSession(session);
+            await this.assertWritable({ id: session.sessionId, cwd: session.sessionManager.getCwd() }, this.sessionManagementContexts.get(session));
+            this.assertCurrentExtensionSession(session);
+            return operation();
+        });
+    }
+    setSuggestedInput(session, text) {
+        const key = this.dialogSessionKey(session);
+        if (text === undefined || text === "")
+            this.suggestedInputs.delete(key);
+        else
+            this.suggestedInputs.set(key, text);
+    }
     bindRuntime(active, session = active.runtime.session) {
         this.sessionEventScopes.set(session, active.eventScope);
         this.runtimeBySession.set(session, active.runtime);
+        this.rememberManagementMediaFile(session, active.eventScope);
         active.unsubscribe();
         for (const [sessionKey, candidate] of this.active.entries()) {
             if (candidate === active) {
@@ -3059,34 +3544,97 @@ export class PiSessionService {
         if (active.eventScope === NORMAL_SESSION_EVENT_SCOPE && active.runtime.session !== session) {
             this.sessionEvents.close(active.runtime.session);
         }
+        this.reconcileRuntimeMessageCount(session);
+        this.restoreSubsessionReceipts(session);
         const unsubscribe = session.subscribe((event) => {
-            this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel), active.eventScope);
+            const eventType = getString(event, "type");
+            const message = getProperty(event, "message");
+            const entry = getProperty(event, "entry");
+            const inbox = this.subsessionInbox(session.sessionId, session.sessionFile, active.eventScope);
+            if (eventType === "agent_start") {
+                this.restoreSubsessionReceipts(session, false);
+                this.subsessionStoppedParents.delete(session);
+            }
+            if (eventType === "message_end" && getString(message, "role") === "assistant"
+                && (getString(message, "stopReason") === "aborted" || getString(message, "stopReason") === "error"))
+                this.subsessionStoppedParents.add(session);
+            if (eventType === "entry_appended" && getString(entry, "type") === "custom_message"
+                && getString(entry, "customType") === SUBSESSION_NOTIFICATION_CUSTOM_TYPE && this.subsessionReceiptMatches(session, entry))
+                inbox.receive(completionReceiptIds(getProperty(entry, "details")));
+            if (eventType === "turn_end" || eventType === "agent_settled")
+                this.restoreSubsessionReceipts(session);
+            if (eventType === "agent_settled")
+                this.scheduleSubsessionDelivery(session);
+            const role = getString(message, "role");
+            if ((eventType === "message_end" && (role === "user" || role === "assistant" || role === "toolResult" || role === "system"))
+                || (eventType === "entry_appended" && getString(entry, "type") === "message")) {
+                this.runtimeMessageCounts.set(session, this.runtimeMessageCount(session) + 1);
+            }
+            if (eventType === "agent_settled" || eventType === "session_tree")
+                this.reconcileRuntimeMessageCount(session);
+            if (eventType === "message_start" && role === "assistant")
+                this.assistantStreamIds.set(session, randomUUID());
+            const streamId = this.assistantStreamIds.get(session);
+            if ((eventType === "message_start" || eventType === "message_update") && role === "assistant") {
+                this.publishedAssistantPartials.set(session, structuredClone(annotateAssistantStreamId(annotateAssistantThinkingLevel(projectBrowserMessage(message), session.thinkingLevel), streamId)));
+            }
+            else if ((eventType === "message_end" && role === "assistant") || eventType === "agent_end") {
+                this.publishedAssistantPartials.delete(session);
+            }
+            const clientEvent = toClientEvent(event, session.thinkingLevel, streamId);
+            if ((clientEvent.type === "message.end" || clientEvent.type === "message.append") && clientEvent.message !== undefined) {
+                clientEvent.message = this.browserTranscriptMessage(session, clientEvent.message);
+            }
+            this.events.publish(session.sessionId, clientEvent, active.eventScope, { id: session.sessionId, cwd: session.sessionManager.getCwd() });
+            if ((eventType === "message_end" && role === "assistant") || eventType === "agent_end")
+                this.assistantStreamIds.delete(session);
             this.auditToolExecutionEvent(active, event);
             this.auditAssistantResponseEvent(active, event);
             this.publishActivityForEvent(session, event);
-            const eventType = getString(event, "type");
-            if (eventType === "message_start" && isRecord(event) && getString(event["message"], "role") === "user") {
-                void this.voidOpenAskForUserMessage(session).catch((error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    this.publishActivity(session, this.t("activity.extensionError", "Extension error"), "error", message);
-                    this.events.publish(session.sessionId, { type: "session.error", message }, active.eventScope);
-                });
-            }
+            if (eventType === "message_start" && role === "user")
+                this.suggestedInputs.delete(this.dialogSessionKey(session));
             if (eventType === "agent_end")
                 this.abortRunScopedExtensionDialogs(session);
-            if (eventType === "compaction_end")
+            if (eventType === "compaction_end") {
+                if (getString(event, "reason") === "manual")
+                    this.manualCompactionEnded.add(session);
+                this.publishCompactionOutcome(session, event);
                 this.scheduleCompactionQueueDrain(session);
+            }
             if (eventType === "agent_start" || eventType === "agent_end")
                 this.scheduleCompactionQueueDrain(session);
             this.publishStatus(session);
-            this.updateSubsessionTracking(session);
+            this.updateSubsessionTracking(session, eventType === "agent_start", eventType === "agent_settled");
+            if (eventType === "bash_execution_end" || eventType === "compaction_end")
+                this.scheduleSubsessionDelivery(session);
         });
         active.unsubscribe = () => {
             if (active.eventScope === NORMAL_SESSION_EVENT_SCOPE)
                 this.sessionEvents.close(session);
             unsubscribe();
+            this.publishedAssistantPartials.delete(session);
+            this.assistantStreamIds.delete(session);
         };
         this.active.set(activeSessionKey(session.sessionId, active.eventScope), active);
+        this.scheduleSubsessionDelivery(session);
+    }
+    publishCompactionOutcome(session, event) {
+        const aborted = getBoolean(event, "aborted") === true;
+        const errorMessage = getString(event, "errorMessage");
+        const automatic = getString(event, "reason") !== "manual";
+        const message = aborted
+            ? (automatic ? this.t("session.compaction.autoCancelled", "Automatic compaction cancelled.") : this.t("session.compaction.cancelled", "Compaction cancelled."))
+            : errorMessage === undefined ? undefined : this.t("session.compaction.failed", "Could not compact history. Try again.");
+        if (!aborted && errorMessage !== undefined) {
+            this.events.publish(session.sessionId, { type: "session.diagnostic", message: errorMessage }, this.eventScopeForSession(session));
+        }
+        this.publishActivity(session, aborted ? this.t("activity.compactionCancelled", "Compaction cancelled") : errorMessage === undefined ? this.t("activity.compacted", "Context compacted") : this.t("activity.compactionFailed", "Context compaction failed"), !aborted && errorMessage !== undefined ? "error" : "idle", message);
+        // Successful compaction already has a canonical summary in the transcript.
+        // Keep cancellation/failure feedback in the refresh-safe session inbox only.
+        const generation = this.notificationGenerationBySession.get(session);
+        if (message !== undefined && generation !== undefined) {
+            this.publishNotificationMutations(this.notificationsForSession(session).addNotification(generation, message, aborted ? "info" : "error").mutations);
+        }
     }
     scheduleCompactionQueueDrain(session, delayMs = 0) {
         const sessionKey = activeSessionKey(session.sessionId, this.eventScopeForSession(session));
@@ -3113,16 +3661,27 @@ export class PiSessionService {
                 return;
             this.publishStatus(session);
             for (const prompt of queued)
-                void this.submitPrompt(session, prompt.text, prompt.kind, prompt.images, prompt.echoUserMessage ?? true);
+                void this.submitHeldPrompt(session, prompt, prompt.kind);
             return;
         }
         const prompt = this.shiftCompactionPrompt(sessionKey);
         if (prompt === undefined)
             return;
         this.publishStatus(session);
-        const submitted = this.submitPrompt(session, prompt.text, undefined, prompt.images, prompt.echoUserMessage ?? true);
+        const submitted = this.submitHeldPrompt(session, prompt);
         void submitted.finally(() => { this.scheduleCompactionQueueDrain(session); });
     }
+    submitHeldPrompt(session, prompt, kind) {
+        if (prompt.message === undefined)
+            return this.submitPrompt(session, prompt.text, kind, prompt.images, prompt.echoUserMessage ?? true);
+        const images = prompt.message.role === "user" && Array.isArray(prompt.message.content)
+            ? prompt.message.content.filter((part) => part.type === "image") : [];
+        // This SDK message was already submitted/audited before moving into held
+        // storage. Preserve public runtime ownership without re-expansion or audit.
+        return this.beginPromptSubmission(session, prompt.text, kind, images, prompt.echoUserMessage ?? true, {
+            expandPromptTemplates: false, auditUserPrompt: false,
+        }).catch(() => undefined);
+    }
     takeCompactionPromptQueue(sessionId) {
         const queued = this.compactionPromptQueues.get(sessionId) ?? [];
         this.compactionPromptQueues.delete(sessionId);
@@ -3130,7 +3689,8 @@ export class PiSessionService {
     }
     shiftCompactionPrompt(sessionId) {
         const queue = this.compactionPromptQueues.get(sessionId);
-        const prompt = queue?.shift();
+        const steeringIndex = queue?.findIndex((prompt) => prompt.kind === "steer") ?? -1;
+        const prompt = queue?.splice(steeringIndex < 0 ? 0 : steeringIndex, 1)[0];
         if (queue === undefined || queue.length === 0)
             this.compactionPromptQueues.delete(sessionId);
         return prompt;
@@ -3154,20 +3714,30 @@ export class PiSessionService {
     maybeGenerateSessionName(session, firstMessage) {
         if (session.sessionName !== undefined || session.messages.length !== 0 || session.isStreaming || session.isCompacting)
             return;
-        const deterministicName = deterministicSessionName(firstMessage);
-        if (deterministicName !== undefined) {
-            this.applyGeneratedSessionName(session, deterministicName);
-            return;
-        }
-        const model = session.model;
-        if (model === undefined)
-            return;
-        void generateShortSessionName(session.agent.streamFunction, model, firstMessage).then((name) => {
+        void this.generateSessionName(session, firstMessage).then((name) => {
+            if (name === undefined)
+                this.logger.info({ sessionId: session.sessionId }, "Session naming returned no title; using the first-message fallback");
             this.applyGeneratedSessionName(session, name ?? fallbackSessionName(firstMessage));
-        }).catch(() => {
+        }).catch((error) => {
+            const errorCategory = error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError") ? "timeout" : "generation";
+            this.logger.info({ sessionId: session.sessionId, errorCategory }, "Session naming failed; using the first-message fallback");
             this.applyGeneratedSessionName(session, fallbackSessionName(firstMessage));
         });
     }
+    async generateSessionName(session, firstMessage) {
+        // One request keeps its settings even if the operator edits the config while it runs.
+        const naming = this.config === undefined ? {} : (await this.config.read()).effectiveConfig.sessionNaming ?? {};
+        let model = session.model;
+        if (naming.model !== undefined) {
+            const parsed = parseModelSpec(naming.model);
+            model = parsed === undefined ? undefined : session.modelRuntime.getModel(parsed.provider, parsed.modelId);
+            if (model === undefined)
+                throw new Error("Configured session naming model is unavailable");
+        }
+        if (model === undefined)
+            return undefined;
+        return generateShortSessionName(session.agent.streamFunction, model, firstMessage, naming);
+    }
     applyGeneratedSessionName(session, name) {
         if (name === undefined || session.sessionName !== undefined)
             return;
@@ -3262,8 +3832,10 @@ export class PiSessionService {
         return this.t("activity.working", "Working");
     }
     hasActiveWork(session) {
+        const execution = this.extensionCommandExecution.getStore();
+        const ownCommandReceipt = execution?.sessionControl === true && execution.submission?.active === true && execution.submission.session === session ? 1 : 0;
         return this.treeNavigations.has(session)
-            || this.isSessionEntryMutationActive(session)
+            || this.isSessionEntryMutationActive(session, ownCommandReceipt)
             || this.isTreeExclusiveOperationActive(session)
             || sessionHasActiveWork(session, this.compactionQueuedMessages(session).length);
     }
@@ -3337,6 +3909,9 @@ export class PiSessionService {
         }
     }
     beginSessionEntryMutation(session, action) {
+        const owner = this.mcpAuthOwners.get(session);
+        if (owner !== undefined)
+            this.mcpAuthFlows.assertSessionAvailable(owner);
         this.assertTreeNavigationInactive(session, action);
         this.sessionEntryMutationCounts.set(session, (this.sessionEntryMutationCounts.get(session) ?? 0) + 1);
         this.observeUnreadActivityState(session);
@@ -3348,9 +3923,11 @@ export class PiSessionService {
         else
             this.sessionEntryMutationCounts.set(session, remaining);
         this.observeUnreadActivityState(session);
+        if (remaining <= 0 && !this.subsessionDeliveringParents.has(session))
+            this.scheduleSubsessionDelivery(session);
     }
-    isSessionEntryMutationActive(session) {
-        return (this.sessionEntryMutationCounts.get(session) ?? 0) > 0;
+    isSessionEntryMutationActive(session, ignoredReceipts = 0) {
+        return (this.sessionEntryMutationCounts.get(session) ?? 0) > ignoredReceipts;
     }
     publishActivityForEvent(session, event) {
         const eventType = getString(event, "type");
@@ -3561,7 +4138,15 @@ export class PiSessionService {
             this.publishStatus(session);
         }
     }
+    rememberManagementMediaFile(session, eventScope) {
+        if (eventScope === NORMAL_SESSION_EVENT_SCOPE)
+            return;
+        const path = session.sessionFile ?? session.sessionManager.getSessionFile();
+        if (path !== undefined)
+            this.managementMediaFiles.add(path);
+    }
     publishStatus(session) {
+        this.rememberManagementMediaFile(session, this.eventScopeForSession(session));
         void this.refreshActivityMarker(session);
         const status = this.statusFromSession(session);
         this.clearStaleActiveActivity(session);
@@ -3617,30 +4202,52 @@ export class PiSessionService {
                 this.publishStatus(session);
         }
     }
-    statusFromSession(session, messageCount = session.messages.length) {
+    reconcileRuntimeMessageCount(session) {
+        const count = transcriptMessageCount(session.sessionManager.getBranch());
+        this.runtimeMessageCounts.set(session, count);
+        return count;
+    }
+    runtimeMessageCount(session) {
+        return this.runtimeMessageCounts.get(session) ?? this.reconcileRuntimeMessageCount(session);
+    }
+    snapshotMessageCount(branch) {
+        // The gateway reuses immutable disk snapshots until the file changes.
+        // Keep disk counts separate: an idle runtime may lag external appends.
+        const cached = this.snapshotMessageCounts.get(branch);
+        if (cached !== undefined)
+            return cached;
+        const count = transcriptMessageCount(branch);
+        this.snapshotMessageCounts.set(branch, count);
+        return count;
+    }
+    statusFromSession(session, messageCount = this.runtimeMessageCount(session)) {
         const stats = session.getSessionStats();
         const model = session.model === undefined ? undefined : modelToClientModel(session.model);
         const contextUsage = session.getContextUsage();
         const warnings = this.warningsForSession(session);
-        const pendingAsk = this.pendingAskStore.pendingAsk(this.dialogSessionKey(session));
         const pendingDialogs = this.pendingExtensionDialogStore.pendingDialogs(this.dialogSessionKey(session));
+        const suggestedInput = this.suggestedInputs.get(this.dialogSessionKey(session));
+        const queuedMessages = this.queuedMessages(session);
+        const queueMessageActionsUnavailable = this.queueCompatibility.reason(session);
         return {
             sessionId: session.sessionId,
             persisted: sessionFileExists(session.sessionFile),
+            recentlyActiveElsewhere: this.eventScopeForSession(session) === NORMAL_SESSION_EVENT_SCOPE && this.activityMarker.isActiveElsewhere(session.sessionFile),
             ...(model === undefined ? {} : { model }),
             thinkingLevel: session.thinkingLevel,
             isStreaming: session.isStreaming,
             isCompacting: session.isCompacting,
             isBashRunning: session.isBashRunning,
             pendingMessageCount: this.pendingMessageCount(session),
-            queuedMessages: queuedMessagesFromSession(session, this.compactionQueuedMessages(session)),
+            queuedMessages,
+            ...(queueMessageActionsUnavailable === undefined ? {} : { queueMessageActionsUnavailable }),
             messageCount,
             tokens: stats.tokens,
             cost: stats.cost,
             ...(contextUsage === undefined ? {} : { contextUsage }),
             ...(warnings.length === 0 ? {} : { warnings }),
-            ...(pendingAsk === undefined ? {} : { pendingAsk }),
             ...(pendingDialogs.length === 0 ? {} : { pendingDialogs }),
+            ...(suggestedInput === undefined ? {} : { suggestedInput }),
         };
     }
     /**
@@ -3652,14 +4259,6 @@ export class PiSessionService {
     warningsForSession(session) {
         const runtime = [...this.active.values()].find((active) => active.runtime.session === session)?.runtime;
         const warnings = runtime === undefined ? [] : collectRuntimeWarnings(runtime);
-        if (this.eventScopeForSession(session) === NORMAL_SESSION_EVENT_SCOPE
-            && this.activityMarker.isActiveElsewhere(session.sessionFile)) {
-            warnings.push({
-                severity: "info",
-                message: this.t("server.main.b80808e6ef11", "Recently active in another PI-WEB instance. Avoid working on this session in both instances at once."),
-                source: "PI-WEB",
-            });
-        }
         const authPath = modelRuntimeAuthPath(session.modelRuntime);
         const anthropic = authPath === undefined ? undefined : anthropicSubscriptionWarning(session, authPath);
         if (anthropic !== undefined)
@@ -3673,7 +4272,11 @@ export class PiSessionService {
         return this.compactionPromptQueues.get(activeSessionKey(session.sessionId, this.eventScopeForSession(session))) ?? [];
     }
     hasQueuedMessageText(session, text) {
-        return queuedMessagesFromSession(session, this.compactionQueuedMessages(session)).some((message) => message.text === text);
+        return this.queuedMessages(session).some((message) => message.text === text);
+    }
+    queuedMessages(session) {
+        const held = this.compactionQueuedMessages(session);
+        return this.queueCompatibility.inspect(session, () => queuedMessagesFromSession(session, held), () => queuedMessagesFromSession(session, held, false));
     }
     notificationsForScope(scope) {
         if (scope === NORMAL_SESSION_EVENT_SCOPE)
@@ -3735,10 +4338,6 @@ export class PiSessionService {
         this.publishNotificationMutations(result.mutations);
         return result.snapshot;
     }
-    async deliverSubsessionNotification(session, notification) {
-        await this.runSessionEntryMutation(session, this.t("session.action.notify", "deliver a subsession notification"), () => session.sendCustomMessage({ customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE, content: notification.text, display: true, details: { sessionId: notification.childId } }, { triggerTurn: true, deliverAs: "followUp" }));
-        this.publishStatus(session);
-    }
     logSubsessionNotificationFailure(parentId, childId, error) {
         this.logger.info({ parentSessionId: parentId, sessionId: childId, error: error instanceof Error ? error.message : String(error) }, "failed to notify parent of subsession completion");
     }
@@ -3749,9 +4348,14 @@ export class PiSessionService {
             this.publishActivity(session, this.t("activity.reloading", "Reloading resources"), "active");
             const priorGeneration = this.notificationGenerationBySession.get(session);
             let candidateGeneration;
+            const reloadBoundary = { beforeSessionStart: false };
             try {
-                await session.reload(priorGeneration === undefined ? undefined : {
+                await session.reload({
                     beforeSessionStart: () => {
+                        this.endSessionExtensionDialogs(session);
+                        reloadBoundary.beforeSessionStart = true;
+                        if (priorGeneration === undefined)
+                            return;
                         candidateGeneration = this.notificationsForSession(session).beginReplacement(priorGeneration, notificationIdentityForSession(session));
                         this.notificationGenerationBySession.set(session, candidateGeneration);
                         this.replaceSessionNotificationContext(session, candidateGeneration);
@@ -3765,6 +4369,8 @@ export class PiSessionService {
                 this.publishStatus(session);
             }
             catch (error) {
+                if (!reloadBoundary.beforeSessionStart)
+                    this.endSessionExtensionDialogs(session);
                 if (candidateGeneration !== undefined) {
                     this.publishNotificationMutations(this.notificationsForSession(session).abortReplacement(candidateGeneration, "candidate"));
                     this.notificationGenerationBySession.set(session, candidateGeneration);
@@ -3880,7 +4486,11 @@ export class PiSessionService {
                     // holds for this session; settle those waits before the new
                     // runtime's extensions can open fresh dialogs under the same id.
                     this.endSessionExtensionDialogs(boundSession);
+                    const changedIdentity = boundSession.sessionId !== session.sessionId;
                     boundSession = session;
+                    this.startupSessions.set(activeSessionKey(session.sessionId, active.eventScope), { session, eventScope: active.eventScope, managementContextKey: active.managementContextKey });
+                    if (changedIdentity)
+                        this.announceCreatedSession(active, session.sessionManager.getCwd());
                     await this.bindSessionExtensions(session, candidateGeneration, active);
                     if (candidateGeneration !== undefined) {
                         this.publishNotificationMutations(notificationStore.commitReplacement(candidateGeneration));
@@ -3950,6 +4560,11 @@ export class PiSessionService {
         const eventScope = this.eventScopeForSession(session);
         const notificationStore = this.notificationsForScope(eventScope);
         const notify = (message, type) => {
+            const operation = McpAuthFlowService.current(session);
+            if (operation !== undefined) {
+                operation.notify(message);
+                return;
+            }
             if (generation === undefined) {
                 this.events.publish(session.sessionId, {
                     type: "command.output",
@@ -3973,13 +4588,16 @@ export class PiSessionService {
                 if (property === "theme")
                     return plainTextTheme;
                 if (property === "confirm") {
-                    return (title, message, opts) => this.openExtensionDialog(session, { kind: "confirm", title, message }, opts, startupDialogs.signal);
+                    return (title, message, opts) => McpAuthFlowService.current(session)?.confirm(title, message, opts)
+                        ?? this.openExtensionDialog(session, { kind: "confirm", title, message }, opts, startupDialogs.signal);
                 }
                 if (property === "select") {
-                    return (title, options, opts) => this.openExtensionDialog(session, { kind: "select", title, options }, opts, startupDialogs.signal);
+                    return (title, options, opts) => McpAuthFlowService.current(session)?.select(title, options, opts)
+                        ?? this.openExtensionDialog(session, { kind: "select", title, options }, opts, startupDialogs.signal);
                 }
                 if (property === "input") {
-                    return (title, placeholder, opts) => this.openExtensionDialog(session, { kind: "input", title, placeholder }, opts, startupDialogs.signal);
+                    return (title, placeholder, opts) => McpAuthFlowService.current(session)?.input(title, placeholder, opts)
+                        ?? this.openExtensionDialog(session, { kind: "input", title, placeholder }, opts, startupDialogs.signal);
                 }
                 const value = Reflect.get(target, property, receiver);
                 return value;
@@ -4119,14 +4737,287 @@ export class PiSessionService {
                 this.logger.info({ sessionId: session.sessionId, error: error instanceof Error ? error.message : String(error) }, "failed to apply deferred session name");
             }
         }
-        const notifications = this.deferredSubsessionNotifications.get(session) ?? [];
-        this.deferredSubsessionNotifications.delete(session);
-        for (const notification of notifications) {
-            void this.deliverSubsessionNotification(session, notification).catch((error) => {
-                this.logSubsessionNotificationFailure(notification.parentId, notification.childId, error);
+        this.restoreSubsessionReceipts(session);
+        this.scheduleSubsessionDelivery(session);
+    }
+    async deliverAskOutcome(session, outcome) {
+        // Pi persists/displays the structured message and wakes an idle agent, or
+        // queues it behind in-flight work. Ordinary entry-mutation protection still
+        // applies, but there is no answer-specific stale/duplicate gate.
+        await this.runSessionEntryMutation(session, this.t("server.main.07f784061918", "deliver answers to your questions"), () => session.sendCustomMessage({ customType: ASK_USER_ANSWERS_CUSTOM_TYPE, content: renderAskUserAnswersText(outcome), display: true, details: outcome }, { triggerTurn: true, deliverAs: "followUp" }));
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    async joinSubsessions(parentSessionId, parentSessionFile, toolCallId, managementContext) {
+        const scope = eventScopeFromManagementContext(managementContext);
+        const subsessions = await this.listSubsessions(parentSessionId, parentSessionFile, managementContext);
+        this.reconcileSubsessionCompletions(parentSessionId, parentSessionFile, scope);
+        const completions = this.subsessionInbox(parentSessionId, parentSessionFile, scope).pending();
+        this.receiveSubsessionCompletions(parentSessionId, parentSessionFile, completions, toolCallId, scope);
+        return { subsessions, completions };
+    }
+    subsessionInbox(parentSessionId, parentSessionFile, scope = NORMAL_SESSION_EVENT_SCOPE) {
+        const file = nonEmptyString(parentSessionFile) ?? nonEmptyString(this.active.get(activeSessionKey(parentSessionId, scope))?.runtime.session.sessionFile);
+        const key = subsessionHydratedParentKey(activeSessionKey(parentSessionId, scope), file);
+        let inbox = this.subsessionInboxes.get(key);
+        if (inbox === undefined) {
+            inbox = new SubsessionCompletionInbox();
+            this.subsessionInboxes.set(key, inbox);
+        }
+        return inbox;
+    }
+    restoreSubsessionReceipts(session, releaseClaims = true) {
+        this.subsessionInbox(session.sessionId, session.sessionFile, this.eventScopeForSession(session)).restoreReceipts(session.sessionManager.getBranch().filter((entry) => this.subsessionReceiptMatches(session, entry)), releaseClaims);
+    }
+    subsessionCompletionForOutput(parentId, parentFile, child, messages, scope) {
+        const branch = persistedSubsessionCompletions(child.sessionManager.getBranch()).filter(({ sessionId }) => sessionId === child.sessionId);
+        // A child can be rewound independently of its parent. Never acknowledge an
+        // abandoned branch's newer result while returning the current branch's text.
+        const completion = branch.at(-1) ?? (child.sessionManager.appendCustomEntry === undefined
+            ? this.subsessionInbox(parentId, parentFile, scope).latest(child.sessionId) : undefined);
+        return completion?.finalText === finalAssistantText(messages) ? completion : undefined;
+    }
+    receiveSubsessionCompletions(parentId, parentFile, completions, toolCallId, scope) {
+        if (completions.length === 0)
+            return;
+        const parent = this.active.get(activeSessionKey(parentId, scope))?.runtime.session;
+        if (parent === undefined || (parentFile !== undefined && !sessionFileMatches(parent, parentFile))) {
+            throw new UserFacingError("session.parentReceiptUnavailable", "Parent session {parentSessionId} is not available to receive subsession results", { parentSessionId: parentId });
+        }
+        const inbox = this.subsessionInbox(parentId, parentFile, scope);
+        const completionIds = completions.map(({ completionId }) => completionId).filter((id) => !inbox.hasReceived(id));
+        if (completionIds.length === 0)
+            return;
+        // Persist before removing unread results. A storage failure leaves the
+        // answer unread and fails the tool instead of losing the notification.
+        this.assertTreeNavigationInactive(parent, this.t("session.action.receiveSubsessions", "receive subsession results"));
+        parent.sessionManager.appendCustomEntry?.(SUBSESSION_RECEIPT_ENTRY_TYPE, { receiptOwner: this.subsessionReceiptOwner(parent), completionIds, ...(toolCallId === undefined ? {} : { toolCallId }) });
+        inbox.receive(completionIds);
+    }
+    reconcileSubsessionCompletions(parentId, parentFile, scope) {
+        for (const childId of this.subsessionChildren.get(activeSessionKey(parentId, scope)) ?? []) {
+            if (!this.subsessionLinkBelongsToParent(parentId, nonEmptyString(parentFile), childId, scope))
+                continue;
+            const link = this.subsessionLinks.get(activeSessionKey(childId, scope));
+            const child = link === undefined ? undefined : this.activeChildForSubsessionLink(link)?.runtime.session;
+            if (child !== undefined)
+                this.reconcileSubsessionCompletion(child);
+        }
+    }
+    reconcileSubsessionCompletion(session) {
+        this.updateSubsessionTracking(session);
+        if (!this.hasActiveWork(session) && this.subsessionNotifyArmed.get(activeSessionKey(session.sessionId, this.eventScopeForSession(session))) === true) {
+            throw new UserFacingError("session.subsessionCompletionPersistFailed", "Could not record completion of subsession {sessionId}; its result remains unread. Retry after fixing session storage.", { sessionId: session.sessionId });
+        }
+    }
+    async prepareSubsessionDelivery(parentId, parentFile, managementContext) {
+        const scope = eventScopeFromManagementContext(managementContext);
+        await this.hydrateSubsessionsForParent(parentId, nonEmptyString(parentFile), managementContext);
+        const parent = this.active.get(activeSessionKey(parentId, scope))?.runtime.session;
+        if (parent === undefined || (parentFile !== undefined && !sessionFileMatches(parent, parentFile)))
+            return undefined;
+        // Tool receipts are intents until the successful (possibly nested) result
+        // is persisted. Reconcile those intents without releasing in-flight drafts.
+        this.restoreSubsessionReceipts(parent, false);
+        this.reconcileSubsessionCompletions(parentId, parentFile, scope);
+        const completions = this.subsessionInbox(parentId, parentFile, scope).claim();
+        if (completions.length === 0)
+            return undefined;
+        return {
+            type: "custom_message", customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE, display: true,
+            content: renderSubsessionCompletions(completions, this.workingSubsessionIds(parentId, scope)),
+            details: { receiptOwner: this.subsessionReceiptOwner(parent), sessionId: completions[0]?.sessionId, completionIds: completions.map(({ completionId }) => completionId) },
+        };
+    }
+    async deliverPendingSubsessionCompletions(session) {
+        if (this.hasActiveWork(session) || !this.isCurrentActiveSession(session) || this.subsessionStoppedParents.has(session))
+            return;
+        const inbox = this.subsessionInbox(session.sessionId, session.sessionFile, this.eventScopeForSession(session));
+        const completions = inbox.claim();
+        if (completions.length === 0)
+            return;
+        const completionIds = completions.map(({ completionId }) => completionId);
+        this.subsessionDeliveringParents.add(session);
+        let delivered = false;
+        try {
+            await this.runSessionEntryMutation(session, this.t("session.action.deliverSubsessions", "deliver subsession results"), () => session.sendCustomMessage({
+                customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE, display: true,
+                content: renderSubsessionCompletions(completions, this.workingSubsessionIds(session.sessionId, this.eventScopeForSession(session))),
+                details: { receiptOwner: this.subsessionReceiptOwner(session), sessionId: completions[0]?.sessionId, completionIds },
+            }, { triggerTurn: true }));
+            inbox.receive(completionIds);
+            delivered = true;
+        }
+        catch (error) {
+            this.subsessionStoppedParents.add(session);
+            throw error;
+        }
+        finally {
+            inbox.release(completionIds);
+            this.subsessionDeliveringParents.delete(session);
+            if (delivered)
+                this.scheduleSubsessionDelivery(session);
+            this.publishStatus(session);
+        }
+    }
+    scheduleSubsessionDelivery(session) {
+        if (this.subsessionDeliveryScheduled.has(session) || this.subsessionInbox(session.sessionId, session.sessionFile, this.eventScopeForSession(session)).pending().length === 0)
+            return;
+        this.subsessionDeliveryScheduled.add(session);
+        // Settlement can precede the host prompt-mutation receipt's finally block.
+        // Recheck on the next tick, closing the yield/child-completion race without
+        // restarting a stopped run or putting rendered answers in a follow-up queue.
+        setTimeout(() => {
+            this.subsessionDeliveryScheduled.delete(session);
+            void this.deliverPendingSubsessionCompletions(session).catch((error) => {
+                this.logSubsessionNotificationFailure(session.sessionId, "inbox", error);
             });
+        }, 0);
+    }
+    assertMcpModeAllowed(managementContext) {
+        if (VERSION !== "1.3.0")
+            throw new UserFacingError("mcpAuth.sdkUnsupported", "Dedicated MCP authentication requires Pi 1.3.0");
+        if (managementContext !== undefined && !managementUsesNormalPermissions(managementContext, { allowPrivileged: this.managementAllowPrivileged })) {
+            throw new UserFacingError("mcpAuth.restrictedManagement", "MCP authentication is unavailable in restricted management mode");
         }
     }
+    async mcpAuthSession(ref, managementContext) {
+        this.assertMcpModeAllowed(managementContext);
+        await this.assertWritable(ref, managementContext);
+        const session = await this.getOrOpen(ref, managementContext);
+        await this.assertWritable(ref, managementContext);
+        const projectPath = await this.projectPathForCwd?.(ref.cwd);
+        const owner = {
+            scope: eventScopeFromManagementContext(managementContext), sessionId: ref.id, cwd: canonicalizeStoredCwd(ref.cwd),
+            ...(projectPath === undefined ? {} : { projectPath: canonicalizeStoredCwd(projectPath) }),
+        };
+        await this.assertMcpAuthIdentity(ref, session, owner);
+        if (!session.extensionRunner.getRegisteredCommands().some((command) => command.invocationName === "mcp" && command.sourceInfo?.path === "builtin:mcp")) {
+            throw new UserFacingError("mcpAuth.builtinUnavailable", "Pi's built-in MCP command is not available for this session");
+        }
+        if (this.hasActiveWork(session))
+            throw new UserFacingError("mcpAuth.waitForIdle", "Wait for current session activity before authenticating MCP");
+        this.mcpAuthOwners.set(session, owner);
+        return { session, owner };
+    }
+    async assertMcpAuthIdentity(ref, session, owner) {
+        this.assertCurrentExtensionSession(session);
+        if (session.sessionId !== ref.id || !cwdPathsEqual(ref.cwd, session.sessionManager.getCwd()) || this.eventScopeForSession(session) !== owner.scope) {
+            throw new UserFacingError("mcpAuth.workspaceChanged", "MCP authentication session workspace changed");
+        }
+        await this.assertMcpProjectOwner(owner);
+        this.assertCurrentExtensionSession(session);
+        if (session.sessionId !== ref.id || !cwdPathsEqual(ref.cwd, session.sessionManager.getCwd()) || this.eventScopeForSession(session) !== owner.scope) {
+            throw new UserFacingError("mcpAuth.workspaceChanged", "MCP authentication session workspace changed");
+        }
+        if (session.settingsManager.isProjectTrusted?.() !== true)
+            throw new UserFacingError("mcpAuth.trustRequired", "MCP authentication requires a trusted workspace");
+    }
+    async authorizedMcpFlowOwner(flowId, managementContext) {
+        const owner = this.mcpAuthFlows.owner(flowId, eventScopeFromManagementContext(managementContext));
+        this.assertMcpModeAllowed(managementContext);
+        // Polling never constructs a runtime. Revalidate the captured project even
+        // after the command ends, rather than trusting the browser's current cwd.
+        await this.assertMcpProjectOwner(owner);
+        return owner;
+    }
+    async assertMcpProjectOwner(owner) {
+        const projectPath = await this.projectPathForCwd?.(owner.cwd);
+        if ((projectPath === undefined) !== (owner.projectPath === undefined)
+            || (projectPath !== undefined && owner.projectPath !== undefined && !cwdPathsEqual(projectPath, owner.projectPath))) {
+            throw new UserFacingError("mcpAuth.flowNotFound", "MCP authentication flow not found");
+        }
+        if (owner.scope === NORMAL_SESSION_EVENT_SCOPE)
+            await this.normalModelRuntimeForCwd(owner.cwd);
+    }
+    async mcpAuthFlow(flowId, managementContext) {
+        return this.mcpAuthFlows.get(flowId, await this.authorizedMcpFlowOwner(flowId, managementContext));
+    }
+    async respondToMcpAuthFlow(flowId, requestId, value, managementContext) {
+        return this.mcpAuthFlows.respond(flowId, requestId, value, await this.authorizedMcpFlowOwner(flowId, managementContext));
+    }
+    async cancelMcpAuthFlow(flowId, managementContext) {
+        return this.mcpAuthFlows.cancel(flowId, await this.authorizedMcpFlowOwner(flowId, managementContext));
+    }
+    async discoverMcpAuthServers(ref, session, owner, managementContext) {
+        return this.mcpAuthFlows.discover({
+            owner, identity: session,
+            isCurrent: () => this.isCurrentActiveSession(session) && cwdPathsEqual(ref.cwd, session.sessionManager.getCwd()) && session.settingsManager.isProjectTrusted?.() === true,
+            run: async () => {
+                // The SDK has no public MCP readiness promise. In RPC mode this supported
+                // status command awaits startup without reconnecting or touching tokens.
+                await session.prompt("/mcp", { expandPromptTemplates: true });
+                await this.assertWritable(ref, managementContext);
+                await this.assertMcpAuthIdentity(ref, session, owner);
+                const command = session.extensionRunner.getRegisteredCommands().find((candidate) => candidate.invocationName === "mcp" && candidate.sourceInfo?.path === "builtin:mcp");
+                if (!command)
+                    throw new UserFacingError("mcpAuth.builtinUnavailable", "Pi's built-in MCP command is not available for this session");
+                const completions = await command.getArgumentCompletions?.("login ") ?? [];
+                await this.assertWritable(ref, managementContext);
+                await this.assertMcpAuthIdentity(ref, session, owner);
+                if (completions.length > 200)
+                    throw new UserFacingError("mcpAuth.tooManyServers", "Too many MCP authentication servers");
+                const servers = [];
+                for (const item of completions) {
+                    const name = item.value.startsWith("login ") ? item.value.slice(6) : "";
+                    // Commands split on whitespace. Never forward an arbitrary suffix or
+                    // a name that could change the builtin command's argument structure.
+                    if (name.length === 0 || name.length > 256 || /\s/u.test(name) || Array.from(name).some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127))
+                        continue;
+                    if ((item.description?.length ?? 0) > 32 * 1024)
+                        throw new UserFacingError("mcpAuth.descriptionTooLarge", "MCP server description is too large");
+                    if (!servers.some((server) => server.name === name))
+                        servers.push({ name, ...(item.description === undefined ? {} : { description: item.description }) });
+                }
+                return servers;
+            },
+        });
+    }
+    async mcpAuthServers(ref, managementContext) {
+        const { session, owner } = await this.mcpAuthSession(ref, managementContext);
+        if (this.hasActiveWork(session))
+            throw new UserFacingError("mcpAuth.waitForIdleListing", "Wait for current session activity before listing MCP servers");
+        return this.runSessionEntryMutation(session, "list MCP authentication servers", async () => ({ servers: await this.discoverMcpAuthServers(ref, session, owner, managementContext) }));
+    }
+    async startMcpAuth(ref, mode, serverName, managementContext) {
+        const { session, owner } = await this.mcpAuthSession(ref, managementContext);
+        if (this.hasActiveWork(session))
+            throw new UserFacingError("mcpAuth.waitForIdle", "Wait for current session activity before authenticating MCP");
+        const servers = await this.runSessionEntryMutation(session, "discover MCP authentication servers", () => this.discoverMcpAuthServers(ref, session, owner, managementContext));
+        if (serverName !== undefined && !servers.some((server) => server.name === serverName))
+            throw new UserFacingError("mcpAuth.ineligibleServer", "Unknown or ineligible MCP authentication server");
+        await this.assertMcpAuthIdentity(ref, session, owner);
+        if (this.hasActiveWork(session))
+            throw new UserFacingError("mcpAuth.waitForIdle", "Wait for current session activity before authenticating MCP");
+        return this.mcpAuthFlows.start({
+            owner, mode,
+            identity: session,
+            isCurrent: () => this.isCurrentActiveSession(session) && session.sessionId === ref.id && cwdPathsEqual(ref.cwd, session.sessionManager.getCwd()) && session.settingsManager.isProjectTrusted?.() === true,
+            // This is an awaited extension command, not a model prompt submission.
+            // Avoid prompt echoes/activity and the fire-and-forget command receipt.
+            run: () => this.runSessionEntryMutation(session, "authenticate MCP", async () => {
+                const operation = McpAuthFlowService.current(session);
+                if (!operation)
+                    throw new UserFacingError("mcpAuth.sessionNotCurrent", "MCP authentication session is no longer current");
+                if (servers.length === 0) {
+                    operation.notify(this.t("mcpAuth.noEligibleServers", "No eligible MCP servers are available for this action."));
+                    return;
+                }
+                const selected = serverName ?? await operation.selectServer(servers);
+                if (selected === undefined || operation.isCancelled())
+                    return;
+                await this.assertWritable(ref, managementContext);
+                await this.assertMcpAuthIdentity(ref, session, owner);
+                const fresh = await this.discoverMcpAuthServers(ref, session, owner, managementContext);
+                if (!fresh.some((server) => server.name === selected))
+                    throw new UserFacingError("mcpAuth.serverNoLongerEligible", "MCP authentication server is no longer eligible");
+                if (operation.isCancelled())
+                    return;
+                operation.setServer(selected);
+                await session.prompt(`/mcp ${mode} ${selected}`, { expandPromptTemplates: true });
+            }),
+        });
+    }
 }
 function previewResponseFromPlan(plan) {
     return {
@@ -4153,13 +5044,13 @@ function bulkRefToLookup(ref) {
     return ref;
 }
 function findArchivedRecordForBulkRef(records, ref) {
-    return records.find((record) => record.cwd === ref.cwd && (record.sessionId === ref.id || record.sessionId.startsWith(ref.id)));
+    return records.find((record) => record.cwd === ref.cwd && record.sessionId === ref.id);
 }
 function findListedSessionForBulkRef(context, ref) {
-    return findSessionByIdOrPrefix(context.sessionsByCwd.get(ref.cwd) ?? [], ref.id);
+    return findSessionByExactId(context.sessionsByCwd.get(ref.cwd) ?? [], ref.id);
 }
-function findSessionByIdOrPrefix(sessions, sessionId) {
-    return sessions.find((session) => session.id === sessionId) ?? sessions.find((session) => session.id.startsWith(sessionId));
+function findSessionByExactId(sessions, sessionId) {
+    return sessions.find((session) => session.id === sessionId);
 }
 function uniqueStrings(values) {
     return [...new Set(values)];
@@ -4196,12 +5087,27 @@ function notificationIdentityForSession(session) {
         cwd: canonicalizeStoredCwd(session.sessionManager.getCwd()),
     };
 }
+function clientSessionFromActiveSession(session) {
+    const header = session.sessionManager.getHeader?.();
+    const created = header?.timestamp ?? new Date().toISOString();
+    const metadata = readSessionUiMetadata(session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch());
+    return {
+        id: session.sessionId, path: session.sessionFile ?? "", cwd: session.sessionManager.getCwd(),
+        persisted: sessionFileExists(session.sessionFile), created, modified: created,
+        messageCount: transcriptMessageCount(session.sessionManager.getBranch()), firstMessage: "",
+        ...(metadata === undefined ? {} : { metadata }),
+        ...(session.sessionName === undefined ? {} : { name: session.sessionName }),
+        ...(header?.parentSession === undefined ? {} : { parentSessionPath: header.parentSession }),
+    };
+}
 function clientSessionFromListEntry(session) {
     return {
         id: session.id,
         path: session.path,
         cwd: session.cwd,
         persisted: true,
+        ...(session.agentSubsession === true ? { agentSubsession: true } : {}),
+        ...(session.metadata === undefined ? {} : { metadata: requireSessionUiMetadata(session.metadata) }),
         ...(session.name === undefined ? {} : { name: session.name }),
         created: session.created.toISOString(),
         modified: session.modified.toISOString(),
@@ -4319,37 +5225,6 @@ function persistedChildSubsessionLinkData(parentSessionId, childSessionId) {
         spawnedSessionId: childSessionId,
     };
 }
-function parsePersistedParentSubsessionLink(entry) {
-    if (!isRecord(entry) || entry["type"] !== "custom" || entry["customType"] !== SUBSESSION_LINK_CUSTOM_TYPE)
-        return undefined;
-    const data = entry["data"];
-    if (!isRecord(data))
-        return undefined;
-    const spawnedBySessionId = getString(data, "spawnedBySessionId");
-    const spawnedSessionId = getString(data, "spawnedSessionId");
-    if (spawnedBySessionId === undefined || spawnedBySessionId === "" || spawnedSessionId === undefined || spawnedSessionId === "")
-        return undefined;
-    const spawnedSessionFile = getString(data, "spawnedSessionFile");
-    const cwd = getString(data, "cwd");
-    return {
-        spawnedBySessionId,
-        spawnedSessionId,
-        ...(spawnedSessionFile === undefined || spawnedSessionFile === "" ? {} : { spawnedSessionFile }),
-        ...(cwd === undefined || cwd === "" ? {} : { cwd }),
-    };
-}
-function parsePersistedChildSubsessionLink(entry) {
-    if (!isRecord(entry) || entry["type"] !== "custom" || entry["customType"] !== SUBSESSION_CHILD_LINK_CUSTOM_TYPE)
-        return undefined;
-    const data = entry["data"];
-    if (!isRecord(data))
-        return undefined;
-    const spawnedBySessionId = getString(data, "spawnedBySessionId");
-    const spawnedSessionId = getString(data, "spawnedSessionId");
-    if (spawnedBySessionId === undefined || spawnedBySessionId === "" || spawnedSessionId === undefined || spawnedSessionId === "")
-        return undefined;
-    return { spawnedBySessionId, spawnedSessionId };
-}
 function nonEmptyString(value) {
     return value === undefined || value === "" ? undefined : value;
 }
@@ -4408,12 +5283,37 @@ function clearParentSessionHeader(sessionManager) {
 function clearSessionQueue(session) {
     session.clearQueue();
 }
-function queuedMessagesFromSession(session, extraQueuedMessages = []) {
-    return [
-        ...session.getSteeringMessages().map((text) => ({ kind: "steer", text })),
-        ...session.getFollowUpMessages().map((text) => ({ kind: "followUp", text })),
-        ...extraQueuedMessages,
-    ];
+function queuedMessagesFromSession(session, extraQueuedMessages = [], inspectSdk = true) {
+    const texts = inspectSdk
+        ? { steer: mutableTextMirror(session.getSteeringMessages()), followUp: mutableTextMirror(session.getFollowUpMessages()) }
+        : { steer: publicQueueTexts(() => session.getSteeringMessages()), followUp: publicQueueTexts(() => session.getFollowUpMessages()) };
+    const attachmentCounts = { steer: [], followUp: [] };
+    if (inspectSdk && (texts.steer.length > 0 || texts.followUp.length > 0 || extraQueuedMessages.length > 0)) {
+        const queues = snapshotAgentQueues(mutableQueueAgent(session.agent));
+        for (const kind of ["steer", "followUp"]) {
+            attachmentCounts[kind] = queuedMessageAttachmentCounts(queues[kind], texts[kind]);
+        }
+    }
+    return ["steer", "followUp"].flatMap((kind) => [
+        ...texts[kind].map((text, index) => ({ kind, text, ...queuedAttachmentMetadata(attachmentCounts[kind][index] ?? 0) })),
+        ...extraQueuedMessages.filter((message) => message.kind === kind).map((prompt) => ({
+            kind, text: prompt.text,
+            ...queuedAttachmentMetadata(prompt.message === undefined ? prompt.images?.length ?? 0 : queuedMessageAttachmentCount(prompt.message)),
+        })),
+    ]);
+}
+/** Degraded status still uses public text getters where their values are usable. */
+function publicQueueTexts(read) {
+    try {
+        const value = read();
+        return Array.isArray(value) ? value.filter((text) => typeof text === "string") : [];
+    }
+    catch {
+        return [];
+    } // The compatibility guard already records the original failure.
+}
+function queuedAttachmentMetadata(attachmentCount) {
+    return attachmentCount > 0 ? { hasAttachments: true, attachmentCount } : {};
 }
 function userTextMessage(text) {
     return { role: "user", content: text };
@@ -4469,6 +5369,55 @@ function activeEditableTreeTargetParentId(manager, targetId, activeLeafId) {
         return undefined;
     return parentId === null || typeof parentId === "string" ? parentId : undefined;
 }
+/**
+ * Pi edits custom messages from their parent. For a retained checkpoint, remap
+ * that single leaf movement instead, before Pi rebuilds context/restores tools
+ * and emits session_tree. Restore the manager methods before extension handlers
+ * run: their appended history must not be overwritten by a post-event repair.
+ * The caller holds the tree-navigation gate and excludes branch summarization.
+ */
+async function navigateTreeRetainingCustomMessage(manager, targetId, parentId, navigate) {
+    if (parentId !== null && typeof parentId !== "string")
+        throw new UserFacingError("session.checkpointParent", "This checkpoint has no valid history parent");
+    // eslint-disable-next-line @typescript-eslint/unbound-method -- Restore exact identities; calls below explicitly bind the manager.
+    const { branch, resetLeaf } = manager;
+    let pending = true;
+    const restore = () => {
+        if (!pending)
+            return;
+        pending = false;
+        manager.branch = branch;
+        manager.resetLeaf = resetLeaf;
+    };
+    try {
+        manager.branch = (entryId) => {
+            if (entryId === parentId) {
+                restore();
+                branch.call(manager, targetId);
+            }
+            else
+                branch.call(manager, entryId);
+        };
+        manager.resetLeaf = () => {
+            if (parentId === null) {
+                restore();
+                branch.call(manager, targetId);
+            }
+            else
+                resetLeaf.call(manager);
+        };
+        const result = await navigate();
+        if (result.cancelled)
+            return result;
+        // The retained notice is context, not text to restore into the editor.
+        const { editorText, ...retainedResult } = result;
+        void editorText;
+        return retainedResult;
+    }
+    finally {
+        restore();
+    }
+}
 function setSessionTreeLeaf(manager, leafId) {
     if (leafId === null)
         manager.resetLeaf();
@@ -4482,16 +5431,6 @@ function transcriptBranchIncludesEntry(entries, entryId) {
 const SUBSESSION_LINK_CUSTOM_TYPE = "pi-web.subsession.link";
 /** custom entry type used to mark a child as created by spawn_subsession. */
 const SUBSESSION_CHILD_LINK_CUSTOM_TYPE = "pi-web.subsession.spawned";
-/** customType marking a parent-facing subsession-completion notice. */
-const SUBSESSION_NOTIFICATION_CUSTOM_TYPE = "subsession.completion";
-const SUBSESSION_NOTIFICATION_MAX_OUTPUT_CHARS = 2000;
-/** Avoid duplicating a partial result in context when deliberate inspection can return the full output. */
-function formatSubsessionNotificationOutput(childSessionId, text) {
-    if (text.length > SUBSESSION_NOTIFICATION_MAX_OUTPUT_CHARS) {
-        return `Output from subsession ${childSessionId} was too long for this completion notice and was omitted. Call check_subsession with sessionId "${childSessionId}" to retrieve the final output.`;
-    }
-    return `--- SUBSESSION OUTPUT: ${childSessionId} ---\n${text === "" ? "(no output)" : text}`;
-}
 /** Most recent assistant text from a history message list, or "" if none. */
 function finalAssistantText(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -4533,4 +5472,20 @@ async function resolveManagementAuditIdentity(cwd, context, resolveProjectId, lo
         projectId,
     };
 }
+function transcriptReturnsFinalOutput(messages, view, finalText) {
+    if (finalText === "")
+        return false;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const text = finalAssistantText([messages[index]]);
+        if (text === "")
+            continue;
+        const entry = view.entries.find((candidate) => candidate.index === index && candidate.role === "assistant");
+        if (entry === undefined || text !== finalText)
+            return false;
+        const texts = entry.parts.filter((part) => part.kind === "text");
+        return texts.every((part) => part.truncated === undefined)
+            && texts.map((part) => part.text).join("\n").trim() === finalText.trim();
+    }
+    return false;
+}
 //# sourceMappingURL=piSessionService.js.map