@chainingintention/pi-web-cn 1.202609.1 → 1.202609.4

package/dist/server/sessions/piSessionService.js

@@ -1,7 +1,6 @@
-import { constants, realpathSync, statSync } from "node:fs";
-import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { realpathSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, getAgentDir, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, readStoredCredential, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { projectBrowserMessage } from "../browserMessageProjection.js";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
@@ -23,7 +22,7 @@ import { SessionActivityCoordinator } from "./sessionActivityCoordinator.js";
 import { searchSessionContent } from "./sessionContentSearch.js";
 import { createLocalOnlyModelRuntime } from "./authService.js";
 import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
-import { readSessionHeaderSummary } from "./sessionFileHeader.js";
+import { clearSessionFileParent, readSessionHeaderSummary } from "./sessionFileHeader.js";
 import { workbenchAccessHandle } from "../managementEmbed.js";
 import { DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS, piWebDataDir } from "../../config.js";
 import { createScopedSettingsManager, resolveSettingsScopeDirectory } from "./projectSettingsScope.js";
@@ -39,6 +38,7 @@ import { createManagedAgentToolOptions, createManagedPythonToolDefinition } from
 import { PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR, managementAgentToolNames, withRuntimeCreationEnvironment, writeManagementPermissionSystemPolicy } from "./managementPermissionSystem.js";
 import { SessionNotificationStore } from "./sessionNotificationStore.js";
 import { plainTextTheme } from "./plainTextTheme.js";
+import { deduplicateBundledRelaySkills, ensureManagedRelaySkills, MANAGED_RELAY_SKILL_NAMES } from "./relaySkill.js";
 import { SessionUnreadStore } from "./sessionUnreadStore.js";
 import { archiveCandidateFromActiveSession, archiveCandidateFromArchivedRecord, archiveCandidateFromListEntry, archiveInputFromActiveSession, archiveInputFromCandidate, archiveInputFromListEntry, clientSessionFromArchivedRecord, compareArchivedRecords, } from "./sessionArchiveMapping.js";
 import { annotateAssistantThinkingLevel, getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
@@ -178,8 +178,6 @@ function parsePromptStreamingBehavior(value) {
     throw new Error('Prompt streamingBehavior must be "steer" or "followUp"');
 }
 const GLOBAL_AGENT_CONTEXT_FILE_NAMES = new Set(["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"]);
-const MANAGED_RELAY_SKILL_DIRECTORY = join(".pi", "skills", "relay");
-const BUNDLED_RELAY_SKILL_PATH = fileURLToPath(new URL("../../../skills/relay/SKILL.md", import.meta.url));
 export function filterManagedGlobalContextFiles(cwd, agentDir, base) {
     return {
         agentsFiles: base.agentsFiles.filter((file) => {
@@ -202,29 +200,10 @@ export function filterManagedProjectSkills(cwd, base) {
         diagnostics: filterManagedSkillDiagnostics(base.diagnostics, pathAllowed),
     };
 }
-export async function ensureManagedRelaySkill(cwd, bundledSkillPath = BUNDLED_RELAY_SKILL_PATH) {
-    const projectRoot = realpathSync(cwd);
-    const piDirectory = resolve(projectRoot, ".pi");
-    const skillsDirectory = join(piDirectory, "skills");
-    const skillDirectory = resolve(projectRoot, MANAGED_RELAY_SKILL_DIRECTORY);
-    const skillPath = join(skillDirectory, "SKILL.md");
-    for (const directory of [piDirectory, skillsDirectory, skillDirectory]) {
-        await ensureManagedSkillDirectory(projectRoot, directory);
-    }
-    try {
-        await copyFile(bundledSkillPath, skillPath, constants.COPYFILE_EXCL);
-    }
-    catch (error) {
-        if (!isNodeError(error, "EEXIST"))
-            throw error;
-    }
-    assertManagedSkillPath(projectRoot, skillPath, "file");
-    return skillPath;
-}
 export function filterManagedWorkbenchSkills(cwd, base, receipt) {
     const projectRoot = realpathSync(cwd);
     const allowedDirectories = new Set([
-        resolve(projectRoot, MANAGED_RELAY_SKILL_DIRECTORY),
+        ...MANAGED_RELAY_SKILL_NAMES.map((name) => resolve(projectRoot, ".pi", "skills", name)),
         ...receipt.skills.map((skill) => resolve(projectRoot, ".pi", "skills", skill.directory)),
     ]);
     const pathAllowed = (path) => [...allowedDirectories].some((directory) => pathInsideRealDirectory(directory, path));
@@ -245,27 +224,6 @@ function pathInsideRealDirectory(directory, path) {
         return false;
     }
 }
-async function ensureManagedSkillDirectory(projectRoot, path) {
-    try {
-        await mkdir(path);
-    }
-    catch (error) {
-        if (!isNodeError(error, "EEXIST"))
-            throw error;
-    }
-    assertManagedSkillPath(projectRoot, path, "directory");
-}
-function assertManagedSkillPath(projectRoot, path, expectedType) {
-    const realPath = realpathSync(path);
-    const stats = statSync(realPath);
-    const hasExpectedType = expectedType === "directory" ? stats.isDirectory() : stats.isFile();
-    if (!pathInsideOrEqual(projectRoot, realPath) || !hasExpectedType) {
-        throw new Error(`Managed skill path is invalid: ${path}`);
-    }
-}
-function isNodeError(error, code) {
-    return error instanceof Error && "code" in error && error.code === code;
-}
 function pathInsideOrEqual(parent, child) {
     const normalizedParent = resolve(parent);
     const normalizedChild = resolve(child);
@@ -433,13 +391,16 @@ function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRu
             globalAgentDir: agentDir,
             mode: "normal",
         });
-        const resourceLoaderOptions = piWebResourceLoaderOptions(appendSystemPromptSections);
+        const resourceLoaderOptions = {
+            ...piWebResourceLoaderOptions(appendSystemPromptSections),
+            skillsOverride: (base) => deduplicateBundledRelaySkills(cwd, base),
+        };
         const services = await createAgentSessionServices({
             cwd,
             agentDir,
             modelRuntime: scopedModelRuntime,
             settingsManager,
-            ...(resourceLoaderOptions === undefined ? {} : { resourceLoaderOptions }),
+            resourceLoaderOptions,
         });
         const modelOptions = await resolveSessionModelOptions({
             services,
@@ -463,7 +424,7 @@ function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRu
 }
 function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled = true }) => {
-        await ensureManagedRelaySkill(cwd);
+        await ensureManagedRelaySkills(cwd);
         const auditIdentity = await resolveManagementAuditIdentity(cwd, managementContext, managementProjectIdForCwd, logger);
         const accessHandle = workbenchAccessHandle(managementContext);
         const state = workbench === undefined ? undefined : workbench.accessStates.require(accessHandle);
@@ -641,6 +602,9 @@ export class PiSessionService {
          * child that works again (and stops again) notifies the parent each time.
          */
         this.subsessionNotifyArmed = new Map();
+        this.scopedNotificationStores = new Map();
+        this.scopedUnreadStores = new Map();
+        this.sessionEventScopes = new WeakMap();
         this.notificationGenerationBySession = new WeakMap();
         this.idleSessionFileResolutions = new WeakMap();
         /** The parked extension Promise resolvers behind the store's open dialogs. */
@@ -736,7 +700,8 @@ export class PiSessionService {
     async cleanupPreview(request) {
         return previewResponseFromPlan(await this.cleanupPlan(request));
     }
-    async cleanup(request) {
+    async cleanup(request, context) {
+        const scope = eventScopeFromManagementContext(context);
         const plan = await this.cleanupPlan(request);
         if (plan.deleteRecords.length > 0 && this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
@@ -750,24 +715,24 @@ export class PiSessionService {
                 skippedBusySessionIds.add(input.sessionId);
                 continue;
             }
-            await this.closeActive(input.sessionId, { kind: "clear", reason: "archive" });
+            await this.closeActive(input.sessionId, { kind: "clear", reason: "archive" }, scope);
             readyArchiveInputs.push(input);
         }
         await this.archiveStoreArchiveMany(readyArchiveInputs);
         archiveInputs.push(...readyArchiveInputs);
-        await this.forgetUnreadSessions(readyArchiveInputs);
+        await this.forgetUnreadSessions(readyArchiveInputs, scope);
         for (const record of plan.deleteRecords) {
             if (this.activeSessionHasWork(record.sessionId)) {
                 skippedBusySessionIds.add(record.sessionId);
                 continue;
             }
-            await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
+            await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" }, scope);
             readyDeleteRecords.push(record);
         }
         await this.ensureArchivedRecordsMoved(readyDeleteRecords);
         const deletedSessionIds = new Set(await this.archiveStoreDeleteArchivedMany(readyDeleteRecords.map((record) => record.sessionId)));
         deleteRecords.push(...readyDeleteRecords.filter((record) => deletedSessionIds.has(record.sessionId)));
-        await this.forgetUnreadSessions(deleteRecords);
+        await this.forgetUnreadSessions(deleteRecords, scope);
         return summarizeSessionCleanupExecution({
             archiveInputs,
             deleteRecords,
@@ -806,6 +771,8 @@ export class PiSessionService {
         this.subsessionHydratedParents.clear();
         this.subsessionNotifyArmed.clear();
         this.notificationStore.clearAll("service-dispose");
+        for (const store of this.scopedNotificationStores.values())
+            store.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);
@@ -870,13 +837,13 @@ export class PiSessionService {
             .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"));
+            this.publishNotificationMutations(this.notificationsForScope(eventScopeFromManagementContext(managementContext)).clearSession(record.sessionId, "archive-reconcile"));
         }
         const unarchivedSessions = sessions.filter((session) => !archivedById.has(session.id)).map(clientSessionFromListEntry);
         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));
+            await this.publishUnreadMutations(this.unreadForScope(eventScopeFromManagementContext(managementContext)).reconcileCwd(canonicalizeStoredCwd(cwd), reconcilableSessionIds));
         }
         const archivedSessions = archivedForCwd
             .sort(compareArchivedRecords)
@@ -985,7 +952,7 @@ export class PiSessionService {
             ...(parentSessionFile === undefined ? {} : { parentSessionFile }),
             cwd: decision.cwd,
         };
-        await this.registerVerifiedSubsession(link);
+        await this.registerVerifiedSubsession(link, eventScopeFromManagementContext(input.managementContext));
         this.persistSubsessionLink(link);
         this.persistSubsessionChildMarker(input.parentSessionId, created.id);
         await this.prompt(created.id, input.prompt, undefined, undefined, {
@@ -1360,7 +1327,7 @@ export class PiSessionService {
             return undefined;
         return sessionFileMatches(session, link.childSessionFile) ? link : undefined;
     }
-    async registerVerifiedSubsession(link) {
+    async registerVerifiedSubsession(link, scope = NORMAL_SESSION_EVENT_SCOPE) {
         const { childSessionId, parentSessionId } = link;
         const previousParentId = this.subsessionParents.get(childSessionId);
         if (previousParentId !== undefined && previousParentId !== parentSessionId) {
@@ -1377,7 +1344,7 @@ export class PiSessionService {
         if (!this.subsessionNotifyArmed.has(childSessionId))
             this.subsessionNotifyArmed.set(childSessionId, false);
         const cwd = this.cwdForVerifiedSubsession(link);
-        await this.publishUnreadMutations(this.unreadStore.excludeSession(childSessionId, cwd));
+        await this.publishUnreadMutations(this.unreadForScope(scope).excludeSession(childSessionId, cwd));
     }
     cwdForVerifiedSubsession(link) {
         const activeCwd = this.activeChildForSubsessionLink(link)?.runtime.session.sessionManager.getCwd();
@@ -1440,7 +1407,7 @@ export class PiSessionService {
         const activeParent = this.activeForSessionId(parentSessionId);
         if (activeParent !== undefined && (parentSessionFile === undefined || activeSessionFileMatches(activeParent, parentSessionFile))) {
             const activeParentFile = nonEmptyString(activeParent.runtime.session.sessionFile);
-            const complete = await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile);
+            const complete = await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile, activeParent.eventScope);
             if (complete)
                 this.subsessionHydratedParents.add(hydrationKey);
             return;
@@ -1460,7 +1427,7 @@ export class PiSessionService {
         if (complete)
             this.subsessionHydratedParents.add(hydrationKey);
     }
-    async registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile) {
+    async registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile, scope = NORMAL_SESSION_EVENT_SCOPE) {
         // Parent custom links are the authoritative recovery record: verify the
         // exact live child file/header before tracking. Do not negatively cache a
         // scan while a candidate child is temporarily unavailable.
@@ -1475,7 +1442,7 @@ export class PiSessionService {
                 complete = false;
                 continue;
             }
-            await this.registerVerifiedSubsession(verified);
+            await this.registerVerifiedSubsession(verified, scope);
         }
         return complete;
     }
@@ -1496,7 +1463,7 @@ export class PiSessionService {
         const link = await this.verifiedSubsessionLinkFromOpenedChild(session);
         if (link === undefined)
             return;
-        await this.registerVerifiedSubsession(link);
+        await this.registerVerifiedSubsession(link, this.eventScopeForSession(session));
     }
     verifiedSubsessionLinkFromOpenedChild(session) {
         return verifiedTrackedSubsessionLink(this.sessionManager, {
@@ -2034,7 +2001,7 @@ export class PiSessionService {
             const archiveInput = await this.archiveInputForSession(session);
             await this.closeActiveSession(active);
             await this.archiveStore.archive(archiveInput);
-            await this.forgetUnreadSessions([archiveInput]);
+            await this.forgetUnreadSessions([archiveInput], active.eventScope);
         });
     }
     async archiveMany(refs, managementContext) {
@@ -2050,7 +2017,7 @@ export class PiSessionService {
         for (const ref of uniqueRefs) {
             const archived = findArchivedRecordForBulkRef(archivedRecords, ref);
             if (archived !== undefined) {
-                this.publishNotificationMutations(this.notificationStore.clearSession(archived.sessionId, "archive"));
+                this.publishNotificationMutations(this.notificationsForScope(eventScopeFromManagementContext(managementContext)).clearSession(archived.sessionId, "archive"));
                 alreadyArchivedSessionIds.push(archived.sessionId);
                 unreadArchivedIdentities.push(archived);
                 continue;
@@ -2114,7 +2081,7 @@ export class PiSessionService {
                     failures.push({ sessionId: input.sessionId, error: errorMessage(error) });
             }
         });
-        await this.forgetUnreadSessions(unreadArchivedIdentities);
+        await this.forgetUnreadSessions(unreadArchivedIdentities, eventScopeFromManagementContext(managementContext));
         return {
             archived: true,
             archivedSessionIds: uniqueStrings(archivedSessionIds),
@@ -2137,13 +2104,13 @@ export class PiSessionService {
         })), `归档 ${sessionDisplayName(session)} 前请先停止当前会话活动`, async () => {
             for (const target of plan.targets) {
                 if (target.archived)
-                    this.publishNotificationMutations(this.notificationStore.clearSession(target.id, "archive"));
+                    this.publishNotificationMutations(this.notificationsForScope(eventScopeFromManagementContext(managementContext)).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 })));
+        await this.forgetUnreadSessions(plan.targets.map((target) => ({ sessionId: target.id, cwd: target.cwd })), eventScopeFromManagementContext(managementContext));
         return {
             archived: true,
             sessionIds: archiveInputs.map((input) => input.sessionId),
@@ -2157,7 +2124,7 @@ export class PiSessionService {
             throw new Error("未找到会话");
         await this.closeActiveInScope(archived.sessionId, eventScopeFromManagementContext(managementContext));
         await this.archiveStore.restore(archived.sessionId);
-        await this.forgetUnreadSessions([archived]);
+        await this.forgetUnreadSessions([archived], eventScopeFromManagementContext(managementContext));
     }
     async deleteArchived(ref, managementContext) {
         const record = await this.getArchived(ref);
@@ -2169,7 +2136,7 @@ export class PiSessionService {
         if (record.archivePath === undefined)
             await this.ensureArchivedRecordMoved(record);
         await this.archiveStore.deleteArchived(record.sessionId);
-        await this.forgetUnreadSessions([record]);
+        await this.forgetUnreadSessions([record], eventScopeFromManagementContext(managementContext));
     }
     async deleteArchivedMany(refs, managementContext) {
         if (this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
@@ -2216,7 +2183,7 @@ export class PiSessionService {
                 failures.push({ sessionId, error: errorMessage(error) });
         }
         const deletedIdSet = new Set(deletedSessionIds);
-        await this.forgetUnreadSessions(readyRecords.filter((record) => deletedIdSet.has(record.sessionId)));
+        await this.forgetUnreadSessions(readyRecords.filter((record) => deletedIdSet.has(record.sessionId)), eventScopeFromManagementContext(managementContext));
         return {
             deleted: true,
             deletedSessionIds,
@@ -2241,19 +2208,19 @@ export class PiSessionService {
                 await this.closeActiveSession(active, priorGeneration === undefined ? CLEAR_RUNTIME_NOTIFICATIONS : DEFER_RUNTIME_NOTIFICATIONS);
                 candidateGeneration = priorGeneration === undefined
                     ? undefined
-                    : this.notificationStore.beginReplacement(priorGeneration, { sessionId, cwd });
+                    : this.notificationsForSession(session).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));
+                    this.publishNotificationMutations(this.notificationsForSession(session).commitReplacement(candidateGeneration));
                 }
                 return reopened.runtime.session;
             }
             catch (error) {
                 if (candidateGeneration !== undefined) {
-                    this.publishNotificationMutations(this.notificationStore.abortReplacement(candidateGeneration));
+                    this.publishNotificationMutations(this.notificationsForSession(session).abortReplacement(candidateGeneration));
                 }
                 throw error;
             }
@@ -2265,11 +2232,11 @@ export class PiSessionService {
         const sessionFile = session.sessionFile;
         if (sessionFile === undefined || sessionFile === "")
             throw new Error("会话尚未持久化");
-        await clearParentSession(sessionFile);
+        clearSessionFileParent(sessionFile);
         this.sessionManager.invalidateSessionFile?.(sessionFile);
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
-        await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }]);
+        await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }], this.eventScopeForSession(session));
     }
     async abort(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
@@ -2317,7 +2284,7 @@ export class PiSessionService {
             return;
         }
         if (isPiSessionRef(ref)) {
-            this.publishNotificationMutations(this.notificationStore.clearSessionIdentity(ref.id, canonicalizeStoredCwd(ref.cwd), "runtime-close"));
+            this.publishNotificationMutations(this.notificationsForScope(eventScopeFromManagementContext(managementContext)).clearSessionIdentity(ref.id, canonicalizeStoredCwd(ref.cwd), "runtime-close"));
         }
     }
     async bulkSessionLookupContext(refs) {
@@ -2494,17 +2461,17 @@ export class PiSessionService {
         }
         return [...names];
     }
-    async closeActive(sessionId, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS) {
+    async closeActive(sessionId, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS, eventScope = NORMAL_SESSION_EVENT_SCOPE) {
         for (const startup of this.startupSessions.values()) {
-            if (startup.session.sessionId === sessionId)
+            if (startup.session.sessionId === sessionId && startup.eventScope === eventScope)
                 this.endSessionExtensionDialogs(startup.session);
         }
         const pendingOpens = this.pendingSessionOpenPromises(sessionId);
         if (pendingOpens.length > 0)
             await Promise.allSettled(pendingOpens);
-        const activeSessions = this.activeSessionsForId(sessionId);
+        const activeSessions = this.activeSessionsForId(sessionId).filter((active) => active.eventScope === eventScope);
         if (activeSessions.length === 0 && notificationPolicy.kind === "clear") {
-            this.publishNotificationMutations(this.notificationStore.clearSession(sessionId, notificationPolicy.reason));
+            this.publishNotificationMutations(this.notificationsForScope(eventScope).clearSession(sessionId, notificationPolicy.reason));
             return;
         }
         await Promise.all(activeSessions.map((active) => this.closeActiveSession(active, notificationPolicy)));
@@ -2515,16 +2482,17 @@ export class PiSessionService {
             await this.closeActiveSession(active, notificationPolicy);
         }
         else if (notificationPolicy.kind === "clear") {
-            this.publishNotificationMutations(this.notificationStore.clearSession(sessionId, notificationPolicy.reason));
+            this.publishNotificationMutations(this.notificationsForScope(eventScope).clearSession(sessionId, notificationPolicy.reason));
         }
     }
     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 store = this.notificationsForScope(active.eventScope);
             const mutations = generation === undefined
-                ? this.notificationStore.clearSession(sessionId, notificationPolicy.reason)
-                : this.notificationStore.clearGeneration(generation, notificationPolicy.reason);
+                ? store.clearSession(sessionId, notificationPolicy.reason)
+                : store.clearGeneration(generation, notificationPolicy.reason);
             this.publishNotificationMutations(mutations);
         }
         this.forgetUnreadActivity(active.runtime.session);
@@ -2757,6 +2725,7 @@ export class PiSessionService {
         }
     }
     bindRuntime(active, session = active.runtime.session) {
+        this.sessionEventScopes.set(session, active.eventScope);
         this.runtimeBySession.set(session, active.runtime);
         active.unsubscribe();
         for (const [sessionId, candidate] of this.active.entries()) {
@@ -3264,6 +3233,9 @@ export class PiSessionService {
         return this.activities.get(activeSessionKey(session.sessionId, this.eventScopeForSession(session)));
     }
     eventScopeForSession(session) {
+        const boundScope = this.sessionEventScopes.get(session);
+        if (boundScope !== undefined)
+            return boundScope;
         for (const active of this.active.values()) {
             if (active.runtime.session === session)
                 return active.eventScope;
@@ -3338,41 +3310,60 @@ export class PiSessionService {
     hasQueuedMessageText(session, text) {
         return queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)).some((message) => message.text === text);
     }
-    notificationCatalog() {
-        return this.notificationStore.catalogSnapshot();
+    notificationsForScope(scope) {
+        if (scope === NORMAL_SESSION_EVENT_SCOPE)
+            return this.notificationStore;
+        let store = this.scopedNotificationStores.get(scope);
+        if (store === undefined) {
+            store = new SessionNotificationStore({ eventScope: scope, now: this.now });
+            this.scopedNotificationStores.set(scope, store);
+        }
+        return store;
+    }
+    notificationsForSession(session) {
+        return this.notificationsForScope(this.eventScopeForSession(session));
     }
-    async unreadCatalog() {
+    unreadForScope(scope) {
+        if (scope === NORMAL_SESSION_EVENT_SCOPE)
+            return this.unreadStore;
+        let store = this.scopedUnreadStores.get(scope);
+        if (store === undefined) {
+            store = new SessionUnreadStore({ eventScope: scope, now: this.now });
+            this.scopedUnreadStores.set(scope, store);
+        }
+        return store;
+    }
+    notificationCatalog(context) {
+        return this.notificationsForScope(eventScopeFromManagementContext(context)).catalogSnapshot();
+    }
+    async unreadCatalog(context) {
         await this.publishUnreadMutations([]);
-        return this.unreadStore.durableCatalogSnapshot();
+        return this.unreadForScope(eventScopeFromManagementContext(context)).durableCatalogSnapshot();
     }
-    /** Scope-filtered unread view used only by the daemon-owned status tree. */
+    /** The status tree and HTTP catalog must read the same scoped store. */
     async unreadCatalogForScope(eventScope) {
-        const catalog = await this.unreadCatalog();
-        if (eventScope === NORMAL_SESSION_EVENT_SCOPE)
-            return catalog;
-        const visible = new Set([...this.active.values()]
-            .filter((active) => active.eventScope === eventScope)
-            .map((active) => active.runtime.session.sessionId));
-        return { ...catalog, sessions: catalog.sessions.filter((session) => visible.has(session.sessionId)) };
-    }
-    async acknowledgeUnread(sessionId, request) {
-        const result = this.unreadStore.acknowledge(sessionId, {
+        await this.publishUnreadMutations([]);
+        return this.unreadForScope(eventScope).durableCatalogSnapshot();
+    }
+    async acknowledgeUnread(sessionId, request, context) {
+        const store = this.unreadForScope(eventScopeFromManagementContext(context));
+        const result = store.acknowledge(sessionId, {
             ...request,
             cwd: canonicalizeStoredCwd(request.cwd),
         });
         await this.publishUnreadMutations(result.mutations);
-        return this.unreadStore.durableCatalogSnapshot();
+        return store.durableCatalogSnapshot();
     }
-    notificationInbox(ref) {
-        return this.notificationStore.inboxSnapshot(ref.id, canonicalizeStoredCwd(ref.cwd));
+    notificationInbox(ref, context) {
+        return this.notificationsForScope(eventScopeFromManagementContext(context)).inboxSnapshot(ref.id, canonicalizeStoredCwd(ref.cwd));
     }
-    dismissNotification(ref, request) {
-        const result = this.notificationStore.dismissNotification(ref.id, canonicalizeStoredCwd(ref.cwd), request.daemonInstanceId, request.notificationId);
+    dismissNotification(ref, request, context) {
+        const result = this.notificationsForScope(eventScopeFromManagementContext(context)).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);
+    dismissAllNotifications(ref, request, context) {
+        const result = this.notificationsForScope(eventScopeFromManagementContext(context)).dismissAll(ref.id, canonicalizeStoredCwd(ref.cwd), request.daemonInstanceId, request.throughOrder, request.throughOverflowWatermark);
         this.publishNotificationMutations(result.mutations);
         return result.snapshot;
     }
@@ -3393,20 +3384,20 @@ export class PiSessionService {
             try {
                 await session.reload(priorGeneration === undefined ? undefined : {
                     beforeSessionStart: () => {
-                        candidateGeneration = this.notificationStore.beginReplacement(priorGeneration, notificationIdentityForSession(session));
+                        candidateGeneration = this.notificationsForSession(session).beginReplacement(priorGeneration, notificationIdentityForSession(session));
                         this.notificationGenerationBySession.set(session, candidateGeneration);
                         this.replaceSessionNotificationContext(session, candidateGeneration);
                     },
                 });
                 if (candidateGeneration !== undefined) {
-                    this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
+                    this.publishNotificationMutations(this.notificationsForSession(session).commitReplacement(candidateGeneration));
                 }
                 this.publishActivity(session, "资源已重新加载", "idle");
                 this.publishStatus(session);
             }
             catch (error) {
                 if (candidateGeneration !== undefined) {
-                    this.publishNotificationMutations(this.notificationStore.abortReplacement(candidateGeneration, "candidate"));
+                    this.publishNotificationMutations(this.notificationsForSession(session).abortReplacement(candidateGeneration, "candidate"));
                     this.notificationGenerationBySession.set(session, candidateGeneration);
                 }
                 const message = error instanceof Error ? error.message : String(error);
@@ -3468,6 +3459,8 @@ export class PiSessionService {
             }),
         };
         let boundSession = runtime.session;
+        this.sessionEventScopes.set(boundSession, active.eventScope);
+        const notificationStore = this.notificationsForScope(active.eventScope);
         let notificationGeneration = options.notificationGeneration;
         let notificationOwnership = options.notifications === "disabled"
             ? "disabled"
@@ -3476,13 +3469,13 @@ export class PiSessionService {
                 : "external";
         if (notificationOwnership === "registered") {
             const notificationIdentity = notificationIdentityForSession(runtime.session);
-            const existingCandidate = this.notificationStore.beginReplacementForSession(notificationIdentity.sessionId, notificationIdentity.cwd);
+            const existingCandidate = notificationStore.beginReplacementForSession(notificationIdentity.sessionId, notificationIdentity.cwd);
             if (existingCandidate !== undefined) {
                 notificationGeneration = existingCandidate;
                 notificationOwnership = "replacement";
             }
             else {
-                const registration = this.notificationStore.registerSession(notificationIdentity.sessionId, notificationIdentity.cwd);
+                const registration = notificationStore.registerSession(notificationIdentity.sessionId, notificationIdentity.cwd);
                 notificationGeneration = registration.generation;
                 this.publishNotificationMutations(registration.mutations);
             }
@@ -3491,7 +3484,7 @@ export class PiSessionService {
             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())));
+                await this.publishUnreadMutations(this.unreadForScope(active.eventScope).excludeSession(runtime.session.sessionId, canonicalizeStoredCwd(runtime.session.sessionManager.getCwd())));
             }
             else {
                 await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
@@ -3500,13 +3493,14 @@ export class PiSessionService {
             await this.bindSessionExtensions(runtime.session, notificationGeneration, active);
             this.bindRuntime(active);
             runtime.setRebindSession(async (session) => {
+                this.sessionEventScopes.set(session, active.eventScope);
                 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));
+                        candidateGeneration = notificationStore.beginReplacement(priorGeneration, notificationIdentityForSession(session));
                         this.notificationGenerationBySession.set(session, candidateGeneration);
                     }
                     this.bindRuntime(active, session);
@@ -3517,13 +3511,13 @@ export class PiSessionService {
                     boundSession = session;
                     await this.bindSessionExtensions(session, candidateGeneration, active);
                     if (candidateGeneration !== undefined) {
-                        this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
+                        this.publishNotificationMutations(notificationStore.commitReplacement(candidateGeneration));
                         notificationGeneration = candidateGeneration;
                     }
                 }
                 catch (error) {
                     if (candidateGeneration !== undefined) {
-                        this.publishNotificationMutations(this.notificationStore.abortReplacement(candidateGeneration, "candidate"));
+                        this.publishNotificationMutations(notificationStore.abortReplacement(candidateGeneration, "candidate"));
                         notificationGeneration = candidateGeneration;
                         this.notificationGenerationBySession.set(session, candidateGeneration);
                     }
@@ -3532,7 +3526,7 @@ export class PiSessionService {
             });
             this.active.set(activeSessionKey(runtime.session.sessionId, active.eventScope), active);
             if (notificationOwnership === "replacement" && notificationGeneration !== undefined) {
-                this.publishNotificationMutations(this.notificationStore.commitReplacement(notificationGeneration));
+                this.publishNotificationMutations(notificationStore.commitReplacement(notificationGeneration));
                 notificationOwnership = "external";
             }
             this.publishStatus(runtime.session);
@@ -3541,10 +3535,10 @@ export class PiSessionService {
         catch (error) {
             if (notificationGeneration !== undefined) {
                 if (notificationOwnership === "registered") {
-                    this.publishNotificationMutations(this.notificationStore.clearSession(runtime.session.sessionId, "initialization-failed"));
+                    this.publishNotificationMutations(notificationStore.clearSession(runtime.session.sessionId, "initialization-failed"));
                 }
                 else if (notificationOwnership === "replacement") {
-                    this.publishNotificationMutations(this.notificationStore.abortReplacement(notificationGeneration));
+                    this.publishNotificationMutations(notificationStore.abortReplacement(notificationGeneration));
                 }
             }
             active.unsubscribe();
@@ -3577,16 +3571,18 @@ export class PiSessionService {
     }
     sessionUiContext(session, generation) {
         const baseUiContext = session.extensionRunner.getUIContext();
+        const eventScope = this.eventScopeForSession(session);
+        const notificationStore = this.notificationsForScope(eventScope);
         const notify = (message, type) => {
             if (generation === undefined) {
                 this.events.publish(session.sessionId, {
                     type: "command.output",
                     level: type === "error" ? "error" : "info",
                     message,
-                });
+                }, eventScope);
                 return;
             }
-            const added = this.notificationStore.addNotification(generation, message, type);
+            const added = notificationStore.addNotification(generation, message, type);
             this.publishNotificationMutations(added.mutations);
             if (added.notification === undefined)
                 return;
@@ -3595,7 +3591,7 @@ export class PiSessionService {
                 level: type === "error" ? "error" : "info",
                 message,
                 notificationId: added.notification.id,
-            });
+            }, eventScope);
         };
         // PI WEB owns the browser-facing dialog, notification, and text-formatting
         // boundaries: the three dialog primitives park daemon-held Promises that
@@ -3624,35 +3620,32 @@ export class PiSessionService {
     }
     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);
-            }
+            const scope = mutation.eventScope ?? NORMAL_SESSION_EVENT_SCOPE;
+            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 store = this.unreadForScope(this.eventScopeForSession(previous));
+        store.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));
+        await this.publishUnreadMutations(store.forgetSession(previous.sessionId, previousCwd));
     }
     forgetUnreadActivity(session) {
-        this.unreadStore.forgetActivity(session.sessionId, canonicalizeStoredCwd(session.sessionManager.getCwd()));
+        this.unreadForScope(this.eventScopeForSession(session)).forgetActivity(session.sessionId, canonicalizeStoredCwd(session.sessionManager.getCwd()));
     }
-    async forgetUnreadSessions(identities) {
+    async forgetUnreadSessions(identities, scope = NORMAL_SESSION_EVENT_SCOPE) {
         const mutations = [];
         for (const identity of identities) {
-            mutations.push(...this.unreadStore.forgetSession(identity.sessionId, canonicalizeStoredCwd(identity.cwd)));
+            mutations.push(...this.unreadForScope(scope).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));
+        const mutations = this.unreadForScope(this.eventScopeForSession(session)).observeActivityState(session.sessionId, canonicalizeStoredCwd(session.sessionManager.getCwd()), this.hasActiveWork(session));
         if (mutations.length === 0)
             return;
         void this.publishUnreadMutations(mutations).catch(() => undefined);
@@ -3661,11 +3654,7 @@ export class PiSessionService {
         if (mutations.length > 0) {
             const scopes = new Set();
             for (const mutation of mutations) {
-                const activeScopes = this.activeSessionsForId(mutation.event.sessionId).map((active) => active.eventScope);
-                if (activeScopes.length === 0)
-                    scopes.add(NORMAL_SESSION_EVENT_SCOPE);
-                else
-                    activeScopes.forEach((scope) => scopes.add(scope));
+                scopes.add(mutation.eventScope ?? NORMAL_SESSION_EVENT_SCOPE);
             }
             scopes.forEach((scope) => this.onUnreadChanged?.(scope));
         }
@@ -3704,8 +3693,10 @@ export class PiSessionService {
             let publishedCount = 0;
             try {
                 await this.unreadStore.flush();
+                for (const store of this.scopedUnreadStores.values())
+                    await store.flush();
                 for (const mutation of batch) {
-                    this.events.publishGlobal(mutation.event);
+                    this.events.publishGlobal(mutation.event, mutation.eventScope ?? NORMAL_SESSION_EVENT_SCOPE);
                     publishedCount += 1;
                 }
             }
@@ -4040,19 +4031,6 @@ async function sessionFileHeaderMatches(sessionFile, expected) {
         return true;
     return header.parentSession !== undefined && sessionPathsEqual(header.parentSession, expected.parentSessionFile);
 }
-async function clearParentSession(sessionFile) {
-    const content = await readFile(sessionFile, "utf8");
-    const newlineIndex = content.indexOf("\n");
-    const firstLine = newlineIndex === -1 ? content : content.slice(0, newlineIndex);
-    const rest = newlineIndex === -1 ? "" : content.slice(newlineIndex);
-    const header = JSON.parse(firstLine);
-    if (!isRecord(header) || header["type"] !== "session")
-        throw new Error("Invalid session file header");
-    if (header["parentSession"] === undefined)
-        return;
-    delete header["parentSession"];
-    await writeFile(sessionFile, `${JSON.stringify(header)}${rest}`, "utf8");
-}
 function clearParentSessionHeader(sessionManager) {
     const header = sessionManager.getHeader?.();
     if (header !== undefined && header !== null)