@chainingintention/pi-web-cn 1.202607.10 → 1.202608.2

package/dist/server/sessions/piSessionService.js

@@ -1,31 +1,61 @@
 import { statSync } from "node:fs";
-import { open, readFile, writeFile } from "node:fs/promises";
+import { readFile, writeFile } 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, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, getAgentDir, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, ModelRuntime, 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 { projectSessionTree } from "./sessionTreeProjection.js";
 import { SessionArchiveStore } from "./sessionArchiveStore.js";
 import { findArchiveCandidateByIdOrPrefix, planSessionArchiveTree } from "./sessionArchiveTree.js";
 import { deterministicSessionName, fallbackSessionName, generateShortSessionName } from "./sessionNameGenerator.js";
 import { computeEditPreview } from "./editPreview.js";
 import { attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachmentService.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 { createPiSessionManagerGateway } from "./piSessionManagerGateway.js";
 import { SessionPinStore } from "./sessionPinStore.js";
+import { SessionActivityCoordinator } from "./sessionActivityCoordinator.js";
+import { searchSessionContent } from "./sessionContentSearch.js";
 import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
+import { readSessionHeaderSummary } from "./sessionFileHeader.js";
+import { countOutOfListingChildren, locateOutOfListingParents } from "./parentSessionLocator.js";
+import { siblingWorkspaceCwds } from "../workspaces/projectWorkspaceCwds.js";
 import { piWebDataDir } from "../../config.js";
 import { createScopedSettingsManager, resolveSettingsScopeDirectory } from "./projectSettingsScope.js";
+import { createAskUserToolDefinition } from "./askUserTool.js";
+import { PendingAskStore, renderAskUserAnswersText } from "./pendingAskStore.js";
 import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
 import { createSubsessionToolDefinitions } from "./spawnSubsessionTool.js";
 import { buildTranscriptView } from "./subsessionTranscript.js";
 import { planSessionCleanup, summarizeSessionCleanupExecution } from "./sessionCleanup.js";
 import { createManagedAgentToolOptions, createManagedPythonToolDefinition } from "./managementAgentTools.js";
 import { PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR, managementAgentToolNames, withRuntimeCreationEnvironment, writeManagementPermissionSystemPolicy } from "./managementPermissionSystem.js";
+import { SessionNotificationStore } from "./sessionNotificationStore.js";
+import { plainTextTheme } from "./plainTextTheme.js";
+import { SessionUnreadStore } from "./sessionUnreadStore.js";
 import { archiveCandidateFromActiveSession, archiveCandidateFromArchivedRecord, archiveCandidateFromListEntry, archiveInputFromActiveSession, archiveInputFromCandidate, archiveInputFromListEntry, clientSessionFromArchivedRecord, compareArchivedRecords, } from "./sessionArchiveMapping.js";
 import { getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
 const noopLogger = { info() { } };
+const DEFAULT_UNREAD_PUBLICATION_RETRY_MS = 1_000;
+/**
+ * User-facing names for the two phases of session startup PI WEB can prove it
+ * is inside: it awaits exactly one call for each, so the phase is a fact rather
+ * than a guess. Deliberately free of internal symbol names and file paths.
+ */
+const STARTUP_PHASE_RUNTIME = "正在启动 Pi 会话";
+const STARTUP_PHASE_EXTENSIONS = "正在加载会话扩展";
+/**
+ * Appended to whichever phase is running when a background provider catalog
+ * refresh happens to be in flight. It is stated as a concurrent fact, never as
+ * the cause: PI WEB can verify that a refresh is running, but not that this
+ * particular startup is waiting on it.
+ */
+const STARTUP_CONCURRENT_CATALOG_REFRESH = "服务商模型列表正在刷新";
+const MAX_UNREAD_PUBLICATION_RETRY_MS = 30_000;
+const MAX_PENDING_UNREAD_MUTATIONS = SESSION_UNREAD_LIMIT + 1;
 function noop() {
     // Intentionally empty default unsubscribe callback.
 }
@@ -49,6 +79,37 @@ function lookupMatchesActiveSession(ref, active) {
 function activeSessionKey(sessionId, eventScope) {
     return `${eventScope}\0${sessionId}`;
 }
+function sessionTreeNavigationOptions(request) {
+    switch (request.summary.mode) {
+        case "none":
+            return { summarize: false };
+        case "default":
+            return { summarize: true };
+        case "custom": {
+            const customInstructions = request.summary.instructions.trim();
+            if (customInstructions === "")
+                throw new Error("Custom branch-summary instructions are required");
+            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`);
+            }
+            return { summarize: true, customInstructions };
+        }
+    }
+}
+function decrementWeakCount(counts, key) {
+    const remaining = (counts.get(key) ?? 1) - 1;
+    if (remaining <= 0)
+        counts.delete(key);
+    else
+        counts.set(key, remaining);
+}
+function decrementMapCount(counts, key) {
+    const remaining = (counts.get(key) ?? 1) - 1;
+    if (remaining <= 0)
+        counts.delete(key);
+    else
+        counts.set(key, remaining);
+}
 function requirePromptText(value) {
     if (typeof value !== "string")
         throw new Error("提示文本为必填项");
@@ -81,6 +142,109 @@ function pathInsideOrEqual(parent, child) {
     const childRelativePath = relative(normalizedParent, normalizedChild);
     return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
 }
+const CLEAR_RUNTIME_NOTIFICATIONS = { kind: "clear", reason: "runtime-close" };
+const DEFER_RUNTIME_NOTIFICATIONS = { kind: "defer" };
+function resourceDiagnosticToWarning(diagnostic, source) {
+    return {
+        severity: diagnostic.type === "error" ? "error" : "warning",
+        message: diagnostic.message,
+        source,
+        ...(diagnostic.path === undefined ? {} : { path: diagnostic.path }),
+    };
+}
+function runtimeDiagnosticToWarning(diagnostic) {
+    return { severity: diagnostic.type, message: diagnostic.message, source: "runtime" };
+}
+/**
+ * Compute the live warnings for a runtime by re-reading its current resource
+ * loader diagnostics, extension load errors, and runtime setup diagnostics.
+ *
+ * This mimics the TUI recomputing warnings on every (re)bind: it reads the
+ * runtime's current state rather than a cached snapshot, so a rebuilt runtime
+ * yields fresh warnings. Runtimes without SDK services (e.g. test fakes)
+ * contribute no warnings.
+ */
+export function collectRuntimeWarnings(runtime) {
+    const warnings = [];
+    for (const diagnostic of runtime.diagnostics ?? [])
+        warnings.push(runtimeDiagnosticToWarning(diagnostic));
+    const resourceLoader = runtime.services?.resourceLoader;
+    if (resourceLoader !== undefined) {
+        for (const diagnostic of resourceLoader.getSkills().diagnostics)
+            warnings.push(resourceDiagnosticToWarning(diagnostic, "skill"));
+        for (const diagnostic of resourceLoader.getPrompts().diagnostics)
+            warnings.push(resourceDiagnosticToWarning(diagnostic, "prompt"));
+        for (const diagnostic of resourceLoader.getThemes().diagnostics)
+            warnings.push(resourceDiagnosticToWarning(diagnostic, "theme"));
+        for (const error of resourceLoader.getExtensions().errors) {
+            warnings.push({ severity: "error", message: `${error.path}: ${error.error}`, source: "extension", path: error.path });
+        }
+    }
+    return warnings;
+}
+/**
+ * Verbatim TUI wording for the Anthropic subscription-auth billing notice. Kept
+ * character-for-character in sync with `ANTHROPIC_SUBSCRIPTION_AUTH_WARNING` in
+ * the SDK's interactive mode so the browser shows the same message the TUI does.
+ */
+const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
+/** Mirror of the SDK TUI `isAnthropicSubscriptionAuthKey` (subscription API keys start with `sk-ant-oat`). */
+function isAnthropicSubscriptionAuthKey(apiKey) {
+    return typeof apiKey === "string" && apiKey.startsWith("sk-ant-oat");
+}
+/**
+ * Dismiss id for the Anthropic subscription-auth billing notice. This is `pi`'s
+ * own `WarningSettings` key verbatim (`anthropicExtraUsage`): we carry the
+ * coupling `pi` already defines rather than inventing a parallel vocabulary, and
+ * {@link dismissSessionWarning} maps it back to `setWarnings`.
+ */
+const ANTHROPIC_EXTRA_USAGE_DISMISS_ID = "anthropicExtraUsage";
+/**
+ * Port of the TUI `maybeWarnAboutAnthropicSubscriptionAuth` gate/trigger, computed
+ * live from the session's current model, stored Anthropic credential, and warning
+ * settings. Returns the billing warning when the active provider is `anthropic`
+ * and auth is a subscription credential (stored `oauth`, or an `sk-ant-oat` API
+ * key), unless suppressed via `getWarnings().anthropicExtraUsage === false`.
+ *
+ * The stored credential is read synchronously (matching the TUI's `oauth` branch
+ * and the documented `sk-ant-oat` key trigger) so warnings stay part of the
+ * synchronous live status computation.
+ */
+export function anthropicSubscriptionWarning(session, authPath) {
+    if (session.settingsManager.getWarnings().anthropicExtraUsage === false)
+        return undefined;
+    if (session.model?.provider !== "anthropic")
+        return undefined;
+    const credential = readStoredCredential("anthropic", authPath);
+    if (credential === undefined)
+        return undefined;
+    const isSubscriptionAuth = credential.type === "oauth"
+        ? true
+        : isAnthropicSubscriptionAuthKey(credential.key);
+    if (!isSubscriptionAuth)
+        return undefined;
+    return {
+        severity: "warning",
+        message: ANTHROPIC_SUBSCRIPTION_AUTH_WARNING,
+        source: "anthropic",
+        dismiss: { id: ANTHROPIC_EXTRA_USAGE_DISMISS_ID },
+    };
+}
+/**
+ * Durably suppress a dismissable session warning by mapping its opaque dismiss
+ * id back to the concrete `pi` suppression it represents. Only known ids are
+ * honored; unknown ids throw so a stale/forged client cannot silently no-op.
+ *
+ * This is the single place provider-specific suppression lives: the wire type,
+ * parser, and UI stay agnostic. Adding a future dismissable warning is a
+ * server-only change here plus a `dismiss` id on its producer.
+ */
+export function dismissSessionWarning(session, dismissId) {
+    if (dismissId !== ANTHROPIC_EXTRA_USAGE_DISMISS_ID) {
+        throw new Error(`Unknown session warning dismiss id: ${dismissId}`);
+    }
+    session.settingsManager.setWarnings({ ...session.settingsManager.getWarnings(), anthropicExtraUsage: false });
+}
 function defaultCreateAgentRuntime(createRuntime, options) {
     if (!(options.sessionManager instanceof SessionManager))
         throw new Error("Default runtime creation requires an SDK SessionManager");
@@ -109,11 +273,11 @@ function createRuntimeWithContextAndOneShotInitialModel(createRuntime, managemen
         });
     };
 }
-function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions) {
+function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions, askUser) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, delegationToolsEnabled = true }) => {
         const scopedModelRuntime = managementContext === undefined ? await normalModelRuntimeForCwd(cwd) : await managementModelRuntime();
         if (managementContext !== undefined) {
-            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, spawn, subsessions, managementContext)({
+            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext)({
                 cwd,
                 agentDir,
                 sessionManager,
@@ -128,7 +292,7 @@ function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRu
             globalAgentDir: agentDir,
         });
         const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime: scopedModelRuntime, settingsManager });
-        const customTools = createPiWebCustomToolDefinitions(cwd, delegationToolsEnabled, spawn, subsessions);
+        const customTools = createPiWebCustomToolDefinitions(cwd, delegationToolsEnabled, spawn, subsessions, askUser);
         const result = await createAgentSessionFromServices({
             services,
             sessionManager,
@@ -139,7 +303,7 @@ function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRu
         return { ...result, services, diagnostics: services.diagnostics };
     };
 }
-function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spawn, subsessions, managementContext) {
+function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, delegationToolsEnabled = true }) => {
         const policyAgentDir = await writeManagementPermissionSystemPolicy(agentDir, cwd, managementContext);
         return withRuntimeCreationEnvironment({ [PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR]: policyAgentDir }, async () => {
@@ -163,6 +327,7 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spaw
                 createManagedPythonToolDefinition(cwd, managementContext),
                 ...(delegationToolsEnabled && spawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))] : []),
                 ...(delegationToolsEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool)) : []),
+                ...(askUser === undefined ? [] : [createAskUserToolDefinition(askUser)]),
             ];
             const options = {
                 services,
@@ -177,11 +342,12 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spaw
         });
     };
 }
-export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions) {
+export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions, askUser) {
     return [
         ...managedAgentToolDefinitions(cwd),
         ...(delegationEnabled && spawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))] : []),
         ...(delegationEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool)) : []),
+        ...(askUser === undefined ? [] : [createAskUserToolDefinition(askUser)]),
     ];
 }
 function managedAgentToolDefinitions(cwd, options) {
@@ -221,8 +387,18 @@ export class PiSessionService {
     constructor(events, deps) {
         this.events = events;
         this.active = new Map();
+        this.runtimeBySession = new WeakMap();
         this.pendingSessionOpens = new Map();
-        this.activities = new Map();
+        this.activities = new SessionActivityCoordinator();
+        /** Runtime-identity gate held while Pi may await abandoned-branch summarization. */
+        this.treeNavigations = new WeakSet();
+        /** Counts async operations that may append an entry before they settle. */
+        this.sessionEntryMutationCounts = new WeakMap();
+        /** Runtime/session-identity reservations for operations that must not overlap tree navigation. */
+        this.treeExclusiveRuntimeOperationCounts = new WeakMap();
+        this.treeExclusiveSessionOperationCounts = new Map();
+        this.deferredSubsessionNotifications = new WeakMap();
+        this.deferredGeneratedSessionNames = new WeakMap();
         this.compactionPromptQueues = new Map();
         this.compactionDrainTimers = new Map();
         this.authLossWarnings = new Set();
@@ -234,12 +410,32 @@ export class PiSessionService {
         this.subsessionLinks = new Map();
         /** Parent id/file identities whose persisted links have already been loaded. */
         this.subsessionHydratedParents = new Set();
+        /** Session file path -> its parsed header. Headers are written once, so successful reads are cached. */
+        this.sessionHeaderCache = new Map();
         /**
          * Tracked subsession id -> whether a completion notification is armed.
          * Armed when the child starts working; firing on completion disarms it so a
          * child that works again (and stops again) notifies the parent each time.
          */
         this.subsessionNotifyArmed = new Map();
+        this.notificationGenerationBySession = new WeakMap();
+        this.pendingUnreadMutations = [];
+        this.unreadPublicationFlushRequested = false;
+        this.unreadPublicationStopped = false;
+        /**
+         * Read a session file header, memoized per path. Pi writes the header once at
+         * session creation, so a successful read stays valid for the process lifetime;
+         * failures are not cached so a session file that appears later is picked up.
+         */
+        this.readCachedSessionHeader = async (sessionFile) => {
+            const cached = this.sessionHeaderCache.get(sessionFile);
+            if (cached !== undefined)
+                return cached;
+            const header = await readSessionHeaderSummary(sessionFile);
+            if (header !== undefined)
+                this.sessionHeaderCache.set(sessionFile, header);
+            return header;
+        };
         this.archiveStore = deps.archiveStore ?? new SessionArchiveStore();
         this.pinStore = deps.pinStore ?? new SessionPinStore(join(deps.dataDir ?? piWebDataDir(), "session-pins.json"));
         this.agentDir = deps.agentDir ?? getAgentDir();
@@ -261,8 +457,15 @@ export class PiSessionService {
             ? resolveDefaultModelRuntime
             : () => Promise.resolve(managementModelRuntime);
         this.spawnTargets = deps.spawnTargets;
+        this.projectWorkspaces = deps.projectWorkspaces;
         this.logger = deps.logger ?? noopLogger;
         this.now = deps.now ?? (() => new Date());
+        this.notificationStore = deps.notificationStore ?? new SessionNotificationStore();
+        this.unreadStore = deps.unreadStore ?? new SessionUnreadStore();
+        this.pendingAskStore = deps.pendingAskStore ?? new PendingAskStore();
+        this.catalogRefreshStatus = deps.catalogRefreshStatus;
+        this.unreadPublicationRetryInitialMs = Math.max(0, deps.unreadPublicationRetryDelayMs ?? DEFAULT_UNREAD_PUBLICATION_RETRY_MS);
+        this.unreadPublicationRetryDelayMs = this.unreadPublicationRetryInitialMs;
         // Subsessions are a beta capability 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;
@@ -271,20 +474,33 @@ export class PiSessionService {
             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);
         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.publishActivity(session, "compacting", "active");
+                this.beginSessionEntryMutation(session, "compact the session");
+                this.publishActivity(session, "正在压缩上下文", "active");
                 this.publishStatus(session);
             },
             onCompactionEnd: (session, result, detail) => {
-                this.publishActivity(session, result === "success" ? "compaction complete" : "compaction failed", result === "success" ? "idle" : "error", detail);
+                this.endSessionEntryMutation(session);
+                this.publishActivity(session, result === "success" ? "上下文压缩完成" : "上下文压缩失败", result === "success" ? "idle" : "error", detail);
                 this.publishStatus(session);
             },
             reloadSession: (session) => this.reloadSessionRuntime(session),
+            getSessionTree: (session) => {
+                if (typeof session.sessionManager.getTree !== "function" || typeof session.navigateTree !== "function")
+                    return undefined;
+                return projectSessionTree(session.sessionManager.getTree(), session.sessionManager.getLeafId());
+            },
+            hasActiveWork: (session) => this.hasActiveWork(session),
+            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);
+            },
         }, { listSessionNames: (cwd) => this.listSessionNames(cwd) });
     }
     activeCount() {
@@ -316,22 +532,24 @@ export class PiSessionService {
                 skippedBusySessionIds.add(input.sessionId);
                 continue;
             }
-            await this.closeActive(input.sessionId);
+            await this.closeActive(input.sessionId, { kind: "clear", reason: "archive" });
             readyArchiveInputs.push(input);
         }
         await this.archiveStoreArchiveMany(readyArchiveInputs);
         archiveInputs.push(...readyArchiveInputs);
+        await this.forgetUnreadSessions(readyArchiveInputs);
         for (const record of plan.deleteRecords) {
             if (this.activeSessionHasWork(record.sessionId)) {
                 skippedBusySessionIds.add(record.sessionId);
                 continue;
             }
-            await this.closeActive(record.sessionId);
+            await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
             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);
         return summarizeSessionCleanupExecution({
             archiveInputs,
             deleteRecords,
@@ -341,12 +559,18 @@ export class PiSessionService {
         });
     }
     async dispose() {
+        this.unreadPublicationStopped = true;
+        this.clearUnreadPublicationRetry();
         clearInterval(this.heartbeat);
         this.clearCompactionDrainTimers();
         const pendingOpens = this.pendingSessionOpenPromises();
         if (pendingOpens.length > 0)
             await Promise.allSettled(pendingOpens);
         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.active.clear();
         this.pendingSessionOpens.clear();
         this.activities.clear();
@@ -357,12 +581,15 @@ export class PiSessionService {
         this.subsessionLinks.clear();
         this.subsessionHydratedParents.clear();
         this.subsessionNotifyArmed.clear();
+        this.sessionHeaderCache.clear();
+        this.notificationStore.clearAll("service-dispose");
         await Promise.all(activeSessions.map(async (active) => {
             active.unsubscribe();
             this.workspaceActivity?.removeSession(active.runtime.session.sessionId, active.runtime.session.sessionManager.getCwd(), active.eventScope);
             await active.runtime.session.abort();
             await active.runtime.dispose();
         }));
+        await this.publishUnreadMutations([]);
     }
     async list(cwd, managementContext) {
         return (await this.listWorkspaceSessions(cwd, managementContext)).sessions;
@@ -371,15 +598,26 @@ export class PiSessionService {
         const normalizedQuery = query.trim().toLocaleLowerCase();
         if (normalizedQuery === "")
             return this.list(cwd, managementContext);
-        const listing = await this.listWorkspaceSessions(cwd, managementContext);
-        const matches = await Promise.all(listing.sessions.map(async (session) => {
-            const entry = listing.entriesById.get(session.id);
-            const archived = listing.archivedById.get(session.id);
-            const archivedText = archived?.archivePath === undefined ? "" : await readArchivedSessionText(archived.archivePath);
-            const haystack = [session.id, session.name ?? "", session.firstMessage, entry?.allMessagesText ?? "", archivedText].join("\n").toLocaleLowerCase();
-            return haystack.includes(normalizedQuery) ? session : undefined;
-        }));
-        return matches.filter(isDefined);
+        const { sessions } = await this.searchCandidates(cwd, normalizedQuery, managementContext);
+        return sessions;
+    }
+    async searchContent(cwd, query, managementContext) {
+        const normalizedQuery = query.trim();
+        if (normalizedQuery === "")
+            return { results: [], matchCount: 0, truncated: false };
+        const maxMatches = 200;
+        const { listing, sessions } = await this.searchCandidates(cwd, normalizedQuery.toLocaleLowerCase(), managementContext);
+        const results = [];
+        let matchCount = 0;
+        for (const session of sessions) {
+            const remaining = maxMatches - results.reduce((count, result) => count + result.matches.length, 0);
+            const messages = this.searchableSessionHistory(session, listing, managementContext);
+            const view = searchSessionContent(messages, normalizedQuery, Math.max(1, remaining));
+            matchCount += view.matchCount;
+            if (remaining > 0 && view.matches.length > 0)
+                results.push({ session, matches: view.matches.slice(0, remaining) });
+        }
+        return { results, matchCount, truncated: matchCount > maxMatches };
     }
     async listPinned(cwd, managementContext) {
         const listing = await this.listWorkspaceSessions(cwd, managementContext);
@@ -408,18 +646,81 @@ export class PiSessionService {
             .filter((record) => record.cwd === cwd)
             .map((record) => this.ensureArchivedSessionMoved(record, sessionsById.get(record.sessionId))));
         const archivedById = new Map(archivedForCwd.map((record) => [record.sessionId, record]));
+        for (const record of archivedForCwd) {
+            this.publishNotificationMutations(this.notificationStore.clearSession(record.sessionId, "archive-reconcile"));
+        }
         const unarchivedSessions = sessions.filter((session) => !archivedById.has(session.id)).map(clientSessionFromListEntry);
-        this.workspaceActivity?.reconcileSessionActivity(cwd, this.reconcilableSessionIds(cwd, unarchivedSessions.map((session) => session.id), archivedById), eventScopeFromManagementContext(managementContext));
+        const reconcilableSessionIds = this.reconcilableSessionIds(cwd, unarchivedSessions.map((session) => session.id), archivedById);
+        this.workspaceActivity?.reconcileSessionActivity(cwd, reconcilableSessionIds, eventScopeFromManagementContext(managementContext));
+        if (managementContext === undefined) {
+            await this.publishUnreadMutations(this.unreadStore.reconcileCwd(canonicalizeStoredCwd(cwd), reconcilableSessionIds));
+        }
         const archivedSessions = archivedForCwd
             .sort(compareArchivedRecords)
             .map((record) => clientSessionFromArchivedRecord(record, sessionsById.get(record.sessionId)))
             .filter(isDefined);
         return {
-            sessions: [...unarchivedSessions, ...archivedSessions],
+            sessions: await this.withRelatedSessionsElsewhere([...unarchivedSessions, ...archivedSessions], cwd),
             entriesById: new Map(sessions.map((session) => [session.id, session])),
             archivedById,
         };
     }
+    /**
+     * Annotate a listing with the session relationships that cross workspace
+     * boundaries: where an out-of-listing parent lives, and how many children a
+     * listed session has in sibling workspaces.
+     *
+     * Both directions are best-effort. An unreadable parent header or a sibling
+     * workspace that cannot be listed leaves the session unannotated rather than
+     * failing the listing, and the browser falls back to its generic states.
+     */
+    async withRelatedSessionsElsewhere(sessions, cwd) {
+        const [parentLocations, childCounts] = await Promise.all([
+            locateOutOfListingParents(sessions, cwd, this.readCachedSessionHeader),
+            this.countChildrenInSiblingWorkspaces(sessions, cwd),
+        ]);
+        return sessions.map((session) => {
+            const parent = session.parentSessionPath === undefined ? undefined : parentLocations.get(session.parentSessionPath);
+            const childrenElsewhere = childCounts.get(session.path);
+            if (parent === undefined && childrenElsewhere === undefined)
+                return session;
+            const annotated = { ...session };
+            if (parent !== undefined) {
+                annotated.parentSessionId = parent.parentSessionId;
+                annotated.parentSessionCwd = parent.parentSessionCwd;
+            }
+            if (childrenElsewhere !== undefined)
+                annotated.childSessionsElsewhere = childrenElsewhere;
+            return annotated;
+        });
+    }
+    /**
+     * Count children of the listed sessions that live in other workspaces of the
+     * same project.
+     *
+     * Only sibling workspaces are scanned: agents may only spawn into workspaces
+     * of the spawning session's own project, so that bounds where a child can be.
+     * Listing is skipped entirely when no project-workspace locator is configured
+     * or the cwd belongs to no registered project.
+     */
+    async countChildrenInSiblingWorkspaces(sessions, cwd) {
+        if (this.projectWorkspaces === undefined || sessions.length === 0)
+            return new Map();
+        try {
+            const siblingCwds = await siblingWorkspaceCwds(this.projectWorkspaces, cwd);
+            if (siblingCwds.length === 0)
+                return new Map();
+            const listings = await Promise.all(siblingCwds.map(async (siblingCwd) => {
+                const entries = await this.sessionManager.list(siblingCwd);
+                return entries.flatMap((entry) => entry.parentSessionPath === undefined ? [] : [entry.parentSessionPath]);
+            }));
+            return countOutOfListingChildren(sessions, listings.flat());
+        }
+        catch (error) {
+            this.logger.info({ cwd, error: error instanceof Error ? error.message : String(error) }, "failed to count child sessions in sibling workspaces");
+            return new Map();
+        }
+    }
     async start(cwd, options = {}) {
         if (options.managementContext === undefined)
             await this.normalModelRuntimeForCwd(cwd);
@@ -430,6 +731,8 @@ export class PiSessionService {
             ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
             ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
+            ...(options.startupToken === undefined ? {} : { startupToken: options.startupToken }),
+            startupIntent: "create",
         });
         const { session } = active.runtime;
         const created = {
@@ -491,13 +794,100 @@ export class PiSessionService {
             ...(parentSessionFile === undefined ? {} : { parentSessionFile }),
             cwd: decision.cwd,
         };
-        this.registerVerifiedSubsession(link);
+        await this.registerVerifiedSubsession(link);
         this.persistSubsessionLink(link);
         this.persistSubsessionChildMarker(input.parentSessionId, created.id);
         await this.prompt(created.id, input.prompt);
         this.logger.info({ parentSessionId: input.parentSessionId, sessionId: created.id, cwd: decision.cwd, promptLength: input.prompt.length }, "spawn_subsession started a tracked child session");
         return { sessionId: created.id, cwd: decision.cwd };
     }
+    /**
+     * Register the question set an agent wants the user to answer as the session's
+     * open ask. Deliberately does not wait for the user: `ask_user` terminates the
+     * run and the submitted answers come back later as a follow-up message.
+     *
+     * Rejected question sets throw {@link PendingAskValidationError}, which the
+     * agent loop reports to the model as an error tool result.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await -- async so a rejected question set becomes a rejection rather than a synchronous throw from a promise-returning method.
+    async openAsk(input) {
+        const result = this.pendingAskStore.open(input);
+        // 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);
+        return result;
+    }
+    /**
+     * Record the user's answers to the session's open ask and hand them to the
+     * model. The answers travel as a system-authored custom message rather than a
+     * user message, so they are not attributed to the human in the transcript;
+     * they still wake an idle session (`triggerTurn`) and queue behind in-flight
+     * work (`deliverAs: "followUp"`), which is how the run that `ask_user`
+     * terminated continues.
+     */
+    async submitAsk(ref, askId, submission) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        // 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));
+    }
+    /**
+     * Close the open ask without answers. The model is still told, naming every
+     * question as unanswered: it was promised a follow-up message and would
+     * otherwise wait for one that never comes.
+     */
+    async cancelAsk(ref, askId) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        this.assertTreeNavigationInactive(session, "dismiss questions");
+        return this.closeAsk(session, this.pendingAskStore.cancel(session.sessionId, askId));
+    }
+    /**
+     * Publish and deliver a closed ask. A stale close is reported rather than
+     * thrown: losing the race against a supersede, another browser, or a session
+     * that went away is ordinary, and the returned status tells the browser what
+     * the session's open ask is now.
+     */
+    async closeAsk(session, result) {
+        if (result.status === "stale")
+            return { result: "stale", sessionStatus: this.statusFromSession(session) };
+        const { outcome } = result;
+        this.publishAskClosed(session.sessionId, outcome);
+        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.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 });
+    }
+    /**
+     * Void the session's open ask because the user sent a chat message instead of
+     * answering it. Every browser closes the card as cancelled, and the model is
+     * told — without being woken — so the notice rides into the turn the message
+     * itself triggers rather than becoming a turn of its own.
+     */
+    async voidOpenAskForUserMessage(session) {
+        const outcome = this.pendingAskStore.cancelOpen(session.sessionId);
+        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.publishStatus(session);
+    }
+    /**
+     * Publish status for a session known only by id, as the ask tools are: they
+     * run inside the session's own runtime, so the active entry is the session.
+     */
+    publishStatusForSessionId(sessionId) {
+        const session = this.active.get(sessionId)?.runtime.session;
+        if (session !== undefined)
+            this.publishStatus(session);
+    }
     /** Summaries of the tracked subsessions spawned by `parentSessionId`. */
     async listSubsessions(parentSessionId, parentSessionFile) {
         const parentFile = nonEmptyString(parentSessionFile);
@@ -560,7 +950,7 @@ export class PiSessionService {
             return undefined;
         return sessionFileMatches(session, link.childSessionFile) ? link : undefined;
     }
-    registerVerifiedSubsession(link) {
+    async registerVerifiedSubsession(link) {
         const { childSessionId, parentSessionId } = link;
         const previousParentId = this.subsessionParents.get(childSessionId);
         if (previousParentId !== undefined && previousParentId !== parentSessionId) {
@@ -576,6 +966,24 @@ export class PiSessionService {
         this.subsessionLinks.set(childSessionId, link);
         if (!this.subsessionNotifyArmed.has(childSessionId))
             this.subsessionNotifyArmed.set(childSessionId, false);
+        const cwd = this.cwdForVerifiedSubsession(link);
+        await this.publishUnreadMutations(this.unreadStore.excludeSession(childSessionId, cwd));
+    }
+    cwdForVerifiedSubsession(link) {
+        const activeCwd = this.activeChildForSubsessionLink(link)?.runtime.session.sessionManager.getCwd();
+        const linkedCwd = nonEmptyString(activeCwd) ?? nonEmptyString(link.cwd);
+        if (linkedCwd !== undefined)
+            return canonicalizeStoredCwd(linkedCwd);
+        const childSessionFile = link.childSessionFile;
+        if (childSessionFile !== undefined) {
+            try {
+                return canonicalizeStoredCwd(this.sessionManager.open(childSessionFile).getCwd());
+            }
+            catch (error) {
+                throw new Error("Could not resolve cwd for verified tracked sub-session", { cause: error });
+            }
+        }
+        throw new Error("Could not resolve cwd for verified tracked sub-session");
     }
     unregisterSubsession(childSessionId) {
         const parentSessionId = this.subsessionParents.get(childSessionId);
@@ -622,40 +1030,44 @@ export class PiSessionService {
         const activeParent = this.activeForSessionId(parentSessionId);
         if (activeParent !== undefined && (parentSessionFile === undefined || activeSessionFileMatches(activeParent, parentSessionFile))) {
             const activeParentFile = nonEmptyString(activeParent.runtime.session.sessionFile);
-            await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile);
-            this.subsessionHydratedParents.add(hydrationKey);
+            const complete = await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile);
+            if (complete)
+                this.subsessionHydratedParents.add(hydrationKey);
             return;
         }
         if (parentSessionFile === undefined)
             return;
-        if ((await readSessionHeaderSummary(parentSessionFile))?.id !== parentSessionId) {
-            this.subsessionHydratedParents.add(hydrationKey);
+        if ((await readSessionHeaderSummary(parentSessionFile))?.id !== parentSessionId)
             return;
-        }
         let parentManager;
         try {
             parentManager = this.sessionManager.open(parentSessionFile);
         }
         catch {
-            this.subsessionHydratedParents.add(hydrationKey);
             return;
         }
-        await this.registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile);
-        this.subsessionHydratedParents.add(hydrationKey);
+        const complete = await this.registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile);
+        if (complete)
+            this.subsessionHydratedParents.add(hydrationKey);
     }
     async registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile) {
         // Parent custom links are the authoritative recovery record: verify the
-        // exact live child file/header before tracking.
+        // exact live child file/header before tracking. Do not negatively cache a
+        // scan while a candidate child is temporarily unavailable.
         const entries = parentManager.getEntries?.() ?? parentManager.getBranch();
+        let complete = true;
         for (const entry of entries) {
             const link = parsePersistedParentSubsessionLink(entry);
-            if (link === undefined)
+            if (link?.spawnedBySessionId !== parentSessionId)
                 continue;
             const verified = await this.verifiedSubsessionLinkFromParentLink(parentSessionId, parentSessionFile, link);
-            if (verified === undefined)
+            if (verified === undefined) {
+                complete = false;
                 continue;
-            this.registerVerifiedSubsession(verified);
+            }
+            await this.registerVerifiedSubsession(verified);
         }
+        return complete;
     }
     async verifiedSubsessionLinkFromParentLink(parentSessionId, parentSessionFile, link) {
         if (parentSessionFile === undefined)
@@ -674,7 +1086,7 @@ export class PiSessionService {
         const link = await this.verifiedSubsessionLinkFromOpenedChild(session);
         if (link === undefined)
             return;
-        this.registerVerifiedSubsession(link);
+        await this.registerVerifiedSubsession(link);
     }
     verifiedSubsessionLinkFromOpenedChild(session) {
         return verifiedTrackedSubsessionLink(this.sessionManager, {
@@ -749,12 +1161,12 @@ export class PiSessionService {
         this.subsessionNotifyArmed.set(childId, false);
         const status = this.activityForSession(session)?.phase === "error" ? "error" : "idle";
         const finalText = finalAssistantText(historyMessages(session));
-        const preview = finalText === "" ? "(no output)" : truncateForNotification(finalText);
+        const outputSection = formatSubsessionNotificationOutput(childId, finalText);
         const workingIds = this.workingSubsessionIds(link.parentSessionId);
         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--- SUBSESSION OUTPUT: ${childId} ---\n${preview}`;
+        const text = `Subsession ${childId} stopped working (${status}).\n${next}\n\n${outputSection}`;
         void this.notifyParentOfSubsession(link.parentSessionId, childId, text);
     }
     async getOrOpenParentForSubsession(parentSessionId, childSessionId) {
@@ -783,11 +1195,16 @@ export class PiSessionService {
     async notifyParentOfSubsession(parentId, childId, text) {
         try {
             const session = await this.getOrOpenParentForSubsession(parentId, childId);
-            await session.sendCustomMessage({ customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE, content: text, display: true, details: { sessionId: childId } }, { triggerTurn: true, deliverAs: "followUp" });
-            this.publishStatus(session);
+            if (this.treeNavigations.has(session)) {
+                const pending = this.deferredSubsessionNotifications.get(session) ?? [];
+                pending.push({ parentId, childId, text });
+                this.deferredSubsessionNotifications.set(session, pending);
+                return;
+            }
+            await this.deliverSubsessionNotification(session, { parentId, childId, text });
         }
         catch (error) {
-            this.logger.info({ parentSessionId: parentId, sessionId: childId, error: error instanceof Error ? error.message : String(error) }, "failed to notify parent of subsession completion");
+            this.logSubsessionNotificationFailure(parentId, childId, error);
         }
     }
     async messages(ref, page, managementContext) {
@@ -797,9 +1214,38 @@ export class PiSessionService {
     async status(ref, managementContext) {
         return this.statusFromSession(await this.getOrOpen(ref, managementContext));
     }
+    async searchCandidates(cwd, normalizedQuery, managementContext) {
+        const listing = await this.listWorkspaceSessions(cwd, managementContext);
+        const matches = await Promise.all(listing.sessions.map(async (session) => {
+            const entry = listing.entriesById.get(session.id);
+            const archived = listing.archivedById.get(session.id);
+            const archivedText = archived?.archivePath === undefined ? "" : await readArchivedSessionText(archived.archivePath);
+            const haystack = [session.id, session.name ?? "", session.firstMessage, entry?.allMessagesText ?? "", archivedText].join("\n").toLocaleLowerCase();
+            return haystack.includes(normalizedQuery) ? session : undefined;
+        }));
+        return { listing, sessions: matches.filter(isDefined) };
+    }
+    searchableSessionHistory(session, listing, managementContext) {
+        const eventScope = eventScopeFromManagementContext(managementContext);
+        const active = this.activeForSessionIdAndScope(session.id, eventScope);
+        if (active !== undefined && cwdPathsEqual(active.runtime.cwd, session.cwd))
+            return historyMessages(active.runtime.session);
+        const path = listing.archivedById.get(session.id)?.archivePath ?? listing.entriesById.get(session.id)?.path;
+        return path === undefined ? [] : historyMessagesFromManager(this.sessionManager.open(path));
+    }
+    async streamSnapshot(ref, managementContext) {
+        const session = await this.getOrOpen(ref, managementContext);
+        const eventScope = this.eventScopeForSession(session);
+        const seq = this.events.currentSeq(session.sessionId, eventScope);
+        const streamingMessage = session.state.streamingMessage;
+        const partial = streamingMessage === undefined || streamingMessage === null
+            ? null
+            : projectBrowserMessage(streamingMessage);
+        return { seq, partial };
+    }
     async availableModels(ref, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
-        await session.modelRuntime.reloadConfig();
+        await session.modelRuntime.refresh();
         const models = session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
             : await session.modelRuntime.getAvailable();
@@ -808,7 +1254,7 @@ export class PiSessionService {
     async setModel(ref, provider, modelId, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        await session.modelRuntime.reloadConfig();
+        await session.modelRuntime.refresh();
         const candidates = session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
             : await session.modelRuntime.getAvailable();
@@ -816,18 +1262,18 @@ export class PiSessionService {
             ?? session.modelRuntime.getModel(provider, modelId);
         if (model === undefined)
             throw new Error(`未找到模型：${provider}/${modelId}`);
-        await session.setModel(model);
-        this.publishActivity(session, `model: ${model.id}`, "idle", model.provider);
+        await this.runSessionEntryMutation(session, "change models", () => session.setModel(model));
+        this.publishActivity(session, `模型：${model.id}`, "idle", model.provider);
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
     async cycleModel(ref, direction, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        const result = await session.cycleModel(direction);
+        const result = await this.runSessionEntryMutation(session, "change models", () => session.cycleModel(direction));
         if (result === undefined)
             throw new Error(session.scopedModels.length > 0 ? "作用域内只有一个模型" : "只有一个可用模型");
-        this.publishActivity(session, `model: ${result.model.id}`, "idle", result.model.provider);
+        this.publishActivity(session, `模型：${result.model.id}`, "idle", result.model.provider);
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
@@ -838,24 +1284,28 @@ 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");
         // 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}`);
-        session.setThinkingLevel(match);
-        this.publishActivity(session, `thinking: ${session.thinkingLevel}`, "idle");
+        await this.runSessionEntryMutation(session, "change the thinking level", () => {
+            session.setThinkingLevel(match);
+            return Promise.resolve();
+        });
+        this.publishActivity(session, `思考级别：${session.thinkingLevel}`, "idle");
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
     async cycleThinkingLevel(ref, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        const level = session.cycleThinkingLevel();
+        const level = await this.runSessionEntryMutation(session, "change the thinking level", () => Promise.resolve(session.cycleThinkingLevel()));
         if (level === undefined)
             throw new Error("当前模型不支持思考");
-        this.publishActivity(session, `thinking: ${level}`, "idle");
+        this.publishActivity(session, `思考级别：${level}`, "idle");
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
@@ -885,14 +1335,20 @@ 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.maybeGenerateSessionName(session, promptText);
         const isQueued = session.isStreaming || session.isCompacting;
         const behavior = isQueued ? requestedBehavior ?? "followUp" : undefined;
         if (isQueued && images.length === 0 && this.hasQueuedMessageText(session, promptText)) {
-            this.publishActivity(session, "duplicate queued message ignored", "active");
+            this.publishActivity(session, "已忽略重复的排队消息", "active");
             this.publishStatus(session);
             return;
         }
+        // A chat message answers the session's open ask in the user's own words, so
+        // the form is void: keeping it open would invite answers to questions the
+        // conversation has already moved past. Ignored duplicates skip this on
+        // purpose: they must not void an ask posted after the queued original.
+        await this.voidOpenAskForUserMessage(session);
         if (session.isCompacting) {
             this.enqueuePromptDuringCompaction(session, promptText, behavior ?? "followUp", images, echoUserMessage);
             return;
@@ -900,14 +1356,14 @@ export class PiSessionService {
         void this.submitPrompt(session, promptText, behavior, images, echoUserMessage);
     }
     submitPrompt(session, text, behavior, images = [], echoUserMessage = true) {
-        this.publishActivity(session, behavior === "steer" ? "steering queued" : behavior === "followUp" ? "message queued" : "prompt accepted", "active");
+        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 = session.prompt(text, promptOptions).catch((error) => {
+        const promptPromise = this.runSessionEntryMutation(session, "send a prompt", () => session.prompt(text, promptOptions)).catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
-            this.publishActivity(session, "error", "error", message);
+            this.publishActivity(session, "发生错误", "error", message);
             this.events.publish(session.sessionId, { type: "session.error", message }, eventScope);
         });
         void promptPromise;
@@ -917,7 +1373,7 @@ export class PiSessionService {
         const queue = this.compactionPromptQueues.get(session.sessionId) ?? [];
         queue.push({ kind, text, ...(images.length > 0 ? { images } : {}), ...(echoUserMessage ? {} : { echoUserMessage: false }) });
         this.compactionPromptQueues.set(session.sessionId, queue);
-        this.publishActivity(session, "message queued during compaction", "active");
+        this.publishActivity(session, "压缩期间消息已排队", "active");
         this.publishStatus(session);
     }
     async saveAttachments(ref, attachments, folder, managementContext) {
@@ -932,6 +1388,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");
         const isExcluded = text.startsWith("!!");
         const command = (isExcluded ? text.slice(2) : text.slice(1)).trim();
         if (!command)
@@ -939,13 +1396,13 @@ export class PiSessionService {
         if (session.isBashRunning)
             throw new Error("已有 bash 命令正在运行");
         const eventScope = active.eventScope;
-        this.publishActivity(session, "running bash", "active", command);
+        this.publishActivity(session, "正在运行命令", "active", command);
         this.events.publish(session.sessionId, { type: "shell.start", command, excludeFromContext: isExcluded }, eventScope);
-        void session.executeBash(command, (chunk) => {
+        void this.runSessionEntryMutation(session, "run a shell command", () => session.executeBash(command, (chunk) => {
             this.events.publish(session.sessionId, { type: "shell.chunk", chunk }, eventScope);
-            this.publishActivity(session, "running bash", "active", command);
+            this.publishActivity(session, "正在运行命令", "active", command);
             this.publishStatus(session);
-        }, { excludeFromContext: isExcluded }).then((result) => {
+        }, { excludeFromContext: isExcluded })).then((result) => {
             this.events.publish(session.sessionId, {
                 type: "shell.end",
                 output: result.output,
@@ -954,13 +1411,13 @@ export class PiSessionService {
                 truncated: result.truncated,
                 ...(result.fullOutputPath === undefined ? {} : { fullOutputPath: result.fullOutputPath }),
             }, eventScope);
-            this.publishActivity(session, "bash complete", result.exitCode === 0 ? "idle" : "error", command);
+            this.publishActivity(session, "命令执行完成", result.exitCode === 0 ? "idle" : "error", command);
             this.publishStatus(session);
         }).catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             this.events.publish(session.sessionId, { type: "shell.end", output: message, isError: true }, eventScope);
             this.events.publish(session.sessionId, { type: "session.error", message }, eventScope);
-            this.publishActivity(session, "bash failed", "error", message);
+            this.publishActivity(session, "命令执行失败", "error", message);
             this.publishStatus(session);
         });
     }
@@ -974,31 +1431,67 @@ export class PiSessionService {
         const active = await this.getActive(ref, managementContext);
         return this.commandService.respond(active.runtime.session.sessionId, requestId, value, active.eventScope);
     }
-    async reloadSessionRuntime(session) {
+    async navigateTree(ref, request, managementContext) {
+        if (request.targetId.trim() === "")
+            throw new Error("Session tree target is required");
+        if (this.isTreeExclusiveSessionIdentityActive(sessionIdFromLookup(ref))) {
+            throw new Error("Stop current session activity before navigating the session tree");
+        }
+        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");
         if (this.hasActiveWork(session))
-            throw new Error("Stop current session activity before reloading");
-        this.publishActivity(session, "reloading resources", "active");
+            throw new Error("Stop current session activity before navigating the session tree");
+        // 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 {
-            await session.reload();
-            this.publishActivity(session, "resources reloaded", "idle");
+            if (session.sessionManager.getLeafId() !== request.expectedLeafId) {
+                throw new Error("The session changed since /tree was opened. Reopen /tree and try again.");
+            }
+            this.publishActivity(session, options.summarize ? "正在汇总分支" : "正在切换会话树", "active");
             this.publishStatus(session);
+            const result = await session.navigateTree(request.targetId, options);
+            if (result.cancelled) {
+                if (this.isCurrentActiveSession(session)) {
+                    this.publishActivity(session, result.aborted === true ? "分支汇总已终止" : "会话树切换已取消", "idle");
+                }
+                return { cancelled: true, ...(result.aborted === undefined ? {} : { aborted: result.aborted }) };
+            }
+            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, "reload failed", "error", message);
+            this.publishActivity(session, "重新加载失败", "error", message);
             this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
             this.publishStatus(session);
             throw error;
         }
+        finally {
+            this.treeNavigations.delete(session);
+            if (this.isCurrentActiveSession(session)) {
+                this.flushDeferredTreeNavigationWork(session);
+                this.publishStatus(session);
+            }
+            else {
+                this.deferredGeneratedSessionNames.delete(session);
+                this.deferredSubsessionNotifications.delete(session);
+            }
+        }
     }
     async archive(ref, managementContext) {
         const active = await this.getActive(ref, managementContext);
         const session = active.runtime.session;
-        if (this.hasActiveWork(session))
-            throw new Error("归档前请先停止当前会话活动");
-        const archiveInput = await this.archiveInputForSession(session);
-        await this.closeActiveSession(active);
-        await this.archiveStore.archive(archiveInput);
+        await this.runTreeExclusiveOperation([{ sessionId: session.sessionId, session, runtime: active.runtime }], "归档前请先停止当前会话活动", async () => {
+            const archiveInput = await this.archiveInputForSession(session);
+            await this.closeActiveSession(active);
+            await this.archiveStore.archive(archiveInput);
+            await this.forgetUnreadSessions([archiveInput]);
+        });
     }
     async archiveMany(refs, managementContext) {
         const uniqueRefs = uniqueBulkSessionRefs(refs);
@@ -1008,11 +1501,14 @@ export class PiSessionService {
         ]);
         const failures = [];
         const alreadyArchivedSessionIds = [];
+        const unreadArchivedIdentities = [];
         const planItems = [];
         for (const ref of uniqueRefs) {
             const archived = findArchivedRecordForBulkRef(archivedRecords, ref);
             if (archived !== undefined) {
+                this.publishNotificationMutations(this.notificationStore.clearSession(archived.sessionId, "archive"));
                 alreadyArchivedSessionIds.push(archived.sessionId);
+                unreadArchivedIdentities.push(archived);
                 continue;
             }
             const active = this.activeForLookup(bulkRefToLookup(ref), managementContext);
@@ -1037,28 +1533,44 @@ export class PiSessionService {
                 failures.push({ sessionId: resolvedSessionId, error: errorMessage(error) });
             }
         }
-        const readyInputs = [];
+        const readyPlanItems = [];
         for (const item of planItems) {
+            const active = item.active ?? this.activeForLookup(bulkRefToLookup({ id: item.input.sessionId, cwd: item.input.cwd }), managementContext);
+            if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
+                failures.push({ sessionId: item.input.sessionId, error: "Stop current session activity before archiving" });
+                continue;
+            }
+            readyPlanItems.push(active === undefined ? item : { ...item, active });
+        }
+        const readyInputs = [];
+        const archivedSessionIds = [...alreadyArchivedSessionIds];
+        await this.runTreeExclusiveOperation(readyPlanItems.map(({ input, active }) => ({
+            sessionId: input.sessionId,
+            ...(active === undefined ? {} : { session: active.runtime.session, runtime: active.runtime }),
+        })), "Stop current session activity before archiving", async () => {
+            for (const item of readyPlanItems) {
+                try {
+                    if (item.active !== undefined)
+                        await this.closeActiveSession(item.active);
+                    else
+                        await this.closeActiveInScope(item.input.sessionId, eventScopeFromManagementContext(managementContext));
+                    readyInputs.push(item.input);
+                }
+                catch (error) {
+                    failures.push({ sessionId: item.input.sessionId, error: errorMessage(error) });
+                }
+            }
             try {
-                if (item.active !== undefined)
-                    await this.closeActiveSession(item.active);
-                else
-                    await this.closeActiveInScope(item.input.sessionId, eventScopeFromManagementContext(managementContext));
-                readyInputs.push(item.input);
+                const archived = await this.archiveStoreArchiveMany(readyInputs);
+                archivedSessionIds.push(...archived.map((record) => record.sessionId));
+                unreadArchivedIdentities.push(...archived);
             }
             catch (error) {
-                failures.push({ sessionId: item.input.sessionId, error: errorMessage(error) });
+                for (const input of readyInputs)
+                    failures.push({ sessionId: input.sessionId, error: errorMessage(error) });
             }
-        }
-        const archivedSessionIds = [...alreadyArchivedSessionIds];
-        try {
-            const archived = await this.archiveStoreArchiveMany(readyInputs);
-            archivedSessionIds.push(...archived.map((record) => record.sessionId));
-        }
-        catch (error) {
-            for (const input of readyInputs)
-                failures.push({ sessionId: input.sessionId, error: errorMessage(error) });
-        }
+        });
+        await this.forgetUnreadSessions(unreadArchivedIdentities);
         return {
             archived: true,
             archivedSessionIds: uniqueStrings(archivedSessionIds),
@@ -1075,9 +1587,19 @@ export class PiSessionService {
         if (busy !== undefined)
             throw new Error(`归档 ${sessionDisplayName(busy)} 前请先停止当前会话活动`);
         const archiveInputs = plan.unarchivedTargets.map((target) => archiveInputFromCandidate(target));
-        for (const input of archiveInputs)
-            await this.closeActiveInScope(input.sessionId, eventScopeFromManagementContext(managementContext));
-        await this.archiveStoreArchiveMany(archiveInputs);
+        await this.runTreeExclusiveOperation(plan.unarchivedTargets.map((target) => ({
+            sessionId: target.id,
+            ...(target.activeSession === undefined ? {} : { session: target.activeSession }),
+        })), `归档 ${sessionDisplayName(session)} 前请先停止当前会话活动`, async () => {
+            for (const target of plan.targets) {
+                if (target.archived)
+                    this.publishNotificationMutations(this.notificationStore.clearSession(target.id, "archive"));
+            }
+            for (const input of archiveInputs)
+                await this.closeActiveInScope(input.sessionId, eventScopeFromManagementContext(managementContext));
+            await this.archiveStoreArchiveMany(archiveInputs);
+        });
+        await this.forgetUnreadSessions(plan.targets.map((target) => ({ sessionId: target.id, cwd: target.cwd })));
         return {
             archived: true,
             sessionIds: archiveInputs.map((input) => input.sessionId),
@@ -1091,6 +1613,7 @@ export class PiSessionService {
             throw new Error("未找到会话");
         await this.closeActiveInScope(archived.sessionId, eventScopeFromManagementContext(managementContext));
         await this.archiveStore.restore(archived.sessionId);
+        await this.forgetUnreadSessions([archived]);
     }
     async deleteArchived(ref, managementContext) {
         const record = await this.getArchived(ref);
@@ -1102,6 +1625,7 @@ export class PiSessionService {
         if (record.archivePath === undefined)
             await this.ensureArchivedRecordMoved(record);
         await this.archiveStore.deleteArchived(record.sessionId);
+        await this.forgetUnreadSessions([record]);
     }
     async deleteArchivedMany(refs, managementContext) {
         if (this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
@@ -1147,6 +1671,8 @@ export class PiSessionService {
             for (const sessionId of deleteIds)
                 failures.push({ sessionId, error: errorMessage(error) });
         }
+        const deletedIdSet = new Set(deletedSessionIds);
+        await this.forgetUnreadSessions(readyRecords.filter((record) => deletedIdSet.has(record.sessionId)));
         return {
             deleted: true,
             deletedSessionIds,
@@ -1160,9 +1686,35 @@ export class PiSessionService {
         const session = active.runtime.session;
         if (this.hasActiveWork(session))
             throw new Error("重新加载前请先停止当前会话活动");
-        await this.closeActiveSession(active);
-        const reopened = await this.getActive(ref, managementContext);
-        this.publishStatus(reopened.runtime.session);
+        const sessionFile = session.sessionFile;
+        if (sessionFile === undefined || sessionFile === "")
+            throw new Error("会话尚未持久化");
+        const reopenedSession = await this.runTreeExclusiveOperation([{ sessionId: session.sessionId, session, runtime: active.runtime }], "重新加载前请先停止当前会话活动", async () => {
+            const priorGeneration = this.notificationGenerationBySession.get(session);
+            const { sessionId, cwd } = notificationIdentityForSession(session);
+            let candidateGeneration;
+            try {
+                await this.closeActiveSession(active, priorGeneration === undefined ? CLEAR_RUNTIME_NOTIFICATIONS : DEFER_RUNTIME_NOTIFICATIONS);
+                candidateGeneration = priorGeneration === undefined
+                    ? undefined
+                    : this.notificationStore.beginReplacement(priorGeneration, { sessionId, cwd });
+                const reopened = await this.openExistingSession(sessionId, cwd, () => this.sessionManager.open(sessionFile), {
+                    ...(managementContext === undefined ? {} : { managementContext }),
+                    ...(candidateGeneration === undefined ? {} : { notificationGeneration: candidateGeneration }),
+                });
+                if (candidateGeneration !== undefined) {
+                    this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
+                }
+                return reopened.runtime.session;
+            }
+            catch (error) {
+                if (candidateGeneration !== undefined) {
+                    this.publishNotificationMutations(this.notificationStore.abortReplacement(candidateGeneration));
+                }
+                throw error;
+            }
+        });
+        this.publishStatus(reopenedSession);
     }
     async detachParent(ref, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
@@ -1172,6 +1724,7 @@ export class PiSessionService {
         await clearParentSession(sessionFile);
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
+        await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }]);
     }
     async abort(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
@@ -1180,9 +1733,18 @@ export class PiSessionService {
         const sessionId = active.runtime.session.sessionId;
         this.clearCompactionPromptQueue(sessionId);
         clearSessionQueue(active.runtime.session);
-        await active.runtime.session.abort();
-        this.publishActivity(active.runtime.session, "stopped", "idle");
-        this.publishStatus(active.runtime.session);
+        try {
+            await this.abortSessionOperations(active.runtime.session);
+            this.publishActivity(active.runtime.session, "已停止", "idle");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.publishActivity(active.runtime.session, "停止失败", "error", message);
+            throw error;
+        }
+        finally {
+            this.publishStatus(active.runtime.session);
+        }
     }
     async clearQueue(ref, managementContext) {
         await this.assertWritable(ref);
@@ -1192,13 +1754,15 @@ export class PiSessionService {
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
-    stop(ref, managementContext) {
+    async stop(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
-        if (active === undefined)
+        if (active !== undefined) {
+            await this.closeActiveSession(active);
             return;
-        void this.closeActiveSession(active).catch(() => {
-            // Best-effort shutdown; callers that need errors await closeActive directly.
-        });
+        }
+        if (isPiSessionRef(ref)) {
+            this.publishNotificationMutations(this.notificationStore.clearSessionIdentity(ref.id, canonicalizeStoredCwd(ref.cwd), "runtime-close"));
+        }
     }
     async bulkSessionLookupContext(refs) {
         const cwdSet = new Set();
@@ -1386,20 +1950,37 @@ export class PiSessionService {
         }
         return [...names];
     }
-    async closeActive(sessionId) {
+    async closeActive(sessionId, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS) {
         const pendingOpens = this.pendingSessionOpenPromises(sessionId);
         if (pendingOpens.length > 0)
             await Promise.allSettled(pendingOpens);
         const activeSessions = this.activeSessionsForId(sessionId);
-        await Promise.all(activeSessions.map((active) => this.closeActiveSession(active)));
+        if (activeSessions.length === 0 && notificationPolicy.kind === "clear") {
+            this.publishNotificationMutations(this.notificationStore.clearSession(sessionId, notificationPolicy.reason));
+            return;
+        }
+        await Promise.all(activeSessions.map((active) => this.closeActiveSession(active, notificationPolicy)));
     }
-    async closeActiveInScope(sessionId, eventScope) {
+    async closeActiveInScope(sessionId, eventScope, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS) {
         const active = this.activeForSessionIdAndScope(sessionId, eventScope);
-        if (active !== undefined)
-            await this.closeActiveSession(active);
+        if (active !== undefined) {
+            await this.closeActiveSession(active, notificationPolicy);
+        }
+        else if (notificationPolicy.kind === "clear") {
+            this.publishNotificationMutations(this.notificationStore.clearSession(sessionId, notificationPolicy.reason));
+        }
     }
-    async closeActiveSession(active) {
+    async closeActiveSession(active, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS) {
         const sessionId = active.runtime.session.sessionId;
+        if (notificationPolicy.kind === "clear") {
+            const generation = this.notificationGenerationBySession.get(active.runtime.session);
+            const mutations = generation === undefined
+                ? this.notificationStore.clearSession(sessionId, notificationPolicy.reason)
+                : this.notificationStore.clearGeneration(generation, notificationPolicy.reason);
+            this.publishNotificationMutations(mutations);
+        }
+        this.forgetUnreadActivity(active.runtime.session);
+        this.pendingAskStore.forgetSession(sessionId);
         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);
@@ -1412,13 +1993,36 @@ export class PiSessionService {
             this.subsessionNotifyArmed.delete(sessionId);
         clearSessionQueue(active.runtime.session);
         active.unsubscribe();
+        active.runtime.setRebindSession(undefined);
         try {
-            await active.runtime.session.abort();
+            await this.abortSessionOperations(active.runtime.session);
         }
         finally {
             await active.runtime.dispose();
         }
     }
+    async abortSessionOperations(session) {
+        let branchSummaryAbortFailed = false;
+        let branchSummaryAbortError;
+        try {
+            session.abortBranchSummary?.();
+        }
+        catch (error) {
+            branchSummaryAbortFailed = true;
+            branchSummaryAbortError = error;
+        }
+        try {
+            await session.abort();
+        }
+        catch (abortError) {
+            if (branchSummaryAbortFailed) {
+                throw new AggregateError([branchSummaryAbortError, abortError], "Failed to abort session operations", { cause: abortError });
+            }
+            throw abortError;
+        }
+        if (branchSummaryAbortFailed)
+            throw branchSummaryAbortError;
+    }
     async assertWritable(ref) {
         if (await this.getArchived(ref) !== undefined)
             throw new Error("已归档会话为只读。请恢复会话后继续。");
@@ -1433,7 +2037,7 @@ export class PiSessionService {
         const archived = await this.getArchived(ref);
         if (archived?.archivePath !== undefined) {
             const archivePath = archived.archivePath;
-            return this.openPending(archived.sessionId, archived.cwd, managementContext, () => this.sessionManager.open(archivePath));
+            return this.openPending(archived.sessionId, archived.cwd, managementContext, () => this.sessionManager.open(archivePath), { notifications: "disabled" });
         }
         const match = isPiSessionRef(ref)
             ? (await this.sessionManager.list(ref.cwd)).find((s) => s.id === ref.id || s.id.startsWith(ref.id))
@@ -1442,14 +2046,17 @@ export class PiSessionService {
             throw new Error("未找到会话");
         return this.openPending(match.id, match.cwd, managementContext, () => this.sessionManager.open(match.path));
     }
-    openPending(sessionId, cwd, managementContext, openSessionManager) {
+    openPending(sessionId, cwd, managementContext, openSessionManager, options = {}) {
         const key = JSON.stringify([canonicalizeStoredCwd(cwd), sessionId, managementContextKey(managementContext)]);
         const existing = this.pendingSessionOpens.get(key);
         if (existing !== undefined)
             return existing.promise;
         const pending = {
             sessionId,
-            promise: this.create(openSessionManager(), cwd, managementContext === undefined ? {} : { managementContext }),
+            promise: this.create(openSessionManager(), cwd, {
+                ...options,
+                ...(managementContext === undefined ? {} : { managementContext }),
+            }),
         };
         pending.promise = pending.promise.finally(() => {
             if (this.pendingSessionOpens.get(key) === pending)
@@ -1521,66 +2128,29 @@ export class PiSessionService {
         return [...new Set(this.active.values())].filter((active) => active.runtime.session.sessionId === sessionId);
     }
     async create(sessionManager, cwd, options = {}) {
-        const delegationToolsEnabled = options.creationProvenance !== "tracked-subsession"
-            && await sessionAllowsDelegationTools(sessionManager, this.sessionManager);
-        const runtime = await this.createAgentRuntime(this.createRuntime, {
-            cwd,
-            agentDir: this.agentDir,
-            sessionManager,
-            delegationToolsEnabled,
-            ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
-            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
-        });
-        const active = { runtime, unsubscribe: noop, managementContextKey: managementContextKey(options.managementContext), eventScope: eventScopeFromManagementContext(options.managementContext) };
+        const startup = this.startupProgress(sessionManager, options.startupIntent ?? "open", options.startupToken, eventScopeFromManagementContext(options.managementContext));
         try {
-            await this.bindSessionExtensions(runtime.session);
-            this.bindRuntime(active);
-            runtime.setRebindSession(async (session) => {
-                await this.bindSessionExtensions(session);
-                this.bindRuntime(active);
-                await this.recoverSubsessionTrackingForOpenedSession(session);
-            });
-            this.active.set(activeSessionKey(runtime.session.sessionId, active.eventScope), active);
-            await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
-            this.publishStatus(runtime.session);
-            return active;
+            return await this.createSessionRuntime(sessionManager, cwd, options, startup);
         }
-        catch (error) {
-            active.unsubscribe();
-            let removedActive = false;
-            for (const [sessionKey, candidate] of this.active.entries()) {
-                if (candidate !== active)
-                    continue;
-                this.active.delete(sessionKey);
-                this.activities.delete(sessionKey);
-                removedActive = true;
-            }
-            this.clearAuthLossWarningsForSession(runtime.session.sessionId);
-            this.clearCompactionPromptQueue(runtime.session.sessionId);
-            if (removedActive) {
-                this.workspaceActivity?.removeSession(runtime.session.sessionId, runtime.session.sessionManager.getCwd(), active.eventScope);
-            }
-            try {
-                await runtime.session.abort();
-            }
-            finally {
-                await runtime.dispose();
-            }
-            throw error;
+        finally {
+            startup.end();
         }
     }
-    async bindSessionExtensions(session) {
+    async bindSessionExtensions(session, generation) {
+        const uiContext = this.sessionUiContext(session, generation);
         await session.bindExtensions({
+            uiContext,
+            mode: "rpc",
             onError: (error) => {
                 const message = `${error.extensionPath}: ${error.error}`;
-                this.publishActivity(session, "extension error", "error", message);
+                this.publishActivity(session, "扩展错误", "error", message);
                 this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
             },
         });
     }
-    bindRuntime(active) {
+    bindRuntime(active, session = active.runtime.session) {
+        this.runtimeBySession.set(session, active.runtime);
         active.unsubscribe();
-        const { session } = active.runtime;
         for (const [sessionId, candidate] of this.active.entries()) {
             if (candidate === active) {
                 this.active.delete(sessionId);
@@ -1671,7 +2241,7 @@ export class PiSessionService {
         const model = session.model;
         if (model === undefined)
             return;
-        void generateShortSessionName(session.agent.streamFn, model, firstMessage).then((name) => {
+        void generateShortSessionName(session.agent.streamFunction, model, firstMessage).then((name) => {
             this.applyGeneratedSessionName(session, name ?? fallbackSessionName(firstMessage));
         }).catch(() => {
             this.applyGeneratedSessionName(session, fallbackSessionName(firstMessage));
@@ -1680,6 +2250,10 @@ export class PiSessionService {
     applyGeneratedSessionName(session, name) {
         if (name === undefined || session.sessionName !== undefined)
             return;
+        if (this.treeNavigations.has(session)) {
+            this.deferredGeneratedSessionNames.set(session, name);
+            return;
+        }
         session.setSessionName(name);
         this.publishSessionName(session);
     }
@@ -1751,70 +2325,214 @@ export class PiSessionService {
         }
     }
     activityLabelFromStatus(session) {
+        if (this.treeNavigations.has(session))
+            return "正在切换会话树";
+        if (this.isSessionEntryMutationActive(session))
+            return "正在更新会话";
         if (session.isCompacting)
-            return "compacting";
+            return "正在压缩上下文";
         if (session.isBashRunning)
-            return "running bash";
+            return "正在运行命令";
         if (session.isStreaming)
-            return "agent running";
+            return "代理正在运行";
         if (this.pendingMessageCount(session) > 0)
-            return "queued";
-        return "active";
+            return "正在排队";
+        return "正在处理";
     }
     hasActiveWork(session) {
-        return sessionHasActiveWork(session, this.compactionQueuedMessages(session.sessionId).length);
+        return this.treeNavigations.has(session)
+            || this.isSessionEntryMutationActive(session)
+            || this.isTreeExclusiveOperationActive(session)
+            || sessionHasActiveWork(session, this.compactionQueuedMessages(session.sessionId).length);
+    }
+    async runTreeExclusiveOperation(targets, activeError, operation) {
+        const sessionIds = new Set();
+        const runtimes = new Set();
+        const sessions = new Set();
+        for (const target of targets) {
+            const runtime = target.runtime ?? (target.session === undefined ? undefined : this.activeRuntimeForSession(target.session));
+            const session = target.session ?? runtime?.session;
+            if (session !== undefined && this.hasActiveWork(session))
+                throw new Error(activeError);
+            sessionIds.add(target.sessionId);
+            if (runtime !== undefined)
+                runtimes.add(runtime);
+            if (session !== undefined)
+                sessions.add(session);
+        }
+        for (const sessionId of sessionIds) {
+            this.treeExclusiveSessionOperationCounts.set(sessionId, (this.treeExclusiveSessionOperationCounts.get(sessionId) ?? 0) + 1);
+        }
+        for (const runtime of runtimes) {
+            this.treeExclusiveRuntimeOperationCounts.set(runtime, (this.treeExclusiveRuntimeOperationCounts.get(runtime) ?? 0) + 1);
+        }
+        for (const session of sessions)
+            this.observeUnreadActivityState(session);
+        try {
+            return await operation();
+        }
+        finally {
+            for (const runtime of runtimes)
+                decrementWeakCount(this.treeExclusiveRuntimeOperationCounts, runtime);
+            for (const sessionId of sessionIds)
+                decrementMapCount(this.treeExclusiveSessionOperationCounts, sessionId);
+            for (const session of sessions) {
+                if (this.isCurrentActiveSession(session))
+                    this.observeUnreadActivityState(session);
+            }
+        }
+    }
+    isTreeExclusiveSessionIdentityActive(sessionId) {
+        return (this.treeExclusiveSessionOperationCounts.get(sessionId) ?? 0) > 0;
+    }
+    isTreeExclusiveOperationActive(session) {
+        if (this.isTreeExclusiveSessionIdentityActive(session.sessionId))
+            return true;
+        const runtime = this.activeRuntimeForSession(session);
+        return runtime !== undefined && (this.treeExclusiveRuntimeOperationCounts.get(runtime) ?? 0) > 0;
+    }
+    activeRuntimeForSession(session) {
+        const tracked = this.runtimeBySession.get(session);
+        if (tracked !== undefined)
+            return tracked;
+        for (const active of new Set(this.active.values())) {
+            if (active.runtime.session === session)
+                return active.runtime;
+        }
+        return undefined;
+    }
+    assertTreeNavigationInactive(session, action) {
+        if (this.treeNavigations.has(session))
+            throw new Error(`Cannot ${action} while session tree navigation is active`);
+    }
+    async runSessionEntryMutation(session, action, operation) {
+        this.beginSessionEntryMutation(session, action);
+        try {
+            return await operation();
+        }
+        finally {
+            this.endSessionEntryMutation(session);
+        }
+    }
+    beginSessionEntryMutation(session, action) {
+        this.assertTreeNavigationInactive(session, action);
+        this.sessionEntryMutationCounts.set(session, (this.sessionEntryMutationCounts.get(session) ?? 0) + 1);
+        this.observeUnreadActivityState(session);
+    }
+    endSessionEntryMutation(session) {
+        const remaining = (this.sessionEntryMutationCounts.get(session) ?? 1) - 1;
+        if (remaining <= 0)
+            this.sessionEntryMutationCounts.delete(session);
+        else
+            this.sessionEntryMutationCounts.set(session, remaining);
+        this.observeUnreadActivityState(session);
+    }
+    isSessionEntryMutationActive(session) {
+        return (this.sessionEntryMutationCounts.get(session) ?? 0) > 0;
     }
     publishActivityForEvent(session, event) {
         const eventType = getString(event, "type");
         if (eventType === undefined)
             return;
         if (eventType === "agent_start") {
-            this.publishActivity(session, "agent running", "active");
+            this.publishActivity(session, "代理正在运行", "active");
             return;
         }
         if (eventType === "agent_end") {
-            this.publishActivity(session, "idle", "idle");
-            setTimeout(() => {
-                this.publishActivity(session, "idle", "idle");
+            this.publishActivity(session, "空闲", "idle");
+            const eventScope = this.eventScopeForSession(session);
+            const sessionKey = activeSessionKey(session.sessionId, eventScope);
+            this.activities.scheduleSettledRefresh(sessionKey, () => {
+                if (this.active.get(sessionKey)?.runtime.session !== session)
+                    return;
+                this.publishActivity(session, "空闲", "idle");
                 this.publishStatus(session);
             }, 250);
             return;
         }
         if (eventType === "turn_end") {
-            this.publishActivity(session, "turn complete", "idle");
+            this.publishActivity(session, "本轮已完成", "idle");
             return;
         }
         if (eventType === "message_start") {
-            this.publishActivity(session, "message started", "active");
+            this.publishActivity(session, "消息开始处理", "active");
             return;
         }
         if (eventType === "message_end") {
-            this.publishActivity(session, "message complete", "idle");
+            this.publishActivity(session, "消息处理完成", "idle");
             return;
         }
         if (eventType === "message_update") {
-            this.publishActivity(session, "receiving response", "active");
+            this.publishActivity(session, "正在接收回复", "active");
             return;
         }
         if (eventType === "tool_execution_start") {
-            this.publishActivity(session, "running tool", "active", getString(event, "toolName"));
+            this.publishActivity(session, "正在运行工具", "active", getString(event, "toolName"));
             return;
         }
         if (eventType === "tool_execution_end") {
             const isError = getBoolean(event, "isError") === true;
-            this.publishActivity(session, isError ? "tool failed" : "tool complete", isError ? "error" : "idle", getString(event, "toolName"));
+            this.publishActivity(session, isError ? "工具执行失败" : "工具执行完成", isError ? "error" : "idle", getString(event, "toolName"));
             return;
         }
         if (eventType === "bash_execution_start") {
-            this.publishActivity(session, "running bash", "active");
+            this.publishActivity(session, "正在运行命令", "active");
             return;
         }
         if (eventType === "bash_execution_end") {
-            this.publishActivity(session, "bash complete", "idle");
+            this.publishActivity(session, "命令执行完成", "idle");
             return;
         }
         if (this.hasActiveWork(session))
-            this.publishActivity(session, eventType.replaceAll("_", " "), "active");
+            this.publishActivity(session, "正在处理", "active");
+    }
+    /**
+     * Build the reporter for one session construction.
+     *
+     * The session id is known before any await — a `SessionManager` has its id
+     * from construction — so the daemon can name what it is starting even though
+     * the `PiAgentSession` that {@link publishActivity} needs does not exist yet.
+     * Without an id there is nothing to report against, so the reporter stays
+     * silent and the browser keeps its own generic wording.
+     */
+    startupProgress(sessionManager, intent, startupToken, eventScope) {
+        const sessionId = sessionManager.getSessionId();
+        if (sessionId === "")
+            return { report: noop, end: noop };
+        const label = intent === "create" ? "正在创建会话" : "正在打开会话";
+        return {
+            report: (phase) => { this.publishStartupProgress(sessionId, startupToken, label, "active", this.startupDetail(phase), eventScope); },
+            end: () => {
+                // A real activity published during the window (an extension error, say)
+                // is the truth about this session and must survive the clear.
+                if (this.activities.get(activeSessionKey(sessionId, eventScope)) !== undefined)
+                    return;
+                this.publishStartupProgress(sessionId, startupToken, "空闲", "idle", undefined, eventScope);
+            },
+        };
+    }
+    startupDetail(phase) {
+        return this.catalogRefreshStatus?.isRefreshInFlight() === true
+            ? `${phase} · ${STARTUP_CONCURRENT_CATALOG_REFRESH}`
+            : phase;
+    }
+    /**
+     * Report startup progress on the global channel only, echoing the caller's
+     * correlation token so a waiting browser row recognises its own construction.
+     *
+     * Unlike {@link publishActivity} this deliberately records nothing: no
+     * `activities` entry, no workspace activity, no unread observation. There is
+     * no session to own that state, and a failed creation would leave it stranded.
+     *
+     * Every report is marked `startup`, which is what keeps a session that is
+     * merely opening from counting as one doing work. This is the only publisher
+     * that sets the marker, and because it writes no `activities` entry no later
+     * heartbeat re-publication can carry it.
+     */
+    publishStartupProgress(sessionId, startupToken, label, phase, detail, eventScope) {
+        const at = new Date().toISOString();
+        const activity = detail === undefined ? { sessionId, phase, label, at, startup: true } : { sessionId, phase, label, detail, at, startup: true };
+        this.events.publishGlobal(startupToken === undefined ? { type: "session.startup", activity } : { type: "session.startup", startupToken, activity }, eventScope);
     }
     publishActivity(session, label, phase, detail) {
         const at = new Date().toISOString();
@@ -1825,6 +2543,7 @@ export class PiSessionService {
         this.workspaceActivity?.applySessionActivity(session.sessionManager.getCwd(), activity, eventScope);
         this.events.publish(session.sessionId, { type: "activity.update", activity }, eventScope);
         this.events.publishGlobal({ type: "activity.update", activity }, eventScope);
+        this.observeUnreadActivityState(session);
     }
     publishStatus(session) {
         const status = this.statusFromSession(session);
@@ -1833,6 +2552,7 @@ export class PiSessionService {
         this.workspaceActivity?.applySessionStatus(session.sessionManager.getCwd(), status, eventScope);
         this.events.publish(session.sessionId, { type: "status.update", status }, eventScope);
         this.events.publishGlobal({ type: "status.update", status }, eventScope);
+        this.observeUnreadActivityState(session);
     }
     clearStaleActiveActivity(session) {
         const eventScope = this.eventScopeForSession(session);
@@ -1840,7 +2560,7 @@ export class PiSessionService {
         if (current?.phase !== "active" || this.hasActiveWork(session))
             return;
         const at = new Date().toISOString();
-        const stored = { phase: "idle", label: "idle", at };
+        const stored = { phase: "idle", label: "空闲", at };
         this.activities.set(activeSessionKey(session.sessionId, eventScope), stored);
         const activity = { sessionId: session.sessionId, ...stored };
         this.events.publish(session.sessionId, { type: "activity.update", activity }, eventScope);
@@ -1860,6 +2580,8 @@ export class PiSessionService {
         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);
         return {
             sessionId: session.sessionId,
             persisted: sessionFileExists(session.sessionFile),
@@ -1874,8 +2596,24 @@ export class PiSessionService {
             tokens: stats.tokens,
             cost: stats.cost,
             ...(contextUsage === undefined ? {} : { contextUsage }),
+            ...(warnings.length === 0 ? {} : { warnings }),
+            ...(pendingAsk === undefined ? {} : { pendingAsk }),
         };
     }
+    /**
+     * Compute the live warning set for a session: runtime/resource diagnostics from
+     * the active runtime (if any) plus the Anthropic subscription-auth notice. Read
+     * fresh on each status publish so a rebuilt runtime or an auth/model change is
+     * reflected without caching a stale snapshot.
+     */
+    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 (anthropic !== undefined)
+            warnings.push(anthropic);
+        return warnings;
+    }
     pendingMessageCount(session) {
         return session.pendingMessageCount + this.compactionQueuedMessages(session.sessionId).length;
     }
@@ -1885,6 +2623,394 @@ export class PiSessionService {
     hasQueuedMessageText(session, text) {
         return queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)).some((message) => message.text === text);
     }
+    notificationCatalog() {
+        return this.notificationStore.catalogSnapshot();
+    }
+    async unreadCatalog() {
+        await this.publishUnreadMutations([]);
+        return this.unreadStore.durableCatalogSnapshot();
+    }
+    async acknowledgeUnread(sessionId, request) {
+        const result = this.unreadStore.acknowledge(sessionId, {
+            ...request,
+            cwd: canonicalizeStoredCwd(request.cwd),
+        });
+        await this.publishUnreadMutations(result.mutations);
+        return this.unreadStore.durableCatalogSnapshot();
+    }
+    notificationInbox(ref) {
+        return this.notificationStore.inboxSnapshot(ref.id, canonicalizeStoredCwd(ref.cwd));
+    }
+    dismissNotification(ref, request) {
+        const result = this.notificationStore.dismissNotification(ref.id, canonicalizeStoredCwd(ref.cwd), request.daemonInstanceId, request.notificationId);
+        this.publishNotificationMutations(result.mutations);
+        return result.snapshot;
+    }
+    dismissAllNotifications(ref, request) {
+        const result = this.notificationStore.dismissAll(ref.id, canonicalizeStoredCwd(ref.cwd), request.daemonInstanceId, request.throughOrder, request.throughOverflowWatermark);
+        this.publishNotificationMutations(result.mutations);
+        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" }));
+        this.publishStatus(session);
+    }
+    logSubsessionNotificationFailure(parentId, childId, error) {
+        this.logger.info({ parentSessionId: parentId, sessionId: childId, error: error instanceof Error ? error.message : String(error) }, "failed to notify parent of subsession completion");
+    }
+    async reloadSessionRuntime(session) {
+        if (this.hasActiveWork(session))
+            throw new Error("Stop current session activity before reloading");
+        await this.runTreeExclusiveOperation([{ sessionId: session.sessionId, session }], "Stop current session activity before reloading", async () => {
+            this.publishActivity(session, "正在重新加载资源", "active");
+            const priorGeneration = this.notificationGenerationBySession.get(session);
+            let candidateGeneration;
+            try {
+                await session.reload(priorGeneration === undefined ? undefined : {
+                    beforeSessionStart: () => {
+                        candidateGeneration = this.notificationStore.beginReplacement(priorGeneration, notificationIdentityForSession(session));
+                        this.notificationGenerationBySession.set(session, candidateGeneration);
+                        this.replaceSessionNotificationContext(session, candidateGeneration);
+                    },
+                });
+                if (candidateGeneration !== undefined) {
+                    this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
+                }
+                this.publishActivity(session, "资源已重新加载", "idle");
+                this.publishStatus(session);
+            }
+            catch (error) {
+                if (candidateGeneration !== undefined) {
+                    this.publishNotificationMutations(this.notificationStore.abortReplacement(candidateGeneration, "candidate"));
+                    this.notificationGenerationBySession.set(session, candidateGeneration);
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                this.publishActivity(session, "重新加载失败", "error", message);
+                this.events.publish(session.sessionId, { type: "session.error", message });
+                this.publishStatus(session);
+                throw error;
+            }
+        });
+    }
+    async dismissWarning(ref, dismissId) {
+        const session = await this.getOrOpen(ref);
+        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;
+    }
+    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);
+        const runtime = await this.createAgentRuntime(this.createRuntime, {
+            cwd,
+            agentDir: this.agentDir,
+            sessionManager,
+            delegationToolsEnabled,
+            ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
+            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+        });
+        const active = {
+            runtime,
+            unsubscribe: noop,
+            managementContextKey: managementContextKey(options.managementContext),
+            eventScope: eventScopeFromManagementContext(options.managementContext),
+        };
+        let boundSession = runtime.session;
+        let notificationGeneration = options.notificationGeneration;
+        let notificationOwnership = options.notifications === "disabled"
+            ? "disabled"
+            : notificationGeneration === undefined
+                ? "registered"
+                : "external";
+        if (notificationOwnership === "registered") {
+            const notificationIdentity = notificationIdentityForSession(runtime.session);
+            const existingCandidate = this.notificationStore.beginReplacementForSession(notificationIdentity.sessionId, notificationIdentity.cwd);
+            if (existingCandidate !== undefined) {
+                notificationGeneration = existingCandidate;
+                notificationOwnership = "replacement";
+            }
+            else {
+                const registration = this.notificationStore.registerSession(notificationIdentity.sessionId, notificationIdentity.cwd);
+                notificationGeneration = registration.generation;
+                this.publishNotificationMutations(registration.mutations);
+            }
+        }
+        if (notificationGeneration !== undefined)
+            this.notificationGenerationBySession.set(runtime.session, notificationGeneration);
+        try {
+            if (options.creationProvenance === "tracked-subsession") {
+                await this.publishUnreadMutations(this.unreadStore.excludeSession(runtime.session.sessionId, canonicalizeStoredCwd(runtime.session.sessionManager.getCwd())));
+            }
+            else {
+                await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
+            }
+            startup.report(STARTUP_PHASE_EXTENSIONS);
+            await this.bindSessionExtensions(runtime.session, notificationGeneration);
+            this.bindRuntime(active);
+            runtime.setRebindSession(async (session) => {
+                const priorGeneration = notificationGeneration;
+                let candidateGeneration;
+                try {
+                    await this.prepareUnreadRuntimeRebind(boundSession, session);
+                    await this.recoverSubsessionTrackingForOpenedSession(session);
+                    if (priorGeneration !== undefined) {
+                        candidateGeneration = this.notificationStore.beginReplacement(priorGeneration, notificationIdentityForSession(session));
+                        this.notificationGenerationBySession.set(session, candidateGeneration);
+                    }
+                    this.bindRuntime(active, session);
+                    boundSession = session;
+                    await this.bindSessionExtensions(session, candidateGeneration);
+                    if (candidateGeneration !== undefined) {
+                        this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
+                        notificationGeneration = candidateGeneration;
+                    }
+                }
+                catch (error) {
+                    if (candidateGeneration !== undefined) {
+                        this.publishNotificationMutations(this.notificationStore.abortReplacement(candidateGeneration, "candidate"));
+                        notificationGeneration = candidateGeneration;
+                        this.notificationGenerationBySession.set(session, candidateGeneration);
+                    }
+                    throw error;
+                }
+            });
+            this.active.set(activeSessionKey(runtime.session.sessionId, active.eventScope), active);
+            if (notificationOwnership === "replacement" && notificationGeneration !== undefined) {
+                this.publishNotificationMutations(this.notificationStore.commitReplacement(notificationGeneration));
+                notificationOwnership = "external";
+            }
+            this.publishStatus(runtime.session);
+            return active;
+        }
+        catch (error) {
+            if (notificationGeneration !== undefined) {
+                if (notificationOwnership === "registered") {
+                    this.publishNotificationMutations(this.notificationStore.clearSession(runtime.session.sessionId, "initialization-failed"));
+                }
+                else if (notificationOwnership === "replacement") {
+                    this.publishNotificationMutations(this.notificationStore.abortReplacement(notificationGeneration));
+                }
+            }
+            active.unsubscribe();
+            this.forgetUnreadActivity(boundSession);
+            let removedActive = false;
+            for (const [sessionKey, candidate] of this.active.entries()) {
+                if (candidate !== active)
+                    continue;
+                this.active.delete(sessionKey);
+                this.activities.delete(sessionKey);
+                this.clearAuthLossWarningsForSession(runtime.session.sessionId);
+                this.clearCompactionPromptQueue(runtime.session.sessionId);
+                removedActive = true;
+            }
+            if (removedActive) {
+                this.workspaceActivity?.removeSession(runtime.session.sessionId, runtime.session.sessionManager.getCwd(), active.eventScope);
+            }
+            try {
+                await runtime.session.abort();
+            }
+            finally {
+                await runtime.dispose();
+            }
+            throw error;
+        }
+    }
+    replaceSessionNotificationContext(session, generation) {
+        session.extensionRunner.setUIContext(this.sessionUiContext(session, generation), "rpc");
+    }
+    sessionUiContext(session, generation) {
+        const baseUiContext = session.extensionRunner.getUIContext();
+        const notify = (message, type) => {
+            if (generation === undefined) {
+                this.events.publish(session.sessionId, {
+                    type: "command.output",
+                    level: type === "error" ? "error" : "info",
+                    message,
+                });
+                return;
+            }
+            const added = this.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,
+            });
+        };
+        // PI WEB owns the browser-facing notification and text-formatting
+        // boundaries. Delegate every other UI method to Pi's headless defaults so
+        // unsupported dialogs cancel safely instead of hanging.
+        return new Proxy(baseUiContext, {
+            get(target, property, receiver) {
+                if (property === "notify")
+                    return notify;
+                if (property === "theme")
+                    return plainTextTheme;
+                const value = Reflect.get(target, property, receiver);
+                return value;
+            },
+        });
+    }
+    publishNotificationMutations(mutations) {
+        for (const mutation of mutations) {
+            const scopes = new Set(this.activeSessionsForId(mutation.sessionId).map((active) => active.eventScope));
+            if (scopes.size === 0)
+                scopes.add(NORMAL_SESSION_EVENT_SCOPE);
+            for (const scope of scopes) {
+                this.events.publish(mutation.sessionId, mutation.inboxEvent, scope);
+                this.events.publishGlobal(mutation.summaryEvent, scope);
+            }
+        }
+    }
+    async prepareUnreadRuntimeRebind(previous, next) {
+        const previousCwd = canonicalizeStoredCwd(previous.sessionManager.getCwd());
+        this.unreadStore.forgetActivity(previous.sessionId, previousCwd);
+        const nextCwd = canonicalizeStoredCwd(next.sessionManager.getCwd());
+        if (previous.sessionId === next.sessionId && cwdPathsEqual(previousCwd, nextCwd))
+            return;
+        await this.publishUnreadMutations(this.unreadStore.forgetSession(previous.sessionId, previousCwd));
+    }
+    forgetUnreadActivity(session) {
+        this.unreadStore.forgetActivity(session.sessionId, canonicalizeStoredCwd(session.sessionManager.getCwd()));
+    }
+    async forgetUnreadSessions(identities) {
+        const mutations = [];
+        for (const identity of identities) {
+            mutations.push(...this.unreadStore.forgetSession(identity.sessionId, canonicalizeStoredCwd(identity.cwd)));
+        }
+        await this.publishUnreadMutations(mutations);
+    }
+    observeUnreadActivityState(session) {
+        const mutations = this.unreadStore.observeActivityState(session.sessionId, canonicalizeStoredCwd(session.sessionManager.getCwd()), this.hasActiveWork(session));
+        if (mutations.length === 0)
+            return;
+        void this.publishUnreadMutations(mutations).catch(() => undefined);
+    }
+    publishUnreadMutations(mutations) {
+        this.enqueueUnreadMutations(mutations);
+        this.unreadPublicationFlushRequested = true;
+        if (this.unreadPublication === undefined && this.unreadPublicationRetryTimer !== undefined) {
+            const failure = this.unreadPublicationFailure;
+            return Promise.reject(failure instanceof Error
+                ? failure
+                : new Error("Session unread publication is awaiting retry", { cause: failure }));
+        }
+        return this.ensureUnreadPublication();
+    }
+    ensureUnreadPublication() {
+        const existing = this.unreadPublication;
+        if (existing !== undefined)
+            return existing;
+        const publication = this.drainUnreadPublication();
+        this.unreadPublication = publication;
+        void publication.then(() => {
+            if (this.unreadPublication === publication)
+                this.unreadPublication = undefined;
+        }, (error) => {
+            if (this.unreadPublication === publication)
+                this.unreadPublication = undefined;
+            this.unreadPublicationFailure = error;
+            this.logger.info({ error: error instanceof Error ? error.message : String(error) }, "failed to publish durable session unread mutations");
+            this.scheduleUnreadPublicationRetry();
+        });
+        return publication;
+    }
+    async drainUnreadPublication() {
+        while (this.unreadPublicationFlushRequested || this.pendingUnreadMutations.length > 0) {
+            this.unreadPublicationFlushRequested = false;
+            const batch = this.pendingUnreadMutations.splice(0);
+            let publishedCount = 0;
+            try {
+                await this.unreadStore.flush();
+                for (const mutation of batch) {
+                    this.events.publishGlobal(mutation.event);
+                    publishedCount += 1;
+                }
+            }
+            catch (error) {
+                this.prependUnreadMutations(batch.slice(publishedCount));
+                this.unreadPublicationFlushRequested = true;
+                throw error;
+            }
+            this.unreadPublicationFailure = undefined;
+            this.clearUnreadPublicationRetry();
+        }
+    }
+    enqueueUnreadMutations(mutations) {
+        this.pendingUnreadMutations.push(...mutations);
+        this.trimPendingUnreadMutations();
+    }
+    prependUnreadMutations(mutations) {
+        this.pendingUnreadMutations.unshift(...mutations);
+        this.trimPendingUnreadMutations();
+    }
+    trimPendingUnreadMutations() {
+        const excess = this.pendingUnreadMutations.length - MAX_PENDING_UNREAD_MUTATIONS;
+        if (excess > 0)
+            this.pendingUnreadMutations.splice(0, excess);
+    }
+    scheduleUnreadPublicationRetry() {
+        if (this.unreadPublicationStopped || this.unreadPublicationRetryTimer !== undefined)
+            return;
+        const delay = this.unreadPublicationRetryDelayMs;
+        this.unreadPublicationRetryDelayMs = Math.min(Math.max(delay * 2, this.unreadPublicationRetryInitialMs), Math.max(MAX_UNREAD_PUBLICATION_RETRY_MS, this.unreadPublicationRetryInitialMs));
+        this.unreadPublicationRetryTimer = setTimeout(() => {
+            this.unreadPublicationRetryTimer = undefined;
+            void this.ensureUnreadPublication().catch(() => undefined);
+        }, delay);
+        this.unreadPublicationRetryTimer.unref();
+    }
+    clearUnreadPublicationRetry() {
+        if (this.unreadPublicationRetryTimer !== undefined)
+            clearTimeout(this.unreadPublicationRetryTimer);
+        this.unreadPublicationRetryTimer = undefined;
+        this.unreadPublicationRetryDelayMs = this.unreadPublicationRetryInitialMs;
+    }
+    flushDeferredTreeNavigationWork(session) {
+        const generatedName = this.deferredGeneratedSessionNames.get(session);
+        this.deferredGeneratedSessionNames.delete(session);
+        if (generatedName !== undefined) {
+            try {
+                this.applyGeneratedSessionName(session, generatedName);
+            }
+            catch (error) {
+                this.logger.info({ sessionId: session.sessionId, error: error instanceof Error ? error.message : String(error) }, "failed to apply deferred session name");
+            }
+        }
+        const notifications = this.deferredSubsessionNotifications.get(session) ?? [];
+        this.deferredSubsessionNotifications.delete(session);
+        for (const notification of notifications) {
+            void this.deliverSubsessionNotification(session, notification).catch((error) => {
+                this.logSubsessionNotificationFailure(notification.parentId, notification.childId, error);
+            });
+        }
+    }
 }
 function previewResponseFromPlan(plan) {
     return {
@@ -1940,6 +3066,12 @@ function modelToClientModel(model) {
         ...(reasoning === undefined ? {} : { reasoning }),
     };
 }
+function notificationIdentityForSession(session) {
+    return {
+        sessionId: session.sessionId,
+        cwd: canonicalizeStoredCwd(session.sessionManager.getCwd()),
+    };
+}
 function clientSessionFromListEntry(session) {
     return {
         id: session.id,
@@ -2136,28 +3268,6 @@ function activeSessionFileMatches(active, expectedSessionFile) {
 function trackedLinkParentFileMatches(link, parentSessionFile) {
     return link.parentSessionFile !== undefined && sessionPathsEqual(link.parentSessionFile, parentSessionFile);
 }
-async function readSessionHeaderSummary(sessionFile) {
-    let file;
-    try {
-        file = await open(sessionFile, "r");
-        const buffer = Buffer.alloc(4096);
-        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
-        const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n", 1)[0];
-        if (firstLine === undefined || firstLine === "")
-            return undefined;
-        const header = JSON.parse(firstLine);
-        if (!isRecord(header) || header["type"] !== "session" || typeof header["id"] !== "string")
-            return undefined;
-        const parentSession = getString(header, "parentSession");
-        return { id: header["id"], ...(parentSession === undefined ? {} : { parentSession }) };
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        await file?.close().catch(() => undefined);
-    }
-}
 async function sessionFileHeaderMatches(sessionFile, expected) {
     const header = await readSessionHeaderSummary(sessionFile);
     if (header?.id !== expected.sessionId)
@@ -2223,8 +3333,11 @@ function stringValue(value) {
     return typeof value === "string" ? value : "";
 }
 function historyMessages(session) {
+    return historyMessagesFromManager(session.sessionManager);
+}
+function historyMessagesFromManager(sessionManager) {
     const messages = [];
-    for (const entry of session.sessionManager.getBranch()) {
+    for (const entry of sessionManager.getBranch()) {
         if (!isRecord(entry))
             continue;
         if (entry["type"] === "message")
@@ -2244,11 +3357,13 @@ const SUBSESSION_LINK_CUSTOM_TYPE = "pi-web.subsession.link";
 const SUBSESSION_CHILD_LINK_CUSTOM_TYPE = "pi-web.subsession.spawned";
 /** customType marking a parent-facing subsession-completion notice. */
 const SUBSESSION_NOTIFICATION_CUSTOM_TYPE = "subsession.completion";
-const SUBSESSION_NOTIFICATION_PREVIEW_CHARS = 2000;
-function truncateForNotification(text) {
-    if (text.length <= SUBSESSION_NOTIFICATION_PREVIEW_CHARS)
-        return text;
-    return `${text.slice(0, SUBSESSION_NOTIFICATION_PREVIEW_CHARS)}…`;
+const SUBSESSION_NOTIFICATION_MAX_OUTPUT_CHARS = 2000;
+/** Avoid duplicating a partial result in context when deliberate inspection can return the full output. */
+function formatSubsessionNotificationOutput(childSessionId, text) {
+    if (text.length > SUBSESSION_NOTIFICATION_MAX_OUTPUT_CHARS) {
+        return `Output from subsession ${childSessionId} was too long for this completion notice and was omitted. Call check_subsession with sessionId "${childSessionId}" to retrieve the final output.`;
+    }
+    return `--- SUBSESSION OUTPUT: ${childSessionId} ---\n${text === "" ? "(no output)" : text}`;
 }
 /** Most recent assistant text from a history message list, or "" if none. */
 function finalAssistantText(messages) {