@chainingintention/pi-web-cn 1.202610.1 → 1.202610.2

package/dist/server/sessions/piSessionService.js

@@ -1,12 +1,14 @@
 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, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, getAgentDir, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, readStoredCredential, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEventBus, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, getAgentDir, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, ProjectTrustStore, hasTrustRequiringProjectResources, readStoredCredential, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { projectBrowserMessage } from "../browserMessageProjection.js";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
 import { eventScopeFromManagementContext, managementContextKey, NORMAL_SESSION_EVENT_SCOPE } from "../realtime/sessionEventScope.js";
 import { BUILTIN_COMMANDS } from "./builtinCommands.js";
 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";
@@ -16,17 +18,20 @@ import { attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachm
 import { loadEffectiveProjectAttachmentsConfig } from "../workspaces/projectPiWebConfig.js";
 import { parsePromptAttachments } from "../../shared/promptAttachments.js";
 import { ASK_USER_ANSWERS_CUSTOM_TYPE, SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH, SESSION_UNREAD_LIMIT } from "../../shared/apiTypes.js";
+import { PiSessionEventConnections } from "./piSessionEventConnections.js";
+import { resolveWebProjectTrusted } from "./projectTrust.js";
 import { createPiSessionManagerGateway } from "./piSessionManagerGateway.js";
 import { SessionPinStore } from "./sessionPinStore.js";
 import { SessionActivityCoordinator } from "./sessionActivityCoordinator.js";
 import { searchSessionContent } from "./sessionContentSearch.js";
-import { createLocalOnlyModelRuntime } from "./authService.js";
+import { createLocalOnlyModelRuntime, modelRuntimeAuthPath } from "./authService.js";
 import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
 import { clearSessionFileParent, readSessionHeaderSummary } from "./sessionFileHeader.js";
 import { isManagedAgentsFile, workbenchAccessHandle } from "../managementEmbed.js";
-import { managementPrivilegeRequested, managementPrivileges } from "../managementPrivileges.js";
+import { managementPrivilegeRequested, managementPrivileges, managementUsesNormalPermissions } from "../managementPrivileges.js";
 import { DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS, piWebDataDir } from "../../config.js";
 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 { PendingExtensionDialogStore } from "./pendingExtensionDialogStore.js";
@@ -41,8 +46,9 @@ import { SessionNotificationStore } from "./sessionNotificationStore.js";
 import { plainTextTheme } from "./plainTextTheme.js";
 import { deduplicateBundledRelaySkills, ensureManagedRelaySkills, MANAGED_RELAY_SKILL_NAMES } from "./relaySkill.js";
 import { SessionUnreadStore } from "./sessionUnreadStore.js";
-import { archiveCandidateFromActiveSession, archiveCandidateFromArchivedRecord, archiveCandidateFromListEntry, archiveInputFromActiveSession, archiveInputFromCandidate, archiveInputFromListEntry, clientSessionFromArchivedRecord, compareArchivedRecords, } from "./sessionArchiveMapping.js";
-import { annotateAssistantThinkingLevel, getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
+import { archiveCandidateFromActiveSession, archiveCandidateFromArchivedRecord, archiveCandidateFromListEntry, archiveInputFromActiveSession, archiveInputFromCandidate, archiveInputFromListEntry, clientSessionFromArchivedRecord, } from "./sessionArchiveMapping.js";
+import { 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";
 const noopLogger = { info() { } };
@@ -65,24 +71,16 @@ const MAX_UNREAD_PUBLICATION_RETRY_MS = 30_000;
 const MAX_PENDING_UNREAD_MUTATIONS = SESSION_UNREAD_LIMIT + 1;
 const IDLE_SESSION_FILE_RESOLUTION_THROTTLE_MS = 30_000;
 function auditVisibleAssistantMessage(message) {
-    if (!isAuditRecord(message))
+    if (!isRecord(message) || Array.isArray(message))
         return message;
-    const record = message;
-    const content = record["content"];
+    const content = message["content"];
     if (!Array.isArray(content))
         return message;
     return {
-        ...record,
-        content: content.filter(part => (typeof part !== "object"
-            || part === null
-            || Array.isArray(part)
-            || !isAuditRecord(part)
-            || part["type"] !== "thinking")),
+        ...message,
+        content: content.filter(part => !isRecord(part) || Array.isArray(part) || part["type"] !== "thinking"),
     };
 }
-function isAuditRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function noop() {
     // Intentionally empty default unsubscribe callback.
 }
@@ -143,9 +141,9 @@ function sessionTreeNavigationOptions(request) {
         case "custom": {
             const customInstructions = request.summary.instructions.trim();
             if (customInstructions === "")
-                throw new Error("Custom branch-summary instructions are required");
+                throw new Error("自定义分支汇总要求不能为空");
             if (customInstructions.length > SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH) {
-                throw new Error(`Custom branch-summary instructions must be at most ${String(SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH)} characters`);
+                throw new Error(`自定义分支汇总要求不能超过 ${String(SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH)} 个字符`);
             }
             return { summarize: true, customInstructions };
         }
@@ -381,67 +379,108 @@ export function piWebResourceLoaderOptions(appendSystemPromptSections) {
         return undefined;
     return { appendSystemPromptOverride: (base) => [...base, ...appendSystemPromptSections] };
 }
-function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions, askUser, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd, appendSystemPromptSections = [], managementAllowPrivileged = false) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, initialThinkingLevel, delegationToolsEnabled = true }) => {
+async function createNormalPermissionSessionServices(options) {
+    const { cwd, agentDir, settingsManager, projectTrustRequiring } = options;
+    const projectTrustDiagnostics = [];
+    const services = await createAgentSessionServices({
+        cwd,
+        agentDir,
+        modelRuntime: options.modelRuntime,
+        settingsManager,
+        resourceLoaderOptions: {
+            ...piWebResourceLoaderOptions(options.appendSystemPromptSections),
+            eventBus: options.eventBus,
+            ...(options.agentsFilesOverride === undefined ? {} : { agentsFilesOverride: options.agentsFilesOverride }),
+            skillsOverride: (base) => deduplicateBundledRelaySkills(cwd, base),
+        },
+        ...(projectTrustRequiring ? {
+            resourceLoaderReloadOptions: {
+                resolveProjectTrust: async ({ extensionsResult }) => resolveWebProjectTrusted({
+                    cwd,
+                    trustStore: new ProjectTrustStore(agentDir),
+                    settingsManager,
+                    extensionsResult,
+                    onExtensionError: (message) => projectTrustDiagnostics.push({ type: "warning", message }),
+                }),
+            },
+        } : {}),
+    });
+    return { services, projectTrustDiagnostics };
+}
+function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUser, 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, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged, appendSystemPromptSections)({
+            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged, appendSystemPromptSections)({
                 cwd,
                 agentDir,
                 sessionManager,
-                delegationToolsEnabled,
+                ...(delegationToolsEnabled === undefined ? {} : { delegationToolsEnabled }),
                 ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
                 ...(initialModel === undefined ? {} : { initialModel }),
                 ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
             });
         }
-        const settingsManager = await createScopedSettingsManager({
-            cwd,
-            scopeDirectory: await resolveSettingsScope(cwd, "normal"),
-            globalAgentDir: agentDir,
-            mode: "normal",
-        });
-        const resourceLoaderOptions = {
-            ...piWebResourceLoaderOptions(appendSystemPromptSections),
-            skillsOverride: (base) => deduplicateBundledRelaySkills(cwd, base),
-        };
-        const services = await createAgentSessionServices({
-            cwd,
-            agentDir,
-            modelRuntime: scopedModelRuntime,
-            settingsManager,
-            resourceLoaderOptions,
-        });
-        const modelOptions = await resolveSessionModelOptions({
-            services,
-            hasExistingSession: sessionManager.buildSessionContext().messages.length > 0,
-            ...(initialModel === undefined ? {} : { initialModel }),
-            ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
-        });
-        services.diagnostics.push(...modelOptions.diagnostics);
-        const customTools = createPiWebCustomToolDefinitions(cwd, delegationToolsEnabled, spawn, subsessions, askUser);
-        const result = await createAgentSessionFromServices({
-            services,
-            sessionManager,
-            customTools,
-            ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
-            ...(modelOptions.model === undefined ? {} : { model: modelOptions.model }),
-            ...(modelOptions.thinkingLevel === undefined ? {} : { thinkingLevel: modelOptions.thinkingLevel }),
-            ...(modelOptions.scopedModels.length === 0 ? {} : { scopedModels: modelOptions.scopedModels }),
+        // Resource loaders may read process.env; wait for managed overrides to be restored.
+        return withRuntimeCreationEnvironment({}, async () => {
+            const projectTrustRequiring = hasTrustRequiringProjectResources(cwd);
+            const settingsManager = await createScopedSettingsManager({
+                cwd,
+                scopeDirectory: await resolveSettingsScope(cwd, "normal"),
+                globalAgentDir: agentDir,
+                mode: "normal",
+                projectTrusted: !projectTrustRequiring,
+            });
+            // Only normal runtimes register a host connection; privileged management
+            // packages keep their own event bus without exposing a normal-mode session.
+            const eventBus = createEventBus();
+            const { services, projectTrustDiagnostics } = await createNormalPermissionSessionServices({
+                cwd,
+                agentDir,
+                modelRuntime: scopedModelRuntime,
+                settingsManager,
+                projectTrustRequiring,
+                appendSystemPromptSections,
+                eventBus,
+            });
+            const modelOptions = await resolveSessionModelOptions({
+                services,
+                hasExistingSession: sessionManager.buildSessionContext().messages.length > 0,
+                ...(initialModel === undefined ? {} : { initialModel }),
+                ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
+            });
+            services.diagnostics.push(...modelOptions.diagnostics);
+            const resolvedDelegationToolsEnabled = delegationToolsEnabled
+                ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
+            const customTools = createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions, askUser);
+            const result = await createAgentSessionFromServices({
+                services,
+                sessionManager,
+                customTools,
+                ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
+                ...(modelOptions.model === undefined ? {} : { model: modelOptions.model }),
+                ...(modelOptions.thinkingLevel === undefined ? {} : { thinkingLevel: modelOptions.thinkingLevel }),
+                ...(modelOptions.scopedModels.length === 0 ? {} : { scopedModels: modelOptions.scopedModels }),
+            });
+            sessionEvents.register(result.session, eventBus);
+            const reload = result.session.reload.bind(result.session);
+            result.session.reload = (options) => withRuntimeCreationEnvironment({}, () => reload(options));
+            return { ...result, services, diagnostics: [...projectTrustDiagnostics, ...services.diagnostics] };
         });
-        return { ...result, services, diagnostics: services.diagnostics };
     };
 }
-function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged = false, appendSystemPromptSections = []) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled = true }) => {
+function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUser, 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 fullPrivileges = privileges.full === true;
-        if (!fullPrivileges)
+        const resolvedDelegationToolsEnabled = delegationToolsEnabled
+            ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
+        if (!normalPermissions)
             await ensureManagedRelaySkills(cwd);
         const auditIdentity = await resolveManagementAuditIdentity(cwd, managementContext, managementProjectIdForCwd, logger);
         const accessHandle = workbenchAccessHandle(managementContext);
-        const state = workbench === undefined ? undefined : await workbench.accessStates.prepare(accessHandle, workbench.client);
-        const receipt = state === undefined || fullPrivileges ? undefined : await workbench?.skills.synchronize(cwd, state, {
+        const state = normalPermissions || workbench === undefined ? undefined : await workbench.accessStates.prepare(accessHandle, workbench.client);
+        const receipt = state === undefined ? undefined : await workbench?.skills.synchronize(cwd, state, {
             ...(managementAudit === undefined ? {} : { recorder: managementAudit }),
             ...auditIdentity,
             sessionId: sessionManager.getSessionId(),
@@ -467,13 +506,18 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spaw
         const scopedSubsessions = subsessions === undefined
             ? undefined
             : {
-                ...subsessions,
                 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),
             };
+        const scopedAskUser = askUser === undefined ? undefined : {
+            open: (input) => askUser.open({ ...input, managementContext }),
+        };
         const controlledManagementTools = [
-            ...(delegationToolsEnabled && scopedSpawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn: scopedSpawn }))] : []),
-            ...(delegationToolsEnabled && scopedSubsessions !== undefined ? createSubsessionToolDefinitions(cwd, scopedSubsessions).map((tool) => defineTool(tool)) : []),
-            ...(askUser === undefined ? [] : [createAskUserToolDefinition(askUser)]),
+            ...(resolvedDelegationToolsEnabled && scopedSpawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn: scopedSpawn }))] : []),
+            ...(resolvedDelegationToolsEnabled && scopedSubsessions !== undefined ? createSubsessionToolDefinitions(cwd, scopedSubsessions).map((tool) => defineTool(tool)) : []),
+            ...(scopedAskUser === undefined ? [] : [createAskUserToolDefinition(scopedAskUser)]),
             ...workbenchTools,
         ];
         const controlledManagementToolNames = controlledManagementTools.map((tool) => tool.name);
@@ -485,28 +529,36 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spaw
             }, "management privileged grant ignored because managementEmbed.allowPrivileged is disabled");
         }
         const extraToolNames = [...controlledManagementToolNames, ...privilegedManagementToolNames(privileges)];
-        const policyAgentDir = fullPrivileges ? undefined : await writeManagementPermissionSystemPolicy(agentDir, cwd, managementContext, extraToolNames, privileges);
-        return withRuntimeCreationEnvironment(fullPrivileges ? {} : { [PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR]: policyAgentDir }, async () => {
+        const policyAgentDir = normalPermissions ? undefined : await writeManagementPermissionSystemPolicy(agentDir, cwd, managementContext, extraToolNames, privileges);
+        const resourceEnvironment = normalPermissions ? {} : { [PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR]: policyAgentDir };
+        return withRuntimeCreationEnvironment(resourceEnvironment, async () => {
             const settingsManager = await createScopedSettingsManager({
                 cwd,
                 scopeDirectory: await resolveSettingsScope(cwd, "management"),
                 globalAgentDir: agentDir,
                 mode: "management",
+                // Signed management entry authorizes the project without changing ordinary trust decisions.
+                projectTrusted: true,
             });
-            const services = await createAgentSessionServices({
+            const { services, projectTrustDiagnostics } = normalPermissions ? await createNormalPermissionSessionServices({
                 cwd,
                 agentDir,
                 modelRuntime,
                 settingsManager,
-                resourceLoaderOptions: fullPrivileges ? {
-                    ...piWebResourceLoaderOptions(appendSystemPromptSections),
-                    agentsFilesOverride: (base) => filterPrivilegedManagementContextFiles(cwd, managementContext, base),
-                    skillsOverride: (base) => deduplicateBundledRelaySkills(cwd, base),
-                } : {
-                    agentsFilesOverride: (base) => filterManagedGlobalContextFiles(cwd, agentDir, base),
-                    skillsOverride: (base) => receipt === undefined ? filterManagedProjectSkills(cwd, base) : filterManagedWorkbenchSkills(cwd, base, receipt),
-                },
-            });
+                projectTrustRequiring: false,
+                appendSystemPromptSections,
+                eventBus: createEventBus(),
+                agentsFilesOverride: (base) => filterPrivilegedManagementContextFiles(cwd, managementContext, base),
+            }) : { services: await createAgentSessionServices({
+                    cwd,
+                    agentDir,
+                    modelRuntime,
+                    settingsManager,
+                    resourceLoaderOptions: {
+                        agentsFilesOverride: (base) => filterManagedGlobalContextFiles(cwd, agentDir, base),
+                        skillsOverride: (base) => receipt === undefined ? filterManagedProjectSkills(cwd, base) : filterManagedWorkbenchSkills(cwd, base, receipt),
+                    },
+                }), projectTrustDiagnostics: [] };
             const modelOptions = await resolveSessionModelOptions({
                 services,
                 hasExistingSession: sessionManager.buildSessionContext().messages.length > 0,
@@ -514,12 +566,8 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spaw
                 ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
             });
             services.diagnostics.push(...modelOptions.diagnostics);
-            const managedToolOptions = createManagedAgentToolOptions(cwd);
-            const customTools = fullPrivileges ? [
-                ...createPiWebCustomToolDefinitions(cwd, delegationToolsEnabled, scopedSpawn, scopedSubsessions, askUser),
-                ...workbenchTools,
-            ] : [
-                ...managedAgentToolDefinitions(cwd, managedToolOptions),
+            const customTools = normalPermissions ? createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, scopedSpawn, scopedSubsessions, scopedAskUser) : [
+                ...managedAgentToolDefinitions(cwd, createManagedAgentToolOptions(cwd)),
                 createManagedPythonToolDefinition(cwd, managementContext, { network: privileges.network }),
                 createManagedBashToolDefinition(cwd, managementContext, { network: privileges.network, hostFilesystem: privileges.bash }),
                 ...controlledManagementTools,
@@ -529,13 +577,16 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spaw
                 sessionManager,
                 ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
                 customTools,
-                ...(fullPrivileges ? {} : { tools: managementAgentToolNames(managementContext, extraToolNames, privileges) }),
+                ...(normalPermissions ? {} : { tools: managementAgentToolNames(managementContext, extraToolNames, privileges) }),
                 ...(modelOptions.model === undefined ? {} : { model: modelOptions.model }),
                 ...(modelOptions.thinkingLevel === undefined ? {} : { thinkingLevel: modelOptions.thinkingLevel }),
                 ...(modelOptions.scopedModels.length === 0 ? {} : { scopedModels: modelOptions.scopedModels }),
             };
             const result = await createAgentSessionFromServices(options);
-            return { ...result, services, diagnostics: services.diagnostics };
+            // 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, () => reload(options));
+            return { ...result, services, diagnostics: [...projectTrustDiagnostics, ...services.diagnostics] };
         });
     };
 }
@@ -591,6 +642,7 @@ export class PiSessionService {
         this.activities = new SessionActivityCoordinator();
         /** Runtime-identity gate held while Pi may await abandoned-branch summarization. */
         this.treeNavigations = new WeakSet();
+        this.unpersistedTreeBranchLeaves = new WeakMap();
         /** Counts async operations that may append an entry before they settle. */
         this.sessionEntryMutationCounts = new WeakMap();
         /** Serializes enabled-model read/modify/write operations. */
@@ -626,6 +678,7 @@ export class PiSessionService {
         this.scopedNotificationStores = new Map();
         this.scopedUnreadStores = new Map();
         this.sessionEventScopes = new WeakMap();
+        this.sessionManagementContexts = new WeakMap();
         this.notificationGenerationBySession = new WeakMap();
         this.idleSessionFileResolutions = new WeakMap();
         /** The parked extension Promise resolvers behind the store's open dialogs. */
@@ -659,6 +712,10 @@ export class PiSessionService {
         this.managementAudit = deps.managementAudit;
         this.managementProjectIdForCwd = deps.managementProjectIdForCwd;
         this.now = deps.now ?? (() => new Date());
+        this.activityMarker = new SessionActivityMarker({
+            now: () => this.now().getTime(),
+            onError: (error) => { this.logger.info({ err: error }, "Could not update advisory session activity marker"); },
+        });
         this.notificationStore = deps.notificationStore ?? new SessionNotificationStore();
         this.unreadStore = deps.unreadStore ?? new SessionUnreadStore();
         this.onUnreadChanged = deps.onUnreadChanged;
@@ -672,18 +729,19 @@ export class PiSessionService {
         // Subsessions are gated behind their own flag, and they
         // also require the spawn capability (they share its project-scope resolver).
         const subsessionsActive = this.spawnTargets !== undefined && deps.subsessionsEnabled === true;
-        this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.normalModelRuntimeForCwd, this.managementModelRuntime, (cwd, mode) => this.resolveSettingsScopeDirectory(cwd, mode), this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
+        this.sessionEvents = deps.sessionEvents ?? new PiSessionEventConnections();
+        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) => this.listSubsessions(parentSessionId, parentSessionFile),
-            check: (parentSessionId, sessionId, parentSessionFile) => this.checkSubsession(parentSessionId, sessionId, parentSessionFile),
-            read: (parentSessionId, sessionId, query, parentSessionFile) => this.readSubsession(parentSessionId, sessionId, query, parentSessionFile),
-        }, deps.askUserEnabled === true ? { open: (input) => this.openAsk(input) } : undefined, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd, deps.appendSystemPromptSections ?? [], deps.managementAllowPrivileged === true);
+            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);
         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, "compact the session");
+                this.beginSessionEntryMutation(session, "压缩会话");
                 this.publishActivity(session, "正在压缩上下文", "active");
                 this.publishStatus(session);
             },
@@ -702,7 +760,7 @@ export class PiSessionService {
             isTreeNavigationActive: (session) => this.treeNavigations.has(session),
             runSessionReplacement: (session, operation) => {
                 const runtime = this.activeRuntimeForSession(session);
-                return this.runTreeExclusiveOperation([{ sessionId: session.sessionId, session, ...(runtime === undefined ? {} : { runtime }) }], "Stop current session activity before replacing the session", operation);
+                return this.runTreeExclusiveOperation([{ sessionId: session.sessionId, session, ...(runtime === undefined ? {} : { runtime }) }], "替换会话前请先停止当前会话活动", operation);
             },
         }, { listSessionNames: (cwd) => this.listSessionNames(cwd) });
     }
@@ -750,7 +808,6 @@ export class PiSessionService {
             await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" }, scope);
             readyDeleteRecords.push(record);
         }
-        await this.ensureArchivedRecordsMoved(readyDeleteRecords);
         const deletedSessionIds = new Set(await this.archiveStoreDeleteArchivedMany(readyDeleteRecords.map((record) => record.sessionId)));
         deleteRecords.push(...readyDeleteRecords.filter((record) => deletedSessionIds.has(record.sessionId)));
         await this.forgetUnreadSessions(deleteRecords, scope);
@@ -777,7 +834,7 @@ 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(active.runtime.session.sessionId);
+            this.pendingAskStore.forgetSession(this.dialogSessionKey(active.runtime.session));
             this.endSessionExtensionDialogs(active.runtime.session);
         }
         this.active.clear();
@@ -796,10 +853,15 @@ export class PiSessionService {
             store.clearAll("service-dispose");
         await Promise.all(activeSessions.map(async (active) => {
             active.unsubscribe();
+            active.runtime.setRebindSession(undefined);
             this.workspaceActivity?.removeSession(active.runtime.session.sessionId, active.runtime.session.sessionManager.getCwd(), active.eventScope);
-            await active.runtime.session.abort();
-            await active.runtime.dispose();
-        }));
+            try {
+                await this.abortSessionOperations(active.runtime.session);
+            }
+            finally {
+                await active.runtime.dispose();
+            }
+        })).finally(() => this.activityMarker.dispose());
         await this.publishUnreadMutations([]);
     }
     async list(cwd, managementContext) {
@@ -867,9 +929,9 @@ export class PiSessionService {
             await this.publishUnreadMutations(this.unreadForScope(eventScopeFromManagementContext(managementContext)).reconcileCwd(canonicalizeStoredCwd(cwd), reconcilableSessionIds));
         }
         const archivedSessions = archivedForCwd
-            .sort(compareArchivedRecords)
             .map((record) => clientSessionFromArchivedRecord(record, sessionsById.get(record.sessionId)))
-            .filter(isDefined);
+            .filter(isDefined)
+            .sort((a, b) => Date.parse(b.modified) - Date.parse(a.modified));
         return {
             sessions: [...unarchivedSessions, ...archivedSessions],
             entriesById: new Map(sessions.map((session) => [session.id, session])),
@@ -881,15 +943,42 @@ export class PiSessionService {
             await this.normalModelRuntimeForCwd(cwd);
         return this.startSession(cwd, options);
     }
-    async startSession(cwd, options) {
-        const active = await this.create(this.sessionManager.create(cwd, options.parentSession === undefined ? undefined : { parentSession: options.parentSession }), cwd, {
-            ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
-            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
-            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
-            ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
-            ...(options.startupToken === undefined ? {} : { startupToken: options.startupToken }),
-            startupIntent: "create",
-        });
+    /** Publish a host-owned normal-mode conversation without submitting an initial prompt. */
+    async createHostedSession(cwd, signal) {
+        const created = await this.startManagedSession(cwd, signal);
+        return Object.freeze({ id: created.id });
+    }
+    /** Atomically start and prompt one visible normal-mode, non-delegating session. */
+    async startOneShotRun(cwd, text, signal) {
+        const promptText = requirePromptText(text);
+        return this.startManagedSession(cwd, signal, promptText);
+    }
+    async startManagedSession(cwd, signal, promptText) {
+        signal.throwIfAborted();
+        await this.normalModelRuntimeForCwd(cwd);
+        const active = await this.create(this.sessionManager.create(cwd), cwd, { startupIntent: "create", creationProvenance: "host-one-shot", startupSignal: signal });
+        const { session } = active.runtime;
+        try {
+            signal.throwIfAborted();
+            if (promptText !== undefined)
+                this.maybeGenerateSessionName(session, promptText);
+            const created = this.announceCreatedSession(active, cwd);
+            // Publication transfers lifetime ownership to normal hosting. Plugin
+            // cancellation after this point must not abort this or later user work.
+            const completion = promptText === undefined ? Promise.resolve() : this.submitInitialRunPrompt(session, promptText);
+            return Object.freeze({ id: created.id, completion });
+        }
+        catch (error) {
+            try {
+                await this.closeActive(session.sessionId);
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], `托管会话 ${session.sessionId} 启动失败后清理失败`, { cause: cleanupError });
+            }
+            throw error;
+        }
+    }
+    announceCreatedSession(active, cwd, parentSession) {
         const { session } = active.runtime;
         const created = {
             id: session.sessionId,
@@ -902,13 +991,22 @@ export class PiSessionService {
             firstMessage: "",
             // Include the parent so listeners can nest the new session in the tree
             // immediately, instead of showing it flat until the next reload.
-            ...(options.parentSession === undefined ? {} : { parentSessionPath: options.parentSession }),
+            ...(parentSession === undefined ? {} : { parentSessionPath: parentSession }),
         };
-        // Broadcast so other clients (and the spawning agent's UI) can add the new
-        // session to their list without a manual reload.
         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, {
+            ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
+            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
+            ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
+            ...(options.startupToken === undefined ? {} : { startupToken: options.startupToken }),
+            startupIntent: "create",
+        });
+        return this.announceCreatedSession(active, cwd, options.parentSession);
+    }
     /**
      * Start a new session on behalf of a LLM and deliver an initial prompt to it.
      * The target cwd is constrained to a workspace of the same registered project
@@ -973,9 +1071,9 @@ export class PiSessionService {
             ...(parentSessionFile === undefined ? {} : { parentSessionFile }),
             cwd: decision.cwd,
         };
-        await this.registerVerifiedSubsession(link, eventScopeFromManagementContext(input.managementContext));
-        this.persistSubsessionLink(link);
-        this.persistSubsessionChildMarker(input.parentSessionId, created.id);
+        const scopedLink = await this.registerVerifiedSubsession(link, input.managementContext);
+        this.persistSubsessionLink(scopedLink);
+        this.persistSubsessionChildMarker(scopedLink);
         await this.prompt(created.id, input.prompt, undefined, undefined, {
             ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
         });
@@ -1051,6 +1149,23 @@ export class PiSessionService {
         this.modelScopeMutationQueue = queued.then(() => undefined, () => undefined);
         return queued;
     }
+    reloadModelScope(session) {
+        return this.runModelScopeMutation(async () => {
+            const context = this.modelScopeContext(session);
+            await this.modelScopeInitializations.get(context.key);
+            const enabledIds = await resolveEnabledModelIds({
+                settingsManager: session.settingsManager,
+                // Runtime-backed sessions hold the SDK ModelRuntime behind the narrow test seam.
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                modelRuntime: session.modelRuntime,
+                scopedModels: [],
+            });
+            const revision = ++this.modelScopeRevision;
+            this.modelScopeStates.set(context.key, { enabledIds, revision });
+            await this.synchronizeSessionModelScope(session, session.modelRuntime.getAvailableSnapshot());
+            this.events.publishGlobal({ type: "models.changed", revision }, this.eventScopeForSession(session));
+        });
+    }
     applyEnabledModelScope(session, available, enabledIds) {
         const context = this.modelScopeContext(session);
         const availableIds = available.map(modelScopeId);
@@ -1093,14 +1208,16 @@ export class PiSessionService {
      * 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) {
-        const result = this.pendingAskStore.open(input);
+    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);
-        this.events.publish(input.sessionId, { type: "ask.opened", ask: result.ask });
-        this.publishStatusForSessionId(input.sessionId);
+            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;
     }
     /**
@@ -1116,8 +1233,8 @@ export class PiSessionService {
         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, "answer questions");
-        return this.closeAsk(session, this.pendingAskStore.submit(session.sessionId, askId, submission));
+        this.assertTreeNavigationInactive(session, "回答问题");
+        return this.closeAsk(session, this.pendingAskStore.submit(this.dialogSessionKey(session), askId, submission));
     }
     /**
      * Close the open ask without answers. The model is still told, naming every
@@ -1127,8 +1244,8 @@ export class PiSessionService {
     async cancelAsk(ref, askId, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        this.assertTreeNavigationInactive(session, "dismiss questions");
-        return this.closeAsk(session, this.pendingAskStore.cancel(session.sessionId, askId));
+        this.assertTreeNavigationInactive(session, "关闭问题");
+        return this.closeAsk(session, this.pendingAskStore.cancel(this.dialogSessionKey(session), askId));
     }
     /**
      * Publish and deliver a closed ask. A stale close is reported rather than
@@ -1140,13 +1257,13 @@ export class PiSessionService {
         if (result.status === "stale")
             return { result: "stale", sessionStatus: this.statusFromSession(session) };
         const { outcome } = result;
-        this.publishAskClosed(session.sessionId, outcome);
-        await this.runSessionEntryMutation(session, "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.publishAskClosed(session.sessionId, outcome, this.eventScopeForSession(session));
+        await this.runSessionEntryMutation(session, "提交问题回答", () => 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) {
-        this.events.publish(sessionId, { type: "ask.closed", askId: outcome.askId, reason: outcome.reason });
+    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
@@ -1155,11 +1272,11 @@ export class PiSessionService {
      * itself triggers rather than becoming a turn of its own.
      */
     async voidOpenAskForUserMessage(session) {
-        const outcome = this.pendingAskStore.cancelOpen(session.sessionId);
+        const outcome = this.pendingAskStore.cancelOpen(this.dialogSessionKey(session));
         if (outcome === undefined)
             return;
-        this.publishAskClosed(session.sessionId, outcome);
-        await this.runSessionEntryMutation(session, "void the open questions", () => session.sendCustomMessage({ customType: ASK_USER_ANSWERS_CUSTOM_TYPE, content: renderAskUserAnswersText(outcome), display: true, details: outcome }, { triggerTurn: false, deliverAs: "followUp" }));
+        this.publishAskClosed(session.sessionId, outcome, this.eventScopeForSession(session));
+        await this.runSessionEntryMutation(session, "作废未回答问题", () => session.sendCustomMessage({ customType: ASK_USER_ANSWERS_CUSTOM_TYPE, content: renderAskUserAnswersText(outcome), display: true, details: outcome }, { triggerTurn: false, deliverAs: "followUp" }));
         this.publishStatus(session);
     }
     /**
@@ -1204,8 +1321,12 @@ export class PiSessionService {
      * `async` so a rejected dialog becomes a rejection rather than a synchronous
      * throw from a promise-returning method.
      */
-    async openExtensionDialog(session, request, opts) {
-        const signal = opts?.signal;
+    async openExtensionDialog(session, request, opts, startupSignal) {
+        const signal = opts?.signal === undefined
+            ? startupSignal
+            : startupSignal === undefined
+                ? opts.signal
+                : AbortSignal.any([opts.signal, startupSignal]);
         // A pre-aborted signal dismisses the dialog before it ever opens.
         if (signal?.aborted === true)
             return extensionDialogCancelValue(request.kind);
@@ -1287,18 +1408,19 @@ export class PiSessionService {
         }, this.eventScopeForSession(session));
     }
     /** Summaries of the tracked subsessions spawned by `parentSessionId`. */
-    async listSubsessions(parentSessionId, parentSessionFile) {
+    async listSubsessions(parentSessionId, parentSessionFile, managementContext) {
         const parentFile = nonEmptyString(parentSessionFile);
-        await this.hydrateSubsessionsForParent(parentSessionId, parentFile);
-        const childIds = this.subsessionChildren.get(parentSessionId);
+        const scope = eventScopeFromManagementContext(managementContext);
+        await this.hydrateSubsessionsForParent(parentSessionId, parentFile, managementContext);
+        const childIds = this.subsessionChildren.get(activeSessionKey(parentSessionId, scope));
         if (childIds === undefined)
             return [];
-        const authorizedChildIds = [...childIds].filter((childId) => this.subsessionLinkBelongsToParent(parentSessionId, parentFile, childId));
-        return Promise.all(authorizedChildIds.map(async (childId) => ({ sessionId: childId, ...(await this.subsessionSummaryFields(childId)) })));
+        const authorizedChildIds = [...childIds].filter((childId) => this.subsessionLinkBelongsToParent(parentSessionId, parentFile, childId, scope));
+        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) {
-        const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile);
+    async checkSubsession(parentSessionId, sessionId, parentSessionFile, managementContext) {
+        const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext);
         const messages = historyMessages(session);
         return {
             sessionId,
@@ -1309,8 +1431,8 @@ export class PiSessionService {
         };
     }
     /** Filtered, paginated transcript of a subsession, scoped to the caller's children. */
-    async readSubsession(parentSessionId, sessionId, query, parentSessionFile) {
-        const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile);
+    async readSubsession(parentSessionId, sessionId, query, parentSessionFile, managementContext) {
+        const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext);
         const view = buildTranscriptView(historyMessages(session), query);
         return {
             sessionId,
@@ -1320,52 +1442,61 @@ export class PiSessionService {
         };
     }
     /** Open a session after verifying it is one of the caller's tracked children. */
-    async openSubsession(parentSessionId, sessionId, parentSessionFile) {
+    async openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext) {
         const parentFile = nonEmptyString(parentSessionFile);
-        await this.hydrateSubsessionsForParent(parentSessionId, parentFile);
-        if (this.subsessionParents.get(sessionId) !== parentSessionId || !this.subsessionLinkBelongsToParent(parentSessionId, parentFile, sessionId)) {
+        const scope = eventScopeFromManagementContext(managementContext);
+        await this.hydrateSubsessionsForParent(parentSessionId, parentFile, managementContext);
+        if (this.subsessionParents.get(activeSessionKey(sessionId, scope)) !== parentSessionId || !this.subsessionLinkBelongsToParent(parentSessionId, parentFile, sessionId, scope)) {
             throw new Error(`Session ${sessionId} is not one of your subsessions`);
         }
-        return this.getOrOpenTrackedSubsession(sessionId);
+        return this.getOrOpenTrackedSubsession(sessionId, scope);
     }
-    subsessionLinkBelongsToParent(parentSessionId, parentSessionFile, childSessionId) {
-        const link = this.subsessionLinks.get(childSessionId);
+    subsessionLinkBelongsToParent(parentSessionId, parentSessionFile, childSessionId, scope) {
+        const link = this.subsessionLinks.get(activeSessionKey(childSessionId, scope));
         if (link?.parentSessionId !== parentSessionId)
             return false;
         return parentSessionFile === undefined || trackedLinkParentFileMatches(link, parentSessionFile);
     }
     activeChildForSubsessionLink(link) {
-        return this.activeSessionsForId(link.childSessionId).find((active) => activeSessionFileMatches(active, link.childSessionFile));
+        const active = this.activeForSessionIdAndScope(link.childSessionId, link.eventScope);
+        return active !== undefined && activeSessionFileMatches(active, link.childSessionFile) ? active : undefined;
     }
     activeParentForSubsessionLink(link) {
-        return this.activeSessionsForId(link.parentSessionId).find((active) => activeSessionFileMatches(active, link.parentSessionFile));
+        const active = this.activeForSessionIdAndScope(link.parentSessionId, link.eventScope);
+        return active !== undefined && activeSessionFileMatches(active, link.parentSessionFile) ? active : undefined;
     }
     subsessionLinkForActiveChild(session) {
-        const childId = session.sessionId;
-        const parentId = this.subsessionParents.get(childId);
-        const link = this.subsessionLinks.get(childId);
+        const childKey = activeSessionKey(session.sessionId, this.eventScopeForSession(session));
+        const parentId = this.subsessionParents.get(childKey);
+        const link = this.subsessionLinks.get(childKey);
         if (parentId === undefined || link?.parentSessionId !== parentId)
             return undefined;
         return sessionFileMatches(session, link.childSessionFile) ? link : undefined;
     }
-    async registerVerifiedSubsession(link, scope = NORMAL_SESSION_EVENT_SCOPE) {
+    async registerVerifiedSubsession(link, managementContext) {
         const { childSessionId, parentSessionId } = link;
-        const previousParentId = this.subsessionParents.get(childSessionId);
+        const scope = eventScopeFromManagementContext(managementContext);
+        const childKey = activeSessionKey(childSessionId, scope);
+        const parentKey = activeSessionKey(parentSessionId, scope);
+        const scopedLink = { ...link, eventScope: scope, ...(managementContext === undefined ? {} : { managementContext }) };
+        const previousParentId = this.subsessionParents.get(childKey);
         if (previousParentId !== undefined && previousParentId !== parentSessionId) {
-            const previousChildren = this.subsessionChildren.get(previousParentId);
+            const previousParentKey = activeSessionKey(previousParentId, scope);
+            const previousChildren = this.subsessionChildren.get(previousParentKey);
             previousChildren?.delete(childSessionId);
             if (previousChildren?.size === 0)
-                this.subsessionChildren.delete(previousParentId);
+                this.subsessionChildren.delete(previousParentKey);
         }
-        this.subsessionParents.set(childSessionId, parentSessionId);
-        const children = this.subsessionChildren.get(parentSessionId) ?? new Set();
+        this.subsessionParents.set(childKey, parentSessionId);
+        const children = this.subsessionChildren.get(parentKey) ?? new Set();
         children.add(childSessionId);
-        this.subsessionChildren.set(parentSessionId, children);
-        this.subsessionLinks.set(childSessionId, link);
-        if (!this.subsessionNotifyArmed.has(childSessionId))
-            this.subsessionNotifyArmed.set(childSessionId, false);
-        const cwd = this.cwdForVerifiedSubsession(link);
+        this.subsessionChildren.set(parentKey, children);
+        this.subsessionLinks.set(childKey, scopedLink);
+        if (!this.subsessionNotifyArmed.has(childKey))
+            this.subsessionNotifyArmed.set(childKey, false);
+        const cwd = this.cwdForVerifiedSubsession(scopedLink);
         await this.publishUnreadMutations(this.unreadForScope(scope).excludeSession(childSessionId, cwd));
+        return scopedLink;
     }
     cwdForVerifiedSubsession(link) {
         const activeCwd = this.activeChildForSubsessionLink(link)?.runtime.session.sessionManager.getCwd();
@@ -1383,17 +1514,19 @@ export class PiSessionService {
         }
         throw new Error("Could not resolve cwd for verified tracked sub-session");
     }
-    unregisterSubsession(childSessionId) {
-        const parentSessionId = this.subsessionParents.get(childSessionId);
-        this.subsessionParents.delete(childSessionId);
-        this.subsessionLinks.delete(childSessionId);
-        this.subsessionNotifyArmed.delete(childSessionId);
+    unregisterSubsession(childSessionId, scope) {
+        const childKey = activeSessionKey(childSessionId, scope);
+        const parentSessionId = this.subsessionParents.get(childKey);
+        this.subsessionParents.delete(childKey);
+        this.subsessionLinks.delete(childKey);
+        this.subsessionNotifyArmed.delete(childKey);
         if (parentSessionId === undefined)
             return;
-        const children = this.subsessionChildren.get(parentSessionId);
+        const parentKey = activeSessionKey(parentSessionId, scope);
+        const children = this.subsessionChildren.get(parentKey);
         children?.delete(childSessionId);
         if (children?.size === 0)
-            this.subsessionChildren.delete(parentSessionId);
+            this.subsessionChildren.delete(parentKey);
     }
     persistSubsessionLink(link) {
         const parent = this.activeParentForSubsessionLink(link)?.runtime.session;
@@ -1408,8 +1541,9 @@ export class PiSessionService {
             this.logger.info({ parentSessionId: link.parentSessionId, sessionId: link.childSessionId, error: error instanceof Error ? error.message : String(error) }, "failed to persist subsession link");
         }
     }
-    persistSubsessionChildMarker(parentSessionId, childSessionId) {
-        const child = this.activeForSessionId(childSessionId)?.runtime.session;
+    persistSubsessionChildMarker(link) {
+        const { parentSessionId, childSessionId } = link;
+        const child = this.activeChildForSubsessionLink(link)?.runtime.session;
         if (child === undefined)
             return;
         if (child.sessionManager.appendCustomEntry === undefined)
@@ -1421,14 +1555,15 @@ export class PiSessionService {
             this.logger.info({ parentSessionId, sessionId: childSessionId, error: error instanceof Error ? error.message : String(error) }, "failed to persist subsession child marker");
         }
     }
-    async hydrateSubsessionsForParent(parentSessionId, parentSessionFile) {
-        const hydrationKey = subsessionHydratedParentKey(parentSessionId, parentSessionFile);
+    async hydrateSubsessionsForParent(parentSessionId, parentSessionFile, managementContext) {
+        const scope = eventScopeFromManagementContext(managementContext);
+        const hydrationKey = subsessionHydratedParentKey(activeSessionKey(parentSessionId, scope), parentSessionFile);
         if (this.subsessionHydratedParents.has(hydrationKey))
             return;
-        const activeParent = this.activeForSessionId(parentSessionId);
+        const activeParent = this.activeForSessionIdAndScope(parentSessionId, scope);
         if (activeParent !== undefined && (parentSessionFile === undefined || activeSessionFileMatches(activeParent, parentSessionFile))) {
             const activeParentFile = nonEmptyString(activeParent.runtime.session.sessionFile);
-            const complete = await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile, activeParent.eventScope);
+            const complete = await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile, managementContext);
             if (complete)
                 this.subsessionHydratedParents.add(hydrationKey);
             return;
@@ -1444,11 +1579,11 @@ export class PiSessionService {
         catch {
             return;
         }
-        const complete = await this.registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile);
+        const complete = await this.registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile, managementContext);
         if (complete)
             this.subsessionHydratedParents.add(hydrationKey);
     }
-    async registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile, scope = NORMAL_SESSION_EVENT_SCOPE) {
+    async registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile, managementContext) {
         // Parent custom links are the authoritative recovery record: verify the
         // exact live child file/header before tracking. Do not negatively cache a
         // scan while a candidate child is temporarily unavailable.
@@ -1463,7 +1598,7 @@ export class PiSessionService {
                 complete = false;
                 continue;
             }
-            await this.registerVerifiedSubsession(verified, scope);
+            await this.registerVerifiedSubsession(verified, managementContext);
         }
         return complete;
     }
@@ -1484,7 +1619,7 @@ export class PiSessionService {
         const link = await this.verifiedSubsessionLinkFromOpenedChild(session);
         if (link === undefined)
             return;
-        await this.registerVerifiedSubsession(link, this.eventScopeForSession(session));
+        await this.registerVerifiedSubsession(link, this.sessionManagementContexts.get(session));
     }
     verifiedSubsessionLinkFromOpenedChild(session) {
         return verifiedTrackedSubsessionLink(this.sessionManager, {
@@ -1494,8 +1629,8 @@ export class PiSessionService {
             cwd: session.sessionManager.getCwd(),
         });
     }
-    async getOrOpenTrackedSubsession(sessionId) {
-        const link = this.subsessionLinks.get(sessionId);
+    async getOrOpenTrackedSubsession(sessionId, scope) {
+        const link = this.subsessionLinks.get(activeSessionKey(sessionId, scope));
         if (link === undefined)
             throw new Error("Session not found");
         const active = this.activeChildForSubsessionLink(link);
@@ -1505,12 +1640,14 @@ export class PiSessionService {
             if (!(await sessionFileHeaderMatches(link.childSessionFile, { sessionId, parentSessionFile: link.parentSessionFile })))
                 throw new Error("Session not found");
             const sessionManager = this.sessionManager.open(link.childSessionFile);
-            return (await this.create(sessionManager, link.cwd ?? sessionManager.getCwd())).runtime.session;
+            return (await this.create(sessionManager, link.cwd ?? sessionManager.getCwd(), {
+                ...(link.managementContext === undefined ? {} : { managementContext: link.managementContext }),
+            })).runtime.session;
         }
         throw new Error("Session not found");
     }
-    async subsessionSummaryFields(childSessionId) {
-        const link = this.subsessionLinks.get(childSessionId);
+    async subsessionSummaryFields(childSessionId, scope) {
+        const link = this.subsessionLinks.get(activeSessionKey(childSessionId, scope));
         const active = link === undefined ? undefined : this.activeChildForSubsessionLink(link);
         if (active !== undefined) {
             return { cwd: active.runtime.cwd, status: this.subsessionStatus(active.runtime.session) };
@@ -1529,12 +1666,12 @@ export class PiSessionService {
             return "error";
         return "idle";
     }
-    workingSubsessionIds(parentSessionId) {
-        const childIds = this.subsessionChildren.get(parentSessionId);
+    workingSubsessionIds(parentSessionId, scope) {
+        const childIds = this.subsessionChildren.get(activeSessionKey(parentSessionId, scope));
         if (childIds === undefined)
             return [];
         return [...childIds].filter((childId) => {
-            const link = this.subsessionLinks.get(childId);
+            const link = this.subsessionLinks.get(activeSessionKey(childId, scope));
             const active = link === undefined ? undefined : this.activeChildForSubsessionLink(link);
             return active !== undefined && this.hasActiveWork(active.runtime.session);
         });
@@ -1550,27 +1687,26 @@ export class PiSessionService {
         if (link === undefined)
             return;
         const childId = link.childSessionId;
+        const childKey = activeSessionKey(childId, link.eventScope);
         if (this.hasActiveWork(session)) {
-            this.subsessionNotifyArmed.set(childId, true);
+            this.subsessionNotifyArmed.set(childKey, true);
             return;
         }
-        if (this.subsessionNotifyArmed.get(childId) !== true)
+        if (this.subsessionNotifyArmed.get(childKey) !== true)
             return;
-        this.subsessionNotifyArmed.set(childId, false);
+        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);
+        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.parentSessionId, childId, text);
+        void this.notifyParentOfSubsession(link, text);
     }
-    async getOrOpenParentForSubsession(parentSessionId, childSessionId) {
-        const link = this.subsessionLinks.get(childSessionId);
-        if (link?.parentSessionId !== parentSessionId)
-            throw new Error(`Parent session ${parentSessionId} is not available for subsession notification`);
+    async getOrOpenParentForSubsession(link) {
+        const { parentSessionId } = link;
         const active = this.activeParentForSubsessionLink(link);
         if (active !== undefined)
             return active.runtime.session;
@@ -1581,7 +1717,9 @@ export class PiSessionService {
             throw new Error(`Parent session ${parentSessionId} is not available for subsession notification`);
         }
         const sessionManager = this.sessionManager.open(parentSessionFile);
-        return (await this.create(sessionManager, sessionManager.getCwd())).runtime.session;
+        return (await this.create(sessionManager, sessionManager.getCwd(), {
+            ...(link.managementContext === undefined ? {} : { managementContext: link.managementContext }),
+        })).runtime.session;
     }
     /**
      * Deliver a subsession-completion notice to the parent as a system-authored
@@ -1590,9 +1728,10 @@ export class PiSessionService {
      * queues behind in-flight work (`deliverAs: "followUp"`), preserving the
      * established "queue if busy, send and act if idle" behavior.
      */
-    async notifyParentOfSubsession(parentId, childId, text) {
+    async notifyParentOfSubsession(link, text) {
+        const { parentSessionId: parentId, childSessionId: childId } = link;
         try {
-            const session = await this.getOrOpenParentForSubsession(parentId, childId);
+            const session = await this.getOrOpenParentForSubsession(link);
             if (this.treeNavigations.has(session)) {
                 const pending = this.deferredSubsessionNotifications.get(session) ?? [];
                 pending.push({ parentId, childId, text });
@@ -1611,6 +1750,9 @@ export class PiSessionService {
     }
     async status(ref, managementContext) {
         const session = await this.sessionForStatusOrDialogClose(ref, managementContext);
+        if (this.eventScopeForSession(session) === NORMAL_SESSION_EVENT_SCOPE) {
+            await this.activityMarker.refresh(session.sessionFile, this.hasActiveWork(session));
+        }
         if (this.hasActiveWork(session))
             return this.statusFromSession(session);
         const branch = await this.readableSessionBranch(session);
@@ -1645,6 +1787,60 @@ export class PiSessionService {
             : annotateAssistantThinkingLevel(projectBrowserMessage(streamingMessage), session.thinkingLevel);
         return { seq, partial };
     }
+    async getSessionDefaults(ref, managementContext) {
+        const session = await this.getOrOpen(ref, managementContext);
+        const settings = await this.freshSessionDefaultsSettings(session);
+        return parseSessionDefaults(settings.getGlobalSettings());
+    }
+    async setSessionDefaults(ref, defaults, managementContext) {
+        const update = parseSessionDefaultsUpdate({ ...defaults });
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref, managementContext);
+        return this.runModelScopeMutation(async () => {
+            const settings = await this.freshSessionDefaultsSettings(session);
+            if (update.provider !== undefined && update.modelId !== undefined) {
+                await session.modelRuntime.refresh({ allowNetwork: false });
+                const target = `${update.provider}/${update.modelId}`;
+                const available = session.modelRuntime.getAvailableSnapshot();
+                if (!available.some((model) => modelScopeId(model) === target))
+                    throw new Error(`未找到模型：${target}`);
+                const enabledIds = await resolveEnabledModelIds({
+                    settingsManager: settings,
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    modelRuntime: session.modelRuntime,
+                    scopedModels: [],
+                });
+                if (enabledIds !== null && !enabledIds.includes(target))
+                    throw new Error(`模型未启用：${target}`);
+                settings.setDefaultModelAndProvider(update.provider, update.modelId);
+            }
+            else if (update.thinkingLevel !== undefined) {
+                settings.setDefaultThinkingLevel(update.thinkingLevel);
+            }
+            await settings.flush();
+            this.assertDefaultsSettingsHealthy(settings);
+            return parseSessionDefaults(settings.getGlobalSettings());
+        });
+    }
+    async freshSessionDefaultsSettings(session) {
+        const cwd = session.sessionManager.getCwd();
+        const mode = this.eventScopeForSession(session) === NORMAL_SESSION_EVENT_SCOPE ? "normal" : "management";
+        const settings = await createScopedSettingsManager({
+            cwd,
+            scopeDirectory: await this.resolveSettingsScopeDirectory(cwd, mode),
+            globalAgentDir: this.agentDir,
+            mode,
+            projectTrusted: session.settingsManager.isProjectTrusted?.() ?? true,
+        });
+        await settings.reload();
+        this.assertDefaultsSettingsHealthy(settings);
+        return settings;
+    }
+    assertDefaultsSettingsHealthy(settings) {
+        const errors = settings.drainErrors();
+        if (errors.length > 0)
+            throw new Error(`会话默认值设置失败：${errors.map(({ error }) => error.message).join("; ")}`);
+    }
     async availableModels(ref, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
         const models = await this.sessionModelCandidates(session);
@@ -1664,7 +1860,7 @@ export class PiSessionService {
             const scope = this.modelScopeContext(session);
             if (!scope.editable)
                 throw new Error("模型可用范围由此工作区的 .pi/settings.json 控制");
-            this.assertTreeNavigationInactive(session, "change enabled models");
+            this.assertTreeNavigationInactive(session, "修改已启用模型");
             await session.modelRuntime.refresh({ allowNetwork: false });
             const currentIds = (await this.modelScopeSnapshot(session, scope)).enabledIds;
             const available = session.modelRuntime.getAvailableSnapshot();
@@ -1675,7 +1871,7 @@ export class PiSessionService {
             if (!enabled && session.model !== undefined && modelScopeId(session.model) === targetId)
                 throw new Error("不能停用当前模型");
             const nextIds = applyEnabledModelToggle(currentIds, availableIds, targetId, enabled);
-            this.assertTreeNavigationInactive(session, "change enabled models");
+            this.assertTreeNavigationInactive(session, "修改已启用模型");
             if (nextIds !== currentIds)
                 this.applyEnabledModelScope(session, available, nextIds);
             return (await this.enabledModelCatalog(session)).map((entry) => catalogEntryToClientModel(entry));
@@ -1690,7 +1886,7 @@ export class PiSessionService {
             const scope = this.modelScopeContext(session);
             if (!scope.editable)
                 throw new Error("模型可用范围由此工作区的 .pi/settings.json 控制");
-            this.assertTreeNavigationInactive(session, "change enabled models");
+            this.assertTreeNavigationInactive(session, "修改已启用模型");
             await session.modelRuntime.refresh({ allowNetwork: false });
             const available = session.modelRuntime.getAvailableSnapshot();
             const availableIds = available.map(modelScopeId);
@@ -1701,7 +1897,7 @@ export class PiSessionService {
                     throw new Error("当前模型不可用");
                 nextIds = [modelScopeId(current)];
             }
-            this.assertTreeNavigationInactive(session, "change enabled models");
+            this.assertTreeNavigationInactive(session, "修改已启用模型");
             this.applyEnabledModelScope(session, available, nextIds);
             return (await this.enabledModelCatalog(session)).map((entry) => catalogEntryToClientModel(entry));
         });
@@ -1709,14 +1905,14 @@ export class PiSessionService {
     async setModel(ref, provider, modelId, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        this.assertTreeNavigationInactive(session, "change models");
+        this.assertTreeNavigationInactive(session, "更改模型");
         const candidates = await this.sessionModelCandidates(session);
-        this.assertTreeNavigationInactive(session, "change models");
+        this.assertTreeNavigationInactive(session, "更改模型");
         const model = candidates.find((candidate) => candidate.provider === provider && candidate.id === modelId)
             ?? session.modelRuntime.getModel(provider, modelId);
         if (model === undefined)
             throw new Error(`未找到模型：${provider}/${modelId}`);
-        await this.runSessionEntryMutation(session, "change models", () => session.setModel(model));
+        await this.runSessionEntryMutation(session, "更改模型", () => session.setModel(model));
         this.publishActivity(session, `模型：${model.id}`, "idle", model.provider);
         this.publishStatus(session);
         return this.statusFromSession(session);
@@ -1727,7 +1923,7 @@ export class PiSessionService {
         const result = await this.runModelScopeMutation(async () => {
             await session.modelRuntime.refresh({ allowNetwork: false });
             await this.synchronizeSessionModelScope(session, session.modelRuntime.getAvailableSnapshot());
-            return this.runSessionEntryMutation(session, "change models", () => session.cycleModel(direction));
+            return this.runSessionEntryMutation(session, "更改模型", () => session.cycleModel(direction));
         });
         if (result === undefined)
             throw new Error(session.scopedModels.length > 0 ? "作用域内只有一个模型" : "只有一个可用模型");
@@ -1742,14 +1938,14 @@ export class PiSessionService {
     async setThinkingLevel(ref, level, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        this.assertTreeNavigationInactive(session, "change the thinking level");
+        this.assertTreeNavigationInactive(session, "更改思考级别");
         // pi owns the valid set; validate against the session's live levels rather
         // than a hardcoded union so this stays correct if pi changes the set.
         const available = session.getAvailableThinkingLevels();
         const match = available.find((candidate) => candidate === level);
         if (match === undefined)
             throw new Error(`无效的思考级别：${level}`);
-        await this.runSessionEntryMutation(session, "change the thinking level", () => {
+        await this.runSessionEntryMutation(session, "更改思考级别", () => {
             session.setThinkingLevel(match);
             return Promise.resolve();
         });
@@ -1760,7 +1956,7 @@ export class PiSessionService {
     async cycleThinkingLevel(ref, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        const level = await this.runSessionEntryMutation(session, "change the thinking level", () => Promise.resolve(session.cycleThinkingLevel()));
+        const level = await this.runSessionEntryMutation(session, "更改思考级别", () => Promise.resolve(session.cycleThinkingLevel()));
         if (level === undefined)
             throw new Error("当前模型不支持思考");
         this.publishActivity(session, `思考级别：${level}`, "idle");
@@ -1774,7 +1970,12 @@ export class PiSessionService {
             commands.push({ name: command.invocationName, ...(command.description === undefined ? {} : { description: command.description }), source: "extension" });
         }
         for (const template of session.promptTemplates) {
-            commands.push({ name: template.name, ...(template.description === undefined ? {} : { description: template.description }), source: "prompt" });
+            commands.push({
+                name: template.name,
+                ...(template.description === undefined ? {} : { description: template.description }),
+                ...(template.argumentHint === undefined ? {} : { argumentHint: template.argumentHint }),
+                source: "prompt",
+            });
         }
         for (const skill of session.resourceLoader.getSkills().skills) {
             commands.push({ name: `skill:${skill.name}`, ...(skill.description === undefined ? {} : { description: skill.description }), source: "skill" });
@@ -1793,7 +1994,7 @@ export class PiSessionService {
         const images = (await attachmentsToInlineImages(parsedAttachments)).map((entry) => entry.image);
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, options?.managementContext);
-        this.assertTreeNavigationInactive(session, "send a prompt");
+        this.assertTreeNavigationInactive(session, "发送消息");
         this.maybeGenerateSessionName(session, promptText);
         const isQueued = session.isStreaming || session.isCompacting;
         const behavior = isQueued ? requestedBehavior ?? "followUp" : undefined;
@@ -1814,24 +2015,78 @@ export class PiSessionService {
         void this.submitPrompt(session, promptText, behavior, images, echoUserMessage);
     }
     submitPrompt(session, text, behavior, images = [], echoUserMessage = true) {
+        const promptPromise = this.beginPromptSubmission(session, text, behavior, images, echoUserMessage).catch(() => undefined);
+        void promptPromise;
+        return promptPromise;
+    }
+    beginPromptSubmission(session, text, behavior, images = [], echoUserMessage = true) {
         this.auditUserPrompt(session, text);
         this.publishActivity(session, behavior === "steer" ? "插队消息已排队" : behavior === "followUp" ? "消息已排队" : "消息已接收", "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, "send a prompt", () => session.prompt(text, promptOptions)).catch((error) => {
+        const promptPromise = this.runSessionEntryMutation(session, "发送消息", () => session.prompt(text, promptOptions));
+        void promptPromise.catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             this.publishActivity(session, "发生错误", "error", message);
             this.events.publish(session.sessionId, { type: "session.error", message }, eventScope);
         });
-        void promptPromise;
         return promptPromise;
     }
+    async submitInitialRunPrompt(session, text) {
+        let failure;
+        let settled = false;
+        let sawInitialUserMessage = false;
+        const unsubscribe = session.subscribe((event) => {
+            if (settled || !isRecord(event))
+                return;
+            if (event["type"] === "agent_settled") {
+                // Freeze the initial outcome before a later user submission can change it.
+                settled = true;
+                return;
+            }
+            if (event["type"] === "auto_retry_end" && event["success"] === false && event["finalError"] === "Retry cancelled") {
+                // Native Pi cancels retry sleep without an aborted assistant message.
+                failure = new DOMException("初始 PI 会话运行已中止", "AbortError");
+                return;
+            }
+            const message = event["message"];
+            if (!isRecord(message))
+                return;
+            if (event["type"] === "message_start" && message["role"] === "user") {
+                // Pi can drain a queued user follow-up inside the same prompt promise.
+                // Its outcome belongs to that later submission, not this launcher.
+                if (sawInitialUserMessage)
+                    settled = true;
+                sawInitialUserMessage = true;
+                return;
+            }
+            if (event["type"] !== "message_end" || message["role"] !== "assistant")
+                return;
+            // A successful retry supersedes a transient provider failure. Pi's
+            // prompt promise can fulfill even when the final assistant is an error.
+            const reason = message["stopReason"];
+            failure = reason === "aborted"
+                ? new DOMException("初始 PI 会话运行已中止", "AbortError")
+                : reason === "error"
+                    ? new Error(typeof message["errorMessage"] === "string" ? message["errorMessage"] : "初始 PI 会话运行失败")
+                    : undefined;
+        });
+        try {
+            await this.beginPromptSubmission(session, text, undefined);
+            if (failure !== undefined)
+                throw failure;
+        }
+        finally {
+            unsubscribe();
+        }
+    }
     enqueuePromptDuringCompaction(session, text, kind, images = [], echoUserMessage = true) {
-        const queue = this.compactionPromptQueues.get(session.sessionId) ?? [];
+        const sessionKey = activeSessionKey(session.sessionId, this.eventScopeForSession(session));
+        const queue = this.compactionPromptQueues.get(sessionKey) ?? [];
         queue.push({ kind, text, ...(images.length > 0 ? { images } : {}), ...(echoUserMessage ? {} : { echoUserMessage: false }) });
-        this.compactionPromptQueues.set(session.sessionId, queue);
+        this.compactionPromptQueues.set(sessionKey, queue);
         this.publishActivity(session, "压缩期间消息已排队", "active");
         this.publishStatus(session);
     }
@@ -1853,7 +2108,7 @@ export class PiSessionService {
         await this.assertWritable(ref);
         const active = await this.getActive(ref, managementContext);
         const { session } = active.runtime;
-        this.assertTreeNavigationInactive(session, "run a shell command");
+        this.assertTreeNavigationInactive(session, "运行 Shell 命令");
         const isExcluded = text.startsWith("!!");
         const command = (isExcluded ? text.slice(2) : text.slice(1)).trim();
         if (!command)
@@ -1863,7 +2118,7 @@ export class PiSessionService {
         const eventScope = active.eventScope;
         this.publishActivity(session, "正在运行命令", "active", command);
         this.events.publish(session.sessionId, { type: "shell.start", command, excludeFromContext: isExcluded }, eventScope);
-        void this.runSessionEntryMutation(session, "run a shell command", () => session.executeBash(command, (chunk) => {
+        void this.runSessionEntryMutation(session, "运行 Shell 命令", () => session.executeBash(command, (chunk) => {
             this.events.publish(session.sessionId, { type: "shell.chunk", chunk }, eventScope);
             this.publishActivity(session, "正在运行命令", "active", command);
             this.publishStatus(session);
@@ -1898,42 +2153,74 @@ export class PiSessionService {
     }
     async navigateTree(ref, request, managementContext) {
         if (request.targetId.trim() === "")
-            throw new Error("Session tree target is required");
+            throw new Error("会话树目标条目不能为空");
         if (this.isTreeExclusiveSessionIdentityActive(sessionIdFromLookup(ref))) {
-            throw new Error("Stop current session activity before navigating the session tree");
+            throw new Error("切换会话树前请先停止当前会话活动");
         }
         await this.assertWritable(ref);
         const options = sessionTreeNavigationOptions(request);
         const session = await this.getOrOpen(ref, managementContext);
         if (typeof session.navigateTree !== "function")
-            throw new Error("Session tree navigation is not supported by this Pi runtime");
+            throw new Error("当前 Pi 运行时不支持会话树导航");
         if (this.hasActiveWork(session))
-            throw new Error("Stop current session activity before navigating the session tree");
+            throw new Error("切换会话树前请先停止当前会话活动");
         // Acquire synchronously after the active-work check. No leaf-producing work
         // may enter this runtime until Pi's potentially asynchronous summary settles.
         this.treeNavigations.add(session);
         try {
-            if (session.sessionManager.getLeafId() !== request.expectedLeafId) {
-                throw new Error("The session changed since /tree was opened. Reopen /tree and try again.");
+            const oldLeafId = session.sessionManager.getLeafId();
+            if (oldLeafId !== request.expectedLeafId) {
+                throw new Error("打开 /tree 后会话已发生变化。请重新打开 /tree 后重试。");
             }
+            const activeEditableTargetParentId = activeEditableTreeTargetParentId(session.sessionManager, request.targetId, oldLeafId);
             this.publishActivity(session, options.summarize ? "正在汇总分支" : "正在切换会话树", "active");
             this.publishStatus(session);
-            const result = await session.navigateTree(request.targetId, options);
+            let result = await session.navigateTree(request.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);
+                }
+                catch (error) {
+                    session.sessionManager.branch(request.targetId);
+                    throw error;
+                }
+                if (result.cancelled)
+                    session.sessionManager.branch(request.targetId);
+            }
             if (result.cancelled) {
                 if (this.isCurrentActiveSession(session)) {
                     this.publishActivity(session, result.aborted === true ? "分支汇总已终止" : "会话树切换已取消", "idle");
                 }
                 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);
+            }
+            else {
+                const selectedLeafId = session.sessionManager.getLeafId();
+                if (selectedLeafId !== oldLeafId)
+                    this.unpersistedTreeBranchLeaves.set(session, selectedLeafId);
+            }
             if (this.isCurrentActiveSession(session))
                 this.publishActivity(session, "已切换会话树", "idle");
             return { cancelled: false, ...(result.editorText === undefined ? {} : { editorText: result.editorText }) };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            this.publishActivity(session, "重新加载失败", "error", message);
-            this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
-            this.publishStatus(session);
+            if (this.isCurrentActiveSession(session)) {
+                this.publishActivity(session, "会话树切换失败", "error", message);
+                this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
+            }
             throw error;
         }
         finally {
@@ -1950,19 +2237,22 @@ export class PiSessionService {
     }
     async forkFromTree(ref, request, managementContext) {
         if (request.entryId.trim() === "")
-            throw new Error("Session tree entry is required");
+            throw new Error("会话树条目不能为空");
         const requestedSessionId = sessionIdFromLookup(ref);
         if (this.isTreeExclusiveSessionIdentityActive(requestedSessionId)) {
-            throw new Error("Stop current session activity before forking the session tree");
+            throw new Error("分叉会话树前请先停止当前会话活动");
         }
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
         if (this.hasActiveWork(session))
-            throw new Error("Stop current session activity before forking the session tree");
+            throw new Error("分叉会话树前请先停止当前会话活动");
+        if (session.sessionManager.getLeafId() !== request.expectedLeafId) {
+            throw new Error("打开 /tree 后会话已发生变化。请重新打开 /tree 后重试。");
+        }
         const sourceSessionId = session.sessionId;
         const sourceEventScope = this.eventScopeForSession(session);
         const sourceCwd = session.sessionManager.getCwd();
-        this.publishActivity(session, "正在从会话树条目分叉", "active");
+        this.publishActivity(session, "正在从条目分叉会话", "active");
         this.publishStatus(session);
         try {
             const result = await this.commandService.forkEntry(session.sessionId, request.entryId, sourceEventScope, {
@@ -1971,10 +2261,10 @@ export class PiSessionService {
             if (result.type === "unsupported")
                 throw new Error(result.message);
             if (result.type !== "done")
-                throw new Error("Session fork is unavailable");
+                throw new Error("会话分叉不可用");
             if (result.session === undefined) {
                 if (this.isCurrentActiveSession(session)) {
-                    this.publishActivity(session, "会话分叉已取消", "idle");
+                    this.publishActivity(session, "分叉已取消", "idle");
                     this.publishStatus(session);
                 }
                 return { cancelled: true };
@@ -1995,7 +2285,7 @@ export class PiSessionService {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             if (this.isCurrentActiveSession(session)) {
-                this.publishActivity(session, "会话分叉失败", "error", message);
+                this.publishActivity(session, "分叉失败", "error", message);
                 this.events.publish(session.sessionId, { type: "session.error", message }, sourceEventScope);
                 this.publishStatus(session);
             }
@@ -2154,8 +2444,6 @@ export class PiSessionService {
         if (this.archiveStore.deleteArchived === undefined)
             throw new Error("归档存储不支持删除");
         await this.closeActiveInScope(record.sessionId, eventScopeFromManagementContext(managementContext));
-        if (record.archivePath === undefined)
-            await this.ensureArchivedRecordMoved(record);
         await this.archiveStore.deleteArchived(record.sessionId);
         await this.forgetUnreadSessions([record], eventScopeFromManagementContext(managementContext));
     }
@@ -2189,12 +2477,7 @@ export class PiSessionService {
                 failures.push({ sessionId: item.record.sessionId, error: errorMessage(error) });
             }
         }
-        const moveFailures = await this.moveLegacyArchivedRecordsForDelete(readyRecords);
-        failures.push(...moveFailures);
-        const moveFailureIds = new Set(moveFailures.map((failure) => failure.sessionId));
-        const deleteIds = readyRecords
-            .map((record) => record.sessionId)
-            .filter((sessionId) => !moveFailureIds.has(sessionId));
+        const deleteIds = readyRecords.map((record) => record.sessionId);
         let deletedSessionIds = [];
         try {
             deletedSessionIds = await this.archiveStoreDeleteArchivedMany(deleteIds);
@@ -2234,6 +2517,7 @@ export class PiSessionService {
                     ...(managementContext === undefined ? {} : { managementContext }),
                     ...(candidateGeneration === undefined ? {} : { notificationGeneration: candidateGeneration }),
                 });
+                await this.reloadModelScope(reopened.runtime.session);
                 if (candidateGeneration !== undefined) {
                     this.publishNotificationMutations(this.notificationsForSession(session).commitReplacement(candidateGeneration));
                 }
@@ -2249,22 +2533,22 @@ export class PiSessionService {
         this.publishStatus(reopenedSession);
     }
     async detachParent(ref, managementContext) {
+        await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
         const sessionFile = session.sessionFile;
         if (sessionFile === undefined || sessionFile === "")
             throw new Error("会话尚未持久化");
         clearSessionFileParent(sessionFile);
-        this.sessionManager.invalidateSessionFile?.(sessionFile);
+        this.sessionManager.invalidateSessionFile(sessionFile);
         clearParentSessionHeader(session.sessionManager);
-        this.unregisterSubsession(session.sessionId);
+        this.unregisterSubsession(session.sessionId, this.eventScopeForSession(session));
         await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }], this.eventScopeForSession(session));
     }
     async abort(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
         if (active === undefined)
             return;
-        const sessionId = active.runtime.session.sessionId;
-        this.clearCompactionPromptQueue(sessionId);
+        this.clearCompactionPromptQueue(active.runtime.session);
         clearSessionQueue(active.runtime.session);
         this.abortRunScopedExtensionDialogs(active.runtime.session);
         try {
@@ -2283,25 +2567,15 @@ export class PiSessionService {
     async clearQueue(ref, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        this.clearCompactionPromptQueue(session.sessionId);
+        this.clearCompactionPromptQueue(session);
         clearSessionQueue(session);
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
     async stop(ref, managementContext) {
-        let active = this.activeForLookup(ref, managementContext);
-        if (active === undefined) {
-            const startup = this.startupSessionForLookup(ref, managementContext);
-            if (startup !== undefined) {
-                this.endSessionExtensionDialogs(startup);
-                const pendingOpens = this.pendingSessionOpenPromises(startup.sessionId);
-                if (pendingOpens.length > 0)
-                    await Promise.allSettled(pendingOpens);
-                active = this.activeForLookup(ref, managementContext);
-            }
-        }
-        if (active !== undefined) {
-            await this.closeActiveSession(active);
+        const session = this.activeForLookup(ref, managementContext)?.runtime.session ?? this.startupSessionForLookup(ref, managementContext);
+        if (session !== undefined) {
+            await this.closeActive(session.sessionId, CLEAR_RUNTIME_NOTIFICATIONS, eventScopeFromManagementContext(managementContext));
             return;
         }
         if (isPiSessionRef(ref)) {
@@ -2319,10 +2593,11 @@ export class PiSessionService {
     async archiveStoreArchiveMany(inputs) {
         if (inputs.length === 0)
             return [];
+        const oldestFirst = [...inputs].sort((a, b) => Date.parse(a.modified) - Date.parse(b.modified));
         if (this.archiveStore.archiveMany !== undefined)
-            return this.archiveStore.archiveMany(inputs);
+            return this.archiveStore.archiveMany(oldestFirst);
         const records = [];
-        for (const input of inputs)
+        for (const input of oldestFirst)
             records.push(await this.archiveStore.archive(input));
         return records;
     }
@@ -2337,38 +2612,16 @@ export class PiSessionService {
             await this.archiveStore.deleteArchived(sessionId);
         return [...sessionIds];
     }
-    async moveLegacyArchivedRecordsForDelete(records) {
-        const legacyRecords = records.filter((record) => record.archivePath === undefined);
-        if (legacyRecords.length === 0)
-            return [];
-        let sessionsByCwd;
-        try {
-            sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
-        }
-        catch (error) {
-            return legacyRecords.map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
-        }
-        const moveInputs = legacyRecords
-            .map((record) => findSessionByIdOrPrefix(sessionsByCwd.get(record.cwd) ?? [], record.sessionId))
-            .filter(isDefined)
-            .map(archiveInputFromListEntry);
-        if (moveInputs.length === 0)
-            return [];
-        try {
-            await this.archiveStoreArchiveMany(moveInputs);
-            return [];
-        }
-        catch (error) {
-            const failedIds = new Set(moveInputs.map((input) => input.sessionId));
-            return legacyRecords
-                .filter((record) => failedIds.has(record.sessionId))
-                .map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
-        }
-    }
     async cleanupPlan(request) {
-        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.listAll?.() ?? [], this.archiveStore.list()]);
+        const [sessions, archivedRecords, scopedSessions] = await Promise.all([
+            this.sessionManager.listAll(),
+            this.archiveStore.list(),
+            request.thresholds.archiveIdleDays === undefined
+                ? Promise.resolve(new Map())
+                : this.listSessionsByCwd(request.projectCwds ?? []),
+        ]);
         return planSessionCleanup({
-            sessions,
+            sessions: [...sessions, ...[...scopedSessions.values()].flat()],
             archivedRecords,
             activeSessions: this.cleanupActiveSessionStatuses(),
             thresholds: request.thresholds,
@@ -2404,24 +2657,6 @@ export class PiSessionService {
             return record;
         }
     }
-    async ensureArchivedRecordMoved(record) {
-        const session = (await this.sessionManager.list(record.cwd)).find((candidate) => candidate.id === record.sessionId);
-        if (session === undefined)
-            return record;
-        const [moved] = await this.archiveStoreArchiveMany([archiveInputFromListEntry(session)]);
-        return moved ?? record;
-    }
-    async ensureArchivedRecordsMoved(records) {
-        const legacyRecords = records.filter((record) => record.archivePath === undefined);
-        if (legacyRecords.length === 0)
-            return;
-        const sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
-        const moveInputs = legacyRecords
-            .map((record) => sessionsByCwd.get(record.cwd)?.find((candidate) => candidate.id === record.sessionId))
-            .filter(isDefined)
-            .map(archiveInputFromListEntry);
-        await this.archiveStoreArchiveMany(moveInputs);
-    }
     async archiveInputForSession(session) {
         const cwd = session.sessionManager.getCwd();
         const sessionFile = session.sessionFile;
@@ -2487,7 +2722,7 @@ export class PiSessionService {
             if (startup.session.sessionId === sessionId && startup.eventScope === eventScope)
                 this.endSessionExtensionDialogs(startup.session);
         }
-        const pendingOpens = this.pendingSessionOpenPromises(sessionId);
+        const pendingOpens = this.pendingSessionOpenPromises(sessionId, eventScope);
         if (pendingOpens.length > 0)
             await Promise.allSettled(pendingOpens);
         const activeSessions = this.activeSessionsForId(sessionId).filter((active) => active.eventScope === eventScope);
@@ -2498,13 +2733,7 @@ export class PiSessionService {
         await Promise.all(activeSessions.map((active) => this.closeActiveSession(active, notificationPolicy)));
     }
     async closeActiveInScope(sessionId, eventScope, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS) {
-        const active = this.activeForSessionIdAndScope(sessionId, eventScope);
-        if (active !== undefined) {
-            await this.closeActiveSession(active, notificationPolicy);
-        }
-        else if (notificationPolicy.kind === "clear") {
-            this.publishNotificationMutations(this.notificationsForScope(eventScope).clearSession(sessionId, notificationPolicy.reason));
-        }
+        await this.closeActive(sessionId, notificationPolicy, eventScope);
     }
     async closeActiveSession(active, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS) {
         const sessionId = active.runtime.session.sessionId;
@@ -2517,18 +2746,18 @@ export class PiSessionService {
             this.publishNotificationMutations(mutations);
         }
         this.forgetUnreadActivity(active.runtime.session);
-        this.pendingAskStore.forgetSession(sessionId);
+        this.pendingAskStore.forgetSession(this.dialogSessionKey(active.runtime.session));
         this.endSessionExtensionDialogs(active.runtime.session);
         this.active.delete(activeSessionKey(sessionId, active.eventScope));
         this.activities.delete(activeSessionKey(sessionId, active.eventScope));
         this.workspaceActivity?.removeSession(sessionId, active.runtime.session.sessionManager.getCwd(), active.eventScope);
         this.clearAuthLossWarningsForSession(sessionId);
-        this.clearCompactionPromptQueue(sessionId);
+        this.clearCompactionPromptQueue(active.runtime.session);
         // Disarm subsession notification before teardown so the abort below cannot
         // emit a "stopped working" event that notifies the parent (e.g. on archive).
         // The parent/children link is kept so the parent can still see the child.
         if (this.subsessionLinkForActiveChild(active.runtime.session) !== undefined)
-            this.subsessionNotifyArmed.delete(sessionId);
+            this.subsessionNotifyArmed.delete(activeSessionKey(sessionId, active.eventScope));
         clearSessionQueue(active.runtime.session);
         active.unsubscribe();
         active.runtime.setRebindSession(undefined);
@@ -2536,6 +2765,8 @@ export class PiSessionService {
             await this.abortSessionOperations(active.runtime.session);
         }
         finally {
+            if (active.eventScope === NORMAL_SESSION_EVENT_SCOPE)
+                await this.activityMarker.release(active.runtime.session.sessionFile);
             await active.runtime.dispose();
         }
     }
@@ -2594,7 +2825,9 @@ export class PiSessionService {
         const leafId = session.sessionManager.getLeafId();
         const latestEntry = session.sessionManager.getEntries?.().at(-1);
         // Unsummarized tree navigation changes only the SDK's in-memory leaf.
-        if (isRecord(latestEntry) && typeof latestEntry["id"] === "string" && latestEntry["id"] !== leafId)
+        if (!this.unpersistedTreeBranchLeaves.has(session)
+            && isRecord(latestEntry) && typeof latestEntry["id"] === "string"
+            && latestEntry["id"] !== leafId)
             return session.sessionManager.getBranch();
         const sessionFile = session.sessionFile ?? session.sessionManager.getSessionFile();
         const resolvedPath = sessionFile === undefined ? await this.idleSessionFilePath(session) : undefined;
@@ -2606,19 +2839,37 @@ export class PiSessionService {
         const snapshot = await this.sessionManager.readBranch(path);
         if (snapshot === undefined)
             return session.sessionManager.getBranch();
-        return this.hasActiveWork(session) || session.sessionManager.getLeafId() !== leafId ? session.sessionManager.getBranch() : snapshot;
+        if (this.hasActiveWork(session) || session.sessionManager.getLeafId() !== leafId)
+            return session.sessionManager.getBranch();
+        const selectedLeafId = this.unpersistedTreeBranchLeaves.get(session);
+        if (selectedLeafId !== undefined) {
+            const runtimeLeafId = session.sessionManager.getLeafId();
+            const selectedBranchIsAnchored = runtimeLeafId !== null
+                && runtimeLeafId !== selectedLeafId && transcriptBranchIncludesEntry(snapshot, runtimeLeafId);
+            if (!selectedBranchIsAnchored)
+                return session.sessionManager.getBranch();
+            this.unpersistedTreeBranchLeaves.delete(session);
+        }
+        return snapshot;
     }
     async idleSessionFilePath(session) {
         const cached = this.idleSessionFileResolutions.get(session);
         const at = this.now().getTime();
         if (cached !== undefined && at - cached.at < IDLE_SESSION_FILE_RESOLUTION_THROTTLE_MS)
             return cached.path;
-        const match = await this.sessionManager.resolveSessionFile?.(session.sessionManager.getCwd(), session.sessionId);
+        const match = await this.sessionManager.resolveSessionFile(session.sessionManager.getCwd(), session.sessionId);
         this.idleSessionFileResolutions.set(session, { at, path: match?.path });
         return match?.path;
     }
     async getActive(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
+        const resolvedRef = active === undefined ? isPiSessionRef(ref) ? ref : undefined
+            : { id: active.runtime.session.sessionId, cwd: active.runtime.cwd };
+        const pending = resolvedRef === undefined ? undefined : this.pendingSessionOpens.get(JSON.stringify([
+            canonicalizeStoredCwd(resolvedRef.cwd), resolvedRef.id, managementContextKey(managementContext),
+        ]));
+        if (pending !== undefined)
+            return pending.promise;
         if (active !== undefined)
             return active;
         const archived = await this.getArchived(ref);
@@ -2627,10 +2878,8 @@ export class PiSessionService {
             return this.openPending(archived.sessionId, archived.cwd, managementContext, () => this.sessionManager.open(archivePath), { notifications: "disabled" });
         }
         const match = isPiSessionRef(ref)
-            ? this.sessionManager.resolveSessionFile === undefined
-                ? findSessionByIdOrPrefix(await this.sessionManager.list(ref.cwd), ref.id)
-                : await this.sessionManager.resolveSessionFile(ref.cwd, ref.id)
-            : findSessionByIdOrPrefix(await this.sessionManager.listAll?.() ?? [], ref);
+            ? await this.sessionManager.resolveSessionFile(ref.cwd, ref.id)
+            : findSessionByIdOrPrefix(await this.sessionManager.listAll(), ref);
         if (!match)
             throw new Error("未找到会话");
         return this.openPending(match.id, match.cwd, managementContext, () => this.sessionManager.open(match.path));
@@ -2640,8 +2889,12 @@ export class PiSessionService {
         const existing = this.pendingSessionOpens.get(key);
         if (existing !== undefined)
             return existing.promise;
+        const active = this.activeForLookup({ id: sessionId, cwd }, managementContext);
+        if (active !== undefined)
+            return Promise.resolve(active);
         const pending = {
             sessionId,
+            eventScope: eventScopeFromManagementContext(managementContext),
             promise: this.create(openSessionManager(), cwd, {
                 ...options,
                 ...(managementContext === undefined ? {} : { managementContext }),
@@ -2654,9 +2907,9 @@ export class PiSessionService {
         this.pendingSessionOpens.set(key, pending);
         return pending.promise;
     }
-    pendingSessionOpenPromises(sessionId) {
+    pendingSessionOpenPromises(sessionId, eventScope) {
         return [...this.pendingSessionOpens.values()]
-            .filter((pending) => sessionId === undefined || pending.sessionId === sessionId)
+            .filter((pending) => (sessionId === undefined || pending.sessionId === sessionId) && (eventScope === undefined || pending.eventScope === eventScope))
             .map((pending) => pending.promise);
     }
     async getArchived(ref) {
@@ -2705,6 +2958,21 @@ export class PiSessionService {
             throw new Error(`Session not active: ${sessionId}`);
         return this.submitPrompt(active.runtime.session, text, undefined, [], false);
     }
+    /**
+     * Attach to one already-hosted normal-mode session. Management scopes are
+     * not searched: host session events are a normal-mode capability.
+     */
+    connectSessionEvents(ref, lifetime) {
+        const active = this.activeForSessionIdAndScope(ref.id, NORMAL_SESSION_EVENT_SCOPE);
+        if (active?.runtime.session.sessionId !== ref.id
+            || !cwdPathsEqual(active.runtime.session.sessionManager.getCwd(), ref.cwd)) {
+            throw new Error("Selected session is not hosted in this workspace on this machine");
+        }
+        if (this.startupSessions.has(activeSessionKey(ref.id, NORMAL_SESSION_EVENT_SCOPE))) {
+            throw new Error("Selected session is still initializing its extensions");
+        }
+        return this.sessionEvents.connect(active.runtime.session, lifetime);
+    }
     activeForSessionId(sessionId) {
         return this.activeSessionsForId(sessionId)[0];
     }
@@ -2716,17 +2984,25 @@ export class PiSessionService {
     activeSessionsForId(sessionId) {
         return [...new Set(this.active.values())].filter((active) => active.runtime.session.sessionId === sessionId);
     }
-    async create(sessionManager, cwd, options = {}) {
+    create(sessionManager, cwd, options = {}) {
         const startup = this.startupProgress(sessionManager, options.startupIntent ?? "open", options.startupToken, eventScopeFromManagementContext(options.managementContext));
-        try {
-            return await this.createSessionRuntime(sessionManager, cwd, options, startup);
-        }
-        finally {
+        const key = JSON.stringify([canonicalizeStoredCwd(cwd), sessionManager.getSessionId(), managementContextKey(options.managementContext)]);
+        const pending = {
+            sessionId: sessionManager.getSessionId(),
+            eventScope: eventScopeFromManagementContext(options.managementContext),
+            promise: this.createSessionRuntime(sessionManager, cwd, options, startup),
+        };
+        pending.promise = pending.promise.finally(() => {
             startup.end();
-        }
+            if (this.pendingSessionOpens.get(key) === pending)
+                this.pendingSessionOpens.delete(key);
+        });
+        this.pendingSessionOpens.set(key, pending);
+        return pending.promise;
     }
-    async bindSessionExtensions(session, generation, owner) {
-        const uiContext = this.sessionUiContext(session, generation);
+    async bindSessionExtensions(session, generation, owner, startupSignal) {
+        const startupDialogs = { signal: startupSignal };
+        const uiContext = this.sessionUiContext(session, generation, startupDialogs);
         const key = activeSessionKey(session.sessionId, owner.eventScope);
         this.startupSessions.set(key, { session, ...owner });
         try {
@@ -2741,6 +3017,9 @@ export class PiSessionService {
             });
         }
         finally {
+            // A captured startup UI context must not carry plugin cancellation into
+            // later user turns after startup has finished.
+            startupDialogs.signal = undefined;
             if (this.startupSessions.get(key)?.session === session)
                 this.startupSessions.delete(key);
         }
@@ -2749,50 +3028,66 @@ export class PiSessionService {
         this.sessionEventScopes.set(session, active.eventScope);
         this.runtimeBySession.set(session, active.runtime);
         active.unsubscribe();
-        for (const [sessionId, candidate] of this.active.entries()) {
+        for (const [sessionKey, candidate] of this.active.entries()) {
             if (candidate === active) {
-                this.active.delete(sessionId);
-                if (!sessionId.endsWith(`\0${session.sessionId}`))
-                    this.clearCompactionPromptQueue(candidate.runtime.session.sessionId);
+                this.active.delete(sessionKey);
+                if (sessionKey !== activeSessionKey(session.sessionId, active.eventScope))
+                    this.clearCompactionPromptQueueKey(sessionKey);
             }
         }
-        active.unsubscribe = session.subscribe((event) => {
+        if (active.eventScope === NORMAL_SESSION_EVENT_SCOPE && active.runtime.session !== session) {
+            this.sessionEvents.close(active.runtime.session);
+        }
+        const unsubscribe = session.subscribe((event) => {
             this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel), active.eventScope);
             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, "扩展错误", "error", message);
+                    this.events.publish(session.sessionId, { type: "session.error", message }, active.eventScope);
+                });
+            }
             if (eventType === "agent_end")
                 this.abortRunScopedExtensionDialogs(session);
             if (eventType === "compaction_end")
-                this.scheduleCompactionQueueDrain(session.sessionId);
+                this.scheduleCompactionQueueDrain(session);
             if (eventType === "agent_start" || eventType === "agent_end")
-                this.scheduleCompactionQueueDrain(session.sessionId);
+                this.scheduleCompactionQueueDrain(session);
             this.publishStatus(session);
             this.updateSubsessionTracking(session);
         });
+        active.unsubscribe = () => {
+            if (active.eventScope === NORMAL_SESSION_EVENT_SCOPE)
+                this.sessionEvents.close(session);
+            unsubscribe();
+        };
         this.active.set(activeSessionKey(session.sessionId, active.eventScope), active);
     }
-    scheduleCompactionQueueDrain(sessionId, delayMs = 0) {
-        if (!this.compactionPromptQueues.has(sessionId) || this.compactionDrainTimers.has(sessionId))
+    scheduleCompactionQueueDrain(session, delayMs = 0) {
+        const sessionKey = activeSessionKey(session.sessionId, this.eventScopeForSession(session));
+        if (!this.isCurrentActiveSession(session)
+            || !this.compactionPromptQueues.has(sessionKey) || this.compactionDrainTimers.has(sessionKey))
             return;
         const timer = setTimeout(() => {
-            this.compactionDrainTimers.delete(sessionId);
-            this.drainCompactionPromptQueue(sessionId);
+            this.compactionDrainTimers.delete(sessionKey);
+            this.drainCompactionPromptQueue(session);
         }, delayMs);
-        this.compactionDrainTimers.set(sessionId, timer);
+        this.compactionDrainTimers.set(sessionKey, timer);
     }
-    drainCompactionPromptQueue(sessionId) {
-        const active = this.activeForSessionId(sessionId);
-        if (active === undefined)
+    drainCompactionPromptQueue(session) {
+        if (!this.isCurrentActiveSession(session))
             return;
-        const { session } = active.runtime;
+        const sessionKey = activeSessionKey(session.sessionId, this.eventScopeForSession(session));
         if (session.isCompacting) {
-            this.scheduleCompactionQueueDrain(sessionId, 100);
+            this.scheduleCompactionQueueDrain(session, 100);
             return;
         }
         if (session.isStreaming) {
-            const queued = this.takeCompactionPromptQueue(sessionId);
+            const queued = this.takeCompactionPromptQueue(sessionKey);
             if (queued.length === 0)
                 return;
             this.publishStatus(session);
@@ -2800,12 +3095,12 @@ export class PiSessionService {
                 void this.submitPrompt(session, prompt.text, prompt.kind, prompt.images, prompt.echoUserMessage ?? true);
             return;
         }
-        const prompt = this.shiftCompactionPrompt(sessionId);
+        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);
-        void submitted.finally(() => { this.scheduleCompactionQueueDrain(sessionId); });
+        void submitted.finally(() => { this.scheduleCompactionQueueDrain(session); });
     }
     takeCompactionPromptQueue(sessionId) {
         const queued = this.compactionPromptQueues.get(sessionId) ?? [];
@@ -2819,12 +3114,15 @@ export class PiSessionService {
             this.compactionPromptQueues.delete(sessionId);
         return prompt;
     }
-    clearCompactionPromptQueue(sessionId) {
-        this.compactionPromptQueues.delete(sessionId);
-        const timer = this.compactionDrainTimers.get(sessionId);
+    clearCompactionPromptQueue(session) {
+        this.clearCompactionPromptQueueKey(activeSessionKey(session.sessionId, this.eventScopeForSession(session)));
+    }
+    clearCompactionPromptQueueKey(sessionKey) {
+        this.compactionPromptQueues.delete(sessionKey);
+        const timer = this.compactionDrainTimers.get(sessionKey);
         if (timer !== undefined) {
             clearTimeout(timer);
-            this.compactionDrainTimers.delete(sessionId);
+            this.compactionDrainTimers.delete(sessionKey);
         }
     }
     clearCompactionDrainTimers() {
@@ -2913,6 +3211,7 @@ export class PiSessionService {
             // the session still reports active work transiently, so the event-driven
             // latch may not fire. The heartbeat re-checks once the session settles.
             this.updateSubsessionTracking(session);
+            void this.refreshActivityMarker(session);
             const activity = this.activities.get(activeSessionKey(session.sessionId, active.eventScope));
             if (!this.hasActiveWork(session)) {
                 if (activity?.phase === "active")
@@ -2945,7 +3244,7 @@ export class PiSessionService {
         return this.treeNavigations.has(session)
             || this.isSessionEntryMutationActive(session)
             || this.isTreeExclusiveOperationActive(session)
-            || sessionHasActiveWork(session, this.compactionQueuedMessages(session.sessionId).length);
+            || sessionHasActiveWork(session, this.compactionQueuedMessages(session).length);
     }
     async runTreeExclusiveOperation(targets, activeError, operation) {
         const sessionIds = new Set();
@@ -3005,7 +3304,7 @@ export class PiSessionService {
     }
     assertTreeNavigationInactive(session, action) {
         if (this.treeNavigations.has(session))
-            throw new Error(`Cannot ${action} while session tree navigation is active`);
+            throw new Error(`会话树导航期间无法${action}`);
     }
     async runSessionEntryMutation(session, action, operation) {
         this.beginSessionEntryMutation(session, action);
@@ -3139,16 +3438,16 @@ export class PiSessionService {
         const message = getProperty(event, "message");
         if (getString(message, "role") !== "assistant")
             return;
-        this.recordManagementContentAudit(active, "assistant_response", auditVisibleAssistantMessage(message));
+        this.recordManagementMessageAudit(active, "assistant_response", auditVisibleAssistantMessage(message));
     }
     auditUserPrompt(session, text) {
         const active = [...new Set(this.active.values())]
             .find(candidate => candidate.runtime.session === session);
         if (active === undefined)
             return;
-        this.recordManagementContentAudit(active, "user_prompt", text);
+        this.recordManagementMessageAudit(active, "user_prompt", text);
     }
-    recordManagementContentAudit(active, action, content) {
+    recordManagementMessageAudit(active, action, content) {
         const identity = active.managementAuditIdentity;
         if (identity === undefined || this.managementAudit === undefined)
             return;
@@ -3167,7 +3466,7 @@ export class PiSessionService {
                 sessionId: active.runtime.session.sessionId,
                 action,
                 error: error instanceof Error ? error.message : String(error),
-            }, "failed to enqueue management-mode content audit");
+            }, "failed to enqueue management-mode message audit");
         }
     }
     /**
@@ -3229,7 +3528,20 @@ export class PiSessionService {
         this.events.publishGlobal({ type: "activity.update", activity }, eventScope);
         this.observeUnreadActivityState(session);
     }
+    async refreshActivityMarker(session) {
+        const eventScope = this.eventScopeForSession(session);
+        if (eventScope !== NORMAL_SESSION_EVENT_SCOPE
+            || this.activeForSessionIdAndScope(session.sessionId, eventScope)?.runtime.session !== session)
+            return;
+        const previous = this.activityMarker.isActiveElsewhere(session.sessionFile);
+        await this.activityMarker.refresh(session.sessionFile, this.hasActiveWork(session));
+        if (this.activeForSessionIdAndScope(session.sessionId, eventScope)?.runtime.session === session
+            && previous !== this.activityMarker.isActiveElsewhere(session.sessionFile)) {
+            this.publishStatus(session);
+        }
+    }
     publishStatus(session) {
+        void this.refreshActivityMarker(session);
         const status = this.statusFromSession(session);
         this.clearStaleActiveActivity(session);
         const eventScope = this.eventScopeForSession(session);
@@ -3271,7 +3583,7 @@ export class PiSessionService {
         const eventScope = this.eventScopeForSession(session);
         return eventScope === NORMAL_SESSION_EVENT_SCOPE ? session.sessionId : activeSessionKey(session.sessionId, eventScope);
     }
-    publishStatusForSessionId(sessionId) {
+    publishStatusForSessionId(sessionId, scope) {
         const sessions = new Set();
         for (const active of this.activeSessionsForId(sessionId))
             sessions.add(active.runtime.session);
@@ -3279,15 +3591,17 @@ export class PiSessionService {
             if (startup.session.sessionId === sessionId)
                 sessions.add(startup.session);
         }
-        for (const session of sessions)
-            this.publishStatus(session);
+        for (const session of sessions) {
+            if (scope === undefined || this.eventScopeForSession(session) === scope)
+                this.publishStatus(session);
+        }
     }
     statusFromSession(session, messageCount = session.messages.length) {
         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(session.sessionId);
+        const pendingAsk = this.pendingAskStore.pendingAsk(this.dialogSessionKey(session));
         const pendingDialogs = this.pendingExtensionDialogStore.pendingDialogs(this.dialogSessionKey(session));
         return {
             sessionId: session.sessionId,
@@ -3298,7 +3612,7 @@ export class PiSessionService {
             isCompacting: session.isCompacting,
             isBashRunning: session.isBashRunning,
             pendingMessageCount: this.pendingMessageCount(session),
-            queuedMessages: queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)),
+            queuedMessages: queuedMessagesFromSession(session, this.compactionQueuedMessages(session)),
             messageCount,
             tokens: stats.tokens,
             cost: stats.cost,
@@ -3317,19 +3631,28 @@ export class PiSessionService {
     warningsForSession(session) {
         const runtime = [...this.active.values()].find((active) => active.runtime.session === session)?.runtime;
         const warnings = runtime === undefined ? [] : collectRuntimeWarnings(runtime);
-        const anthropic = anthropicSubscriptionWarning(session, join(this.agentDir, "auth.json"));
+        if (this.eventScopeForSession(session) === NORMAL_SESSION_EVENT_SCOPE
+            && this.activityMarker.isActiveElsewhere(session.sessionFile)) {
+            warnings.push({
+                severity: "info",
+                message: "此会话最近在另一个 PI WEB 实例中活动。请避免在两个实例中同时操作此会话。",
+                source: "PI-WEB",
+            });
+        }
+        const authPath = modelRuntimeAuthPath(session.modelRuntime);
+        const anthropic = authPath === undefined ? undefined : anthropicSubscriptionWarning(session, authPath);
         if (anthropic !== undefined)
             warnings.push(anthropic);
         return warnings;
     }
     pendingMessageCount(session) {
-        return session.pendingMessageCount + this.compactionQueuedMessages(session.sessionId).length;
+        return session.pendingMessageCount + this.compactionQueuedMessages(session).length;
     }
-    compactionQueuedMessages(sessionId) {
-        return this.compactionPromptQueues.get(sessionId) ?? [];
+    compactionQueuedMessages(session) {
+        return this.compactionPromptQueues.get(activeSessionKey(session.sessionId, this.eventScopeForSession(session))) ?? [];
     }
     hasQueuedMessageText(session, text) {
-        return queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)).some((message) => message.text === text);
+        return queuedMessagesFromSession(session, this.compactionQueuedMessages(session)).some((message) => message.text === text);
     }
     notificationsForScope(scope) {
         if (scope === NORMAL_SESSION_EVENT_SCOPE)
@@ -3366,6 +3689,9 @@ export class PiSessionService {
         await this.publishUnreadMutations([]);
         return this.unreadForScope(eventScope).durableCatalogSnapshot();
     }
+    async reconcileUnreadWorkspaces(cwds) {
+        await this.publishUnreadMutations(this.unreadStore.reconcileWorkspaces(cwds));
+    }
     async acknowledgeUnread(sessionId, request, context) {
         const store = this.unreadForScope(eventScopeFromManagementContext(context));
         const result = store.acknowledge(sessionId, {
@@ -3389,7 +3715,7 @@ export class PiSessionService {
         return result.snapshot;
     }
     async deliverSubsessionNotification(session, notification) {
-        await this.runSessionEntryMutation(session, "deliver a subsession notification", () => session.sendCustomMessage({ customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE, content: notification.text, display: true, details: { sessionId: notification.childId } }, { triggerTurn: true, deliverAs: "followUp" }));
+        await this.runSessionEntryMutation(session, "发送子会话通知", () => 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) {
@@ -3410,6 +3736,7 @@ export class PiSessionService {
                         this.replaceSessionNotificationContext(session, candidateGeneration);
                     },
                 });
+                await this.reloadModelScope(session);
                 if (candidateGeneration !== undefined) {
                     this.publishNotificationMutations(this.notificationsForSession(session).commitReplacement(candidateGeneration));
                 }
@@ -3423,44 +3750,34 @@ export class PiSessionService {
                 }
                 const message = error instanceof Error ? error.message : String(error);
                 this.publishActivity(session, "重新加载失败", "error", message);
-                this.events.publish(session.sessionId, { type: "session.error", message });
+                this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
                 this.publishStatus(session);
                 throw error;
             }
         });
     }
-    async dismissWarning(ref, dismissId) {
-        const session = await this.getOrOpen(ref);
+    async dismissWarning(ref, dismissId, managementContext) {
+        const session = await this.getOrOpen(ref, managementContext);
         dismissSessionWarning(session, dismissId);
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
     openExistingSession(sessionId, cwd, openSessionManager, options = {}) {
-        const active = this.activeForLookup({ id: sessionId, cwd }, options.managementContext);
-        if (active !== undefined)
-            return Promise.resolve(active);
-        const key = JSON.stringify([canonicalizeStoredCwd(cwd), sessionId]);
-        const existing = this.pendingSessionOpens.get(key);
-        if (existing !== undefined)
-            return existing.promise;
-        const pending = {
-            sessionId,
-            promise: this.create(openSessionManager(), cwd, options),
-        };
-        pending.promise = pending.promise.finally(() => {
-            if (this.pendingSessionOpens.get(key) === pending)
-                this.pendingSessionOpens.delete(key);
-        });
-        this.pendingSessionOpens.set(key, pending);
-        return pending.promise;
+        return this.openPending(sessionId, cwd, options.managementContext, openSessionManager, options);
     }
     isCurrentActiveSession(session) {
         return [...this.active.values()].some((active) => active.runtime.session === session);
     }
     async createSessionRuntime(sessionManager, cwd, options, startup) {
         startup.report(STARTUP_PHASE_RUNTIME);
-        const delegationToolsEnabled = options.creationProvenance !== "tracked-subsession"
-            && await sessionAllowsDelegationTools(sessionManager, this.sessionManager);
+        options.startupSignal?.throwIfAborted();
+        // Ordinary local sessions (undefined provenance) keep the current rule.
+        // Only an explicit host one-shot forces delegation off; do not treat every
+        // defined provenance as disabled the way upstream does.
+        const delegationToolsEnabled = options.creationProvenance === "host-one-shot"
+            ? false
+            : options.creationProvenance !== "tracked-subsession"
+                && await sessionAllowsDelegationTools(sessionManager, this.sessionManager);
         const runtime = await this.createAgentRuntime(this.createRuntime, {
             cwd,
             agentDir: this.agentDir,
@@ -3481,6 +3798,13 @@ export class PiSessionService {
         };
         let boundSession = runtime.session;
         this.sessionEventScopes.set(boundSession, active.eventScope);
+        if (options.managementContext !== undefined)
+            this.sessionManagementContexts.set(boundSession, options.managementContext);
+        const startupSignal = options.startupSignal;
+        const cancelStartup = () => { this.endSessionExtensionDialogs(boundSession); };
+        if (startupSignal !== undefined && !startupSignal.aborted) {
+            startupSignal.addEventListener("abort", cancelStartup, { once: true });
+        }
         const notificationStore = this.notificationsForScope(active.eventScope);
         let notificationGeneration = options.notificationGeneration;
         let notificationOwnership = options.notifications === "disabled"
@@ -3504,17 +3828,23 @@ export class PiSessionService {
         if (notificationGeneration !== undefined)
             this.notificationGenerationBySession.set(runtime.session, notificationGeneration);
         try {
+            startupSignal?.throwIfAborted();
             if (options.creationProvenance === "tracked-subsession") {
                 await this.publishUnreadMutations(this.unreadForScope(active.eventScope).excludeSession(runtime.session.sessionId, canonicalizeStoredCwd(runtime.session.sessionManager.getCwd())));
             }
             else {
                 await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
             }
+            startupSignal?.throwIfAborted();
             startup.report(STARTUP_PHASE_EXTENSIONS);
-            await this.bindSessionExtensions(runtime.session, notificationGeneration, active);
+            // Startup hooks emit through the same scoped stream as hosted turns.
             this.bindRuntime(active);
+            await this.bindSessionExtensions(runtime.session, notificationGeneration, active, startupSignal);
+            startupSignal?.throwIfAborted();
             runtime.setRebindSession(async (session) => {
                 this.sessionEventScopes.set(session, active.eventScope);
+                if (options.managementContext !== undefined)
+                    this.sessionManagementContexts.set(session, options.managementContext);
                 const priorGeneration = notificationGeneration;
                 let candidateGeneration;
                 try {
@@ -3545,6 +3875,7 @@ export class PiSessionService {
                     throw error;
                 }
             });
+            startupSignal?.throwIfAborted();
             this.active.set(activeSessionKey(runtime.session.sessionId, active.eventScope), active);
             if (notificationOwnership === "replacement" && notificationGeneration !== undefined) {
                 this.publishNotificationMutations(notificationStore.commitReplacement(notificationGeneration));
@@ -3572,7 +3903,7 @@ export class PiSessionService {
                 this.active.delete(sessionKey);
                 this.activities.delete(sessionKey);
                 this.clearAuthLossWarningsForSession(runtime.session.sessionId);
-                this.clearCompactionPromptQueue(runtime.session.sessionId);
+                this.clearCompactionPromptQueue(runtime.session);
                 removedActive = true;
             }
             if (removedActive) {
@@ -3586,11 +3917,14 @@ export class PiSessionService {
             }
             throw error;
         }
+        finally {
+            startupSignal?.removeEventListener("abort", cancelStartup);
+        }
     }
     replaceSessionNotificationContext(session, generation) {
         session.extensionRunner.setUIContext(this.sessionUiContext(session, generation), "rpc");
     }
-    sessionUiContext(session, generation) {
+    sessionUiContext(session, generation, startupDialogs = {}) {
         const baseUiContext = session.extensionRunner.getUIContext();
         const eventScope = this.eventScopeForSession(session);
         const notificationStore = this.notificationsForScope(eventScope);
@@ -3605,14 +3939,6 @@ export class PiSessionService {
             }
             const added = notificationStore.addNotification(generation, message, type);
             this.publishNotificationMutations(added.mutations);
-            if (added.notification === undefined)
-                return;
-            this.events.publish(session.sessionId, {
-                type: "command.output",
-                level: type === "error" ? "error" : "info",
-                message,
-                notificationId: added.notification.id,
-            }, eventScope);
         };
         // PI WEB owns the browser-facing dialog, notification, and text-formatting
         // boundaries: the three dialog primitives park daemon-held Promises that
@@ -3626,13 +3952,13 @@ export class PiSessionService {
                 if (property === "theme")
                     return plainTextTheme;
                 if (property === "confirm") {
-                    return (title, message, opts) => this.openExtensionDialog(session, { kind: "confirm", title, message }, opts);
+                    return (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);
+                    return (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);
+                    return (title, placeholder, opts) => this.openExtensionDialog(session, { kind: "input", title, placeholder }, opts, startupDialogs.signal);
                 }
                 const value = Reflect.get(target, property, receiver);
                 return value;
@@ -3673,11 +3999,12 @@ export class PiSessionService {
     }
     publishUnreadMutations(mutations) {
         if (mutations.length > 0) {
-            const scopes = new Set();
+            const scopes = new Map();
             for (const mutation of mutations) {
-                scopes.add(mutation.eventScope ?? NORMAL_SESSION_EVENT_SCOPE);
+                const scope = mutation.eventScope ?? NORMAL_SESSION_EVENT_SCOPE;
+                scopes.set(scope, scopes.get(scope) === true || mutation.event.unread !== null);
             }
-            scopes.forEach((scope) => this.onUnreadChanged?.(scope));
+            scopes.forEach((hasNewCompletion, scope) => this.onUnreadChanged?.(scope, hasNewCompletion));
         }
         this.enqueueUnreadMutations(mutations);
         this.unreadPublicationFlushRequested = true;
@@ -3858,7 +4185,7 @@ function clientSessionFromListEntry(session) {
         created: session.created.toISOString(),
         modified: session.modified.toISOString(),
         messageCount: session.messageCount,
-        firstMessage: session.firstMessage,
+        firstMessage: clientSessionFirstMessagePreview(session.firstMessage),
         ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
     };
 }
@@ -4092,37 +4419,12 @@ function buildPromptOptions(behavior, images) {
         options.images = images;
     return Object.keys(options).length > 0 ? options : undefined;
 }
-function stringValue(value) {
-    return typeof value === "string" ? value : "";
-}
 function historyMessages(session) {
     return historyMessagesFromManager(session.sessionManager);
 }
 function historyMessagesFromManager(sessionManager) {
     return historyMessagesFromEntries(sessionManager.getBranch());
 }
-function historyMessagesFromEntries(entries) {
-    const messages = [];
-    let thinkingLevel;
-    for (const entry of entries) {
-        if (!isRecord(entry))
-            continue;
-        if (entry["type"] === "message")
-            messages.push(annotateAssistantThinkingLevel(entry["message"], thinkingLevel));
-        else if (entry["type"] === "thinking_level_change") {
-            const level = getString(entry, "thinkingLevel");
-            if (level !== undefined)
-                thinkingLevel = level;
-        }
-        else if (entry["type"] === "custom_message" && entry["display"] === true)
-            messages.push({ role: "custom", content: entry["content"], customType: entry["customType"], details: entry["details"] });
-        else if (entry["type"] === "compaction")
-            messages.push({ role: "system", source: "compaction", content: `Compacted history:\n\n${stringValue(entry["summary"])}` });
-        else if (entry["type"] === "branch_summary")
-            messages.push({ role: "system", source: "branch_summary", content: `Branch summary:\n\n${stringValue(entry["summary"])}` });
-    }
-    return messages;
-}
 function transcriptMessageCount(entries) {
     let count = 0;
     for (const entry of entries) {
@@ -4131,6 +4433,30 @@ function transcriptMessageCount(entries) {
     }
     return count;
 }
+function activeEditableTreeTargetParentId(manager, targetId, activeLeafId) {
+    if (activeLeafId !== targetId)
+        return undefined;
+    const entry = manager.getBranch().at(-1);
+    if (!isRecord(entry) || entry["id"] !== targetId)
+        return undefined;
+    const isUserMessage = entry["type"] === "message"
+        && isRecord(entry["message"]) && entry["message"]["role"] === "user";
+    if (!isUserMessage && entry["type"] !== "custom_message")
+        return undefined;
+    const parentId = entry["parentId"];
+    if (parentId === targetId)
+        return undefined;
+    return parentId === null || typeof parentId === "string" ? parentId : undefined;
+}
+function setSessionTreeLeaf(manager, leafId) {
+    if (leafId === null)
+        manager.resetLeaf();
+    else
+        manager.branch(leafId);
+}
+function transcriptBranchIncludesEntry(entries, entryId) {
+    return entries.some((entry) => isRecord(entry) && entry["id"] === entryId);
+}
 /** custom entry type used to persist parent -> child subsession links outside LLM context. */
 const SUBSESSION_LINK_CUSTOM_TYPE = "pi-web.subsession.link";
 /** custom entry type used to mark a child as created by spawn_subsession. */