@chainingintention/pi-web-cn 1.202607.2 → 1.202607.3

package/dist/server/sessions/piSessionService.js

@@ -2,6 +2,7 @@ import { open, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { AuthStorage, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, getAgentDir, ModelRegistry, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
+import { authScopeFromEventScope, eventScopeFromManagementContext, managementContextKey, NORMAL_SESSION_EVENT_SCOPE } from "../realtime/sessionEventScope.js";
 import { BUILTIN_COMMANDS } from "./builtinCommands.js";
 import { SessionCommandService } from "./sessionCommandService.js";
 import { SessionArchiveStore } from "./sessionArchiveStore.js";
@@ -29,8 +30,8 @@ function spawnTargetError(decision) {
         return new Error("派生会话不在已注册项目中");
     return new Error(`cwd 必须是此项目的工作区。允许的路径：${decision.allowedCwds.join(", ")}`);
 }
-function authLossWarningKey(sessionId, provider, modelId) {
-    return `${sessionId}:${provider}/${modelId}`;
+function authLossWarningKey(sessionId, eventScope, provider, modelId) {
+    return `${eventScope}:${sessionId}:${provider}/${modelId}`;
 }
 function sessionIdFromLookup(ref) {
     return typeof ref === "string" ? ref : ref.id;
@@ -41,15 +42,8 @@ function isPiSessionRef(ref) {
 function lookupMatchesActiveSession(ref, active) {
     return !isPiSessionRef(ref) || cwdPathsEqual(active.runtime.cwd, ref.cwd);
 }
-function managementContextKey(context) {
-    if (context === undefined)
-        return undefined;
-    return JSON.stringify({
-        userId: context.user.id,
-        rootUserId: context.user.rootUserId,
-        projects: context.projects.map((project) => project.id).sort(),
-        sandboxEnv: context.sandbox?.env ?? {},
-    });
+function activeSessionKey(sessionId, eventScope) {
+    return `${eventScope}\0${sessionId}`;
 }
 function requirePromptText(value) {
     if (typeof value !== "string")
@@ -107,10 +101,12 @@ function createRuntimeWithContextAndOneShotInitialModel(createRuntime, managemen
         });
     };
 }
-function createDefaultRuntimeFactory(authStorage, modelRegistry, spawn, subsessions) {
+function createDefaultRuntimeFactory(modelRegistry, managementModelRegistry, spawn, subsessions) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel }) => {
+        const scopedModelRegistry = managementContext === undefined ? modelRegistry : managementModelRegistry;
+        const authStorage = scopedModelRegistry.authStorage;
         if (managementContext !== undefined) {
-            return createManagementRuntimeFactory(authStorage, modelRegistry, spawn, subsessions, managementContext)({
+            return createManagementRuntimeFactory(authStorage, scopedModelRegistry, spawn, subsessions, managementContext)({
                 cwd,
                 agentDir,
                 sessionManager,
@@ -118,7 +114,7 @@ function createDefaultRuntimeFactory(authStorage, modelRegistry, spawn, subsessi
                 ...(initialModel === undefined ? {} : { initialModel }),
             });
         }
-        const services = await createAgentSessionServices({ cwd, agentDir, authStorage, modelRegistry });
+        const services = await createAgentSessionServices({ cwd, agentDir, authStorage, modelRegistry: scopedModelRegistry });
         const customTools = [
             ...managedAgentToolDefinitions(cwd),
             ...(spawn === undefined ? [] : [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))]),
@@ -226,13 +222,14 @@ export class PiSessionService {
         this.agentDir = deps.agentDir ?? getAgentDir();
         this.sessionManager = deps.sessionManager ?? createPiSessionManagerGateway({ agentDir: this.agentDir });
         this.modelRegistry = deps.modelRegistry ?? ModelRegistry.create(AuthStorage.create());
+        this.managementModelRegistry = deps.managementModelRegistry ?? this.modelRegistry;
         this.spawnTargets = deps.spawnTargets;
         this.logger = deps.logger ?? noopLogger;
         this.now = deps.now ?? (() => new Date());
         // 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;
-        this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.modelRegistry.authStorage, this.modelRegistry, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
+        this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.modelRegistry, this.managementModelRegistry, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
             spawn: (input) => this.spawnSubsession(input),
             list: (parentSessionId, parentSessionFile) => this.listSubsessions(parentSessionId, parentSessionFile),
             check: (parentSessionId, sessionId, parentSessionFile) => this.checkSubsession(parentSessionId, sessionId, parentSessionFile),
@@ -241,7 +238,7 @@ export class PiSessionService {
         this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
         this.workspaceActivity = deps.workspaceActivity;
         this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
-        this.commandService = new SessionCommandService((sessionId) => this.getActive(sessionId), (sessionId, text) => this.prompt(sessionId, text, undefined, undefined, { echoUserMessage: false }), events, {
+        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.publishStatus(session);
@@ -311,12 +308,12 @@ export class PiSessionService {
         this.subsessionNotifyArmed.clear();
         await Promise.all(activeSessions.map(async (active) => {
             active.unsubscribe();
-            this.workspaceActivity?.removeSession(active.runtime.session.sessionId, active.runtime.session.sessionManager.getCwd());
+            this.workspaceActivity?.removeSession(active.runtime.session.sessionId, active.runtime.session.sessionManager.getCwd(), active.eventScope);
             await active.runtime.session.abort();
             await active.runtime.dispose();
         }));
     }
-    async list(cwd) {
+    async list(cwd, managementContext) {
         const [sessions, archivedRecords] = await Promise.all([this.sessionManager.list(cwd), this.archiveStore.list()]);
         const sessionsById = new Map(sessions.map((session) => [session.id, session]));
         const archivedForCwd = await Promise.all(archivedRecords
@@ -324,7 +321,7 @@ export class PiSessionService {
             .map((record) => this.ensureArchivedSessionMoved(record, sessionsById.get(record.sessionId))));
         const archivedById = new Map(archivedForCwd.map((record) => [record.sessionId, record]));
         const unarchivedSessions = sessions.filter((session) => !archivedById.has(session.id)).map(clientSessionFromListEntry);
-        this.workspaceActivity?.reconcileSessionActivity(cwd, this.reconcilableSessionIds(cwd, unarchivedSessions.map((session) => session.id), archivedById));
+        this.workspaceActivity?.reconcileSessionActivity(cwd, this.reconcilableSessionIds(cwd, unarchivedSessions.map((session) => session.id), archivedById), eventScopeFromManagementContext(managementContext));
         const archivedSessions = archivedForCwd
             .sort(compareArchivedRecords)
             .map((record) => clientSessionFromArchivedRecord(record, sessionsById.get(record.sessionId)))
@@ -351,7 +348,7 @@ export class PiSessionService {
         };
         // Broadcast so other clients (and the spawning agent's UI) can add the new
         // session to their list without a manual reload.
-        this.events.publishGlobal({ type: "session.created", session: created });
+        this.events.publishGlobal({ type: "session.created", session: created }, active.eventScope);
         return created;
     }
     /**
@@ -450,16 +447,10 @@ export class PiSessionService {
         return parentSessionFile === undefined || trackedLinkParentFileMatches(link, parentSessionFile);
     }
     activeChildForSubsessionLink(link) {
-        const active = this.active.get(link.childSessionId);
-        if (active === undefined)
-            return undefined;
-        return activeSessionFileMatches(active, link.childSessionFile) ? active : undefined;
+        return this.activeSessionsForId(link.childSessionId).find((active) => activeSessionFileMatches(active, link.childSessionFile));
     }
     activeParentForSubsessionLink(link) {
-        const active = this.active.get(link.parentSessionId);
-        if (active === undefined)
-            return undefined;
-        return activeSessionFileMatches(active, link.parentSessionFile) ? active : undefined;
+        return this.activeSessionsForId(link.parentSessionId).find((active) => activeSessionFileMatches(active, link.parentSessionFile));
     }
     subsessionLinkForActiveChild(session) {
         const childId = session.sessionId;
@@ -512,7 +503,7 @@ export class PiSessionService {
         }
     }
     persistSubsessionChildMarker(parentSessionId, childSessionId) {
-        const child = this.active.get(childSessionId)?.runtime.session;
+        const child = this.activeForSessionId(childSessionId)?.runtime.session;
         if (child === undefined)
             return;
         if (child.sessionManager.appendCustomEntry === undefined)
@@ -528,7 +519,7 @@ export class PiSessionService {
         const hydrationKey = subsessionHydratedParentKey(parentSessionId, parentSessionFile);
         if (this.subsessionHydratedParents.has(hydrationKey))
             return;
-        const activeParent = this.active.get(parentSessionId);
+        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);
@@ -672,7 +663,7 @@ export class PiSessionService {
     subsessionStatus(session) {
         if (this.hasActiveWork(session))
             return "working";
-        if (this.activities.get(session.sessionId)?.phase === "error")
+        if (this.activityForSession(session)?.phase === "error")
             return "error";
         return "idle";
     }
@@ -694,7 +685,7 @@ export class PiSessionService {
         if (this.subsessionNotifyArmed.get(childId) !== true)
             return;
         this.subsessionNotifyArmed.set(childId, false);
-        const status = this.activities.get(childId)?.phase === "error" ? "error" : "idle";
+        const status = this.activityForSession(session)?.phase === "error" ? "error" : "idle";
         const finalText = finalAssistantText(historyMessages(session));
         const preview = finalText === "" ? "(no output)" : truncateForNotification(finalText);
         const text = `Subsession ${childId} stopped working (status: ${status}). Latest output:\n\n${preview}\n\nUse check_subsession with sessionId "${childId}" for its status and latest output, or read_subsession to look through its full transcript.`;
@@ -844,13 +835,14 @@ export class PiSessionService {
     }
     submitPrompt(session, text, behavior, images = [], echoUserMessage = true) {
         this.publishActivity(session, behavior === "steer" ? "steering queued" : behavior === "followUp" ? "message queued" : "prompt accepted", "active");
+        const eventScope = this.eventScopeForSession(session);
         if (behavior === undefined && echoUserMessage)
-            this.events.publish(session.sessionId, { type: "message.append", message: userMessage(text, images) });
+            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 message = error instanceof Error ? error.message : String(error);
             this.publishActivity(session, "error", "error", message);
-            this.events.publish(session.sessionId, { type: "session.error", message });
+            this.events.publish(session.sessionId, { type: "session.error", message }, eventScope);
         });
         void promptPromise;
         return promptPromise;
@@ -862,12 +854,12 @@ export class PiSessionService {
         this.publishActivity(session, "message queued during compaction", "active");
         this.publishStatus(session);
     }
-    async saveAttachments(ref, attachments, folder) {
+    async saveAttachments(ref, attachments, folder, managementContext) {
         const parsed = parsePromptAttachments(attachments, { enforceInlineSizeLimit: false, allowFileAttachments: true });
         if (parsed.length === 0)
             return [];
         await this.assertWritable(ref);
-        const active = await this.getActive(ref);
+        const active = await this.getActive(ref, managementContext);
         return saveAttachmentsToWorkspace(active.runtime.cwd, parsed, folder === undefined ? {} : { folder });
     }
     async shell(ref, text, managementContext) {
@@ -880,10 +872,11 @@ export class PiSessionService {
             throw new Error("用法：!<shell command>");
         if (session.isBashRunning)
             throw new Error("已有 bash 命令正在运行");
+        const eventScope = active.eventScope;
         this.publishActivity(session, "running bash", "active", command);
-        this.events.publish(session.sessionId, { type: "shell.start", command, excludeFromContext: isExcluded });
+        this.events.publish(session.sessionId, { type: "shell.start", command, excludeFromContext: isExcluded }, eventScope);
         void session.executeBash(command, (chunk) => {
-            this.events.publish(session.sessionId, { type: "shell.chunk", chunk });
+            this.events.publish(session.sessionId, { type: "shell.chunk", chunk }, eventScope);
             this.publishActivity(session, "running bash", "active", command);
             this.publishStatus(session);
         }, { excludeFromContext: isExcluded }).then((result) => {
@@ -894,13 +887,13 @@ export class PiSessionService {
                 cancelled: result.cancelled,
                 truncated: result.truncated,
                 ...(result.fullOutputPath === undefined ? {} : { fullOutputPath: result.fullOutputPath }),
-            });
+            }, eventScope);
             this.publishActivity(session, "bash complete", 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 });
-            this.events.publish(session.sessionId, { type: "session.error", message });
+            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.publishStatus(session);
         });
@@ -908,22 +901,23 @@ export class PiSessionService {
     async runCommand(ref, text, managementContext) {
         await this.assertWritable(ref);
         const active = await this.getActive(ref, managementContext);
-        return this.commandService.run(active.runtime.session.sessionId, text);
+        return this.commandService.run(active.runtime.session.sessionId, text, active.eventScope);
     }
-    async respondToCommand(ref, requestId, value) {
+    async respondToCommand(ref, requestId, value, managementContext) {
         await this.assertWritable(ref);
-        const active = await this.getActive(ref);
-        return this.commandService.respond(active.runtime.session.sessionId, requestId, value);
+        const active = await this.getActive(ref, managementContext);
+        return this.commandService.respond(active.runtime.session.sessionId, requestId, value, active.eventScope);
     }
-    async archive(ref) {
-        const session = await this.getOrOpen(ref);
+    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.closeActive(session.sessionId);
+        await this.closeActiveSession(active);
         await this.archiveStore.archive(archiveInput);
     }
-    async archiveMany(refs) {
+    async archiveMany(refs, managementContext) {
         const uniqueRefs = uniqueBulkSessionRefs(refs);
         const [archivedRecords, sessionContext] = await Promise.all([
             this.archiveStore.list(),
@@ -938,7 +932,7 @@ export class PiSessionService {
                 alreadyArchivedSessionIds.push(archived.sessionId);
                 continue;
             }
-            const active = this.activeForLookup(bulkRefToLookup(ref));
+            const active = this.activeForLookup(bulkRefToLookup(ref), managementContext);
             const listed = findListedSessionForBulkRef(sessionContext, ref);
             const resolvedSessionId = active?.runtime.session.sessionId ?? listed?.id ?? ref.id;
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
@@ -947,10 +941,10 @@ export class PiSessionService {
             }
             try {
                 if (listed !== undefined) {
-                    planItems.push({ input: archiveInputFromListEntry(listed) });
+                    planItems.push({ input: archiveInputFromListEntry(listed), ...(active === undefined ? {} : { active }) });
                 }
                 else if (active !== undefined) {
-                    planItems.push({ input: archiveInputFromActiveSession(active.runtime.session) });
+                    planItems.push({ input: archiveInputFromActiveSession(active.runtime.session), active });
                 }
                 else {
                     failures.push({ sessionId: ref.id, error: "Session not found" });
@@ -963,7 +957,10 @@ export class PiSessionService {
         const readyInputs = [];
         for (const item of planItems) {
             try {
-                await this.closeActive(item.input.sessionId);
+                if (item.active !== undefined)
+                    await this.closeActiveSession(item.active);
+                else
+                    await this.closeActiveInScope(item.input.sessionId, eventScopeFromManagementContext(managementContext));
                 readyInputs.push(item.input);
             }
             catch (error) {
@@ -986,8 +983,8 @@ export class PiSessionService {
             generatedAt: new Date().toISOString(),
         };
     }
-    async archiveTree(ref) {
-        const session = await this.getOrOpen(ref);
+    async archiveTree(ref, managementContext) {
+        const session = await this.getOrOpen(ref, managementContext);
         const catalog = await this.workspaceArchiveCandidates(session.sessionManager.getCwd());
         const root = findArchiveCandidateByIdOrPrefix(catalog, session.sessionId) ?? archiveCandidateFromActiveSession(session, false);
         const plan = planSessionArchiveTree(root, catalog);
@@ -996,7 +993,7 @@ export class PiSessionService {
             throw new Error(`归档 ${sessionDisplayName(busy)} 前请先停止当前会话活动`);
         const archiveInputs = plan.unarchivedTargets.map((target) => archiveInputFromCandidate(target));
         for (const input of archiveInputs)
-            await this.closeActive(input.sessionId);
+            await this.closeActiveInScope(input.sessionId, eventScopeFromManagementContext(managementContext));
         await this.archiveStoreArchiveMany(archiveInputs);
         return {
             archived: true,
@@ -1005,25 +1002,25 @@ export class PiSessionService {
             skippedAlreadyArchivedCount: plan.skippedAlreadyArchivedCount,
         };
     }
-    async restore(ref) {
+    async restore(ref, managementContext) {
         const archived = await this.getArchived(ref);
         if (archived === undefined)
             throw new Error("未找到会话");
-        await this.closeActive(archived.sessionId);
+        await this.closeActiveInScope(archived.sessionId, eventScopeFromManagementContext(managementContext));
         await this.archiveStore.restore(archived.sessionId);
     }
-    async deleteArchived(ref) {
+    async deleteArchived(ref, managementContext) {
         const record = await this.getArchived(ref);
         if (record === undefined)
             throw new Error("未找到已归档会话");
         if (this.archiveStore.deleteArchived === undefined)
             throw new Error("归档存储不支持删除");
-        await this.closeActive(record.sessionId);
+        await this.closeActiveInScope(record.sessionId, eventScopeFromManagementContext(managementContext));
         if (record.archivePath === undefined)
             await this.ensureArchivedRecordMoved(record);
         await this.archiveStore.deleteArchived(record.sessionId);
     }
-    async deleteArchivedMany(refs) {
+    async deleteArchivedMany(refs, managementContext) {
         if (this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
         const uniqueRefs = uniqueBulkSessionRefs(refs);
@@ -1036,7 +1033,7 @@ export class PiSessionService {
                 failures.push({ sessionId: ref.id, error: "Archived session not found" });
                 continue;
             }
-            const active = this.activeForLookup({ id: record.sessionId, cwd: record.cwd });
+            const active = this.activeForLookup({ id: record.sessionId, cwd: record.cwd }, managementContext);
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
                 failures.push({ sessionId: record.sessionId, error: "Stop current session activity before deleting archived session" });
                 continue;
@@ -1046,7 +1043,7 @@ export class PiSessionService {
         const readyRecords = [];
         for (const item of planItems) {
             try {
-                await this.closeActive(item.record.sessionId);
+                await this.closeActiveInScope(item.record.sessionId, eventScopeFromManagementContext(managementContext));
                 readyRecords.push(item.record);
             }
             catch (error) {
@@ -1074,17 +1071,18 @@ export class PiSessionService {
             generatedAt: new Date().toISOString(),
         };
     }
-    async reload(ref) {
+    async reload(ref, managementContext) {
         await this.assertWritable(ref);
-        const session = await this.getOrOpen(ref);
+        const active = await this.getActive(ref, managementContext);
+        const session = active.runtime.session;
         if (this.hasActiveWork(session))
             throw new Error("重新加载前请先停止当前会话活动");
-        await this.closeActive(session.sessionId);
-        const reopened = await this.getActive(ref);
+        await this.closeActiveSession(active);
+        const reopened = await this.getActive(ref, managementContext);
         this.publishStatus(reopened.runtime.session);
     }
-    async detachParent(ref) {
-        const session = await this.getOrOpen(ref);
+    async detachParent(ref, managementContext) {
+        const session = await this.getOrOpen(ref, managementContext);
         const sessionFile = session.sessionFile;
         if (sessionFile === undefined || sessionFile === "")
             throw new Error("会话尚未持久化");
@@ -1092,8 +1090,8 @@ export class PiSessionService {
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
     }
-    async abort(ref) {
-        const active = this.activeForLookupAny(ref);
+    async abort(ref, managementContext) {
+        const active = this.activeForLookup(ref, managementContext);
         if (active === undefined)
             return;
         const sessionId = active.runtime.session.sessionId;
@@ -1103,11 +1101,11 @@ export class PiSessionService {
         this.publishActivity(active.runtime.session, "stopped", "idle");
         this.publishStatus(active.runtime.session);
     }
-    stop(ref) {
-        const active = this.activeForLookupAny(ref);
+    stop(ref, managementContext) {
+        const active = this.activeForLookup(ref, managementContext);
         if (active === undefined)
             return;
-        void this.closeActive(active.runtime.session.sessionId).catch(() => {
+        void this.closeActiveSession(active).catch(() => {
             // Best-effort shutdown; callers that need errors await closeActive directly.
         });
     }
@@ -1198,8 +1196,7 @@ export class PiSessionService {
         }));
     }
     activeSessionHasWork(sessionId) {
-        const active = this.active.get(sessionId);
-        return active !== undefined && this.hasActiveWork(active.runtime.session);
+        return this.activeSessionsForId(sessionId).some((active) => this.hasActiveWork(active.runtime.session));
     }
     reconcilableSessionIds(cwd, listedSessionIds, archivedById) {
         const sessionIds = new Set(listedSessionIds);
@@ -1211,7 +1208,7 @@ export class PiSessionService {
         return [...sessionIds];
     }
     async ensureArchivedSessionMoved(record, session) {
-        if (session === undefined || this.active.has(record.sessionId))
+        if (session === undefined || this.activeSessionsForId(record.sessionId).length > 0)
             return record;
         try {
             return await this.archiveStore.archive(archiveInputFromListEntry(session));
@@ -1299,12 +1296,19 @@ export class PiSessionService {
         return [...names];
     }
     async closeActive(sessionId) {
-        const active = this.active.get(sessionId);
-        if (!active)
-            return;
-        this.active.delete(sessionId);
-        this.activities.delete(sessionId);
-        this.workspaceActivity?.removeSession(sessionId, active.runtime.session.sessionManager.getCwd());
+        const activeSessions = this.activeSessionsForId(sessionId);
+        await Promise.all(activeSessions.map((active) => this.closeActiveSession(active)));
+    }
+    async closeActiveInScope(sessionId, eventScope) {
+        const active = this.activeForSessionIdAndScope(sessionId, eventScope);
+        if (active !== undefined)
+            await this.closeActiveSession(active);
+    }
+    async closeActiveSession(active) {
+        const sessionId = active.runtime.session.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);
         this.clearAuthLossWarningsForSession(sessionId);
         this.clearCompactionPromptQueue(sessionId);
         // Disarm subsession notification before teardown so the abort below cannot
@@ -1332,9 +1336,6 @@ export class PiSessionService {
         const active = this.activeForLookup(ref, managementContext);
         if (active !== undefined)
             return active;
-        const mismatched = this.activeForLookupAny(ref);
-        if (mismatched !== undefined)
-            await this.closeActive(mismatched.runtime.session.sessionId);
         const archived = await this.getArchived(ref);
         if (archived?.archivePath !== undefined) {
             return this.create(this.sessionManager.open(archived.archivePath), archived.cwd, managementContext === undefined ? {} : { managementContext });
@@ -1356,11 +1357,13 @@ export class PiSessionService {
     }
     activeForLookup(ref, managementContext) {
         const key = managementContextKey(managementContext);
+        const eventScope = eventScopeFromManagementContext(managementContext);
         const sessionId = sessionIdFromLookup(ref);
-        const exact = this.active.get(sessionId);
+        const exact = this.active.get(activeSessionKey(sessionId, eventScope));
         if (exact !== undefined && lookupMatchesActiveSession(ref, exact) && exact.managementContextKey === key)
             return exact;
-        for (const [candidateId, active] of this.active.entries()) {
+        for (const active of this.active.values()) {
+            const candidateId = active.runtime.session.sessionId;
             if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active) && active.managementContextKey === key)
                 return active;
         }
@@ -1368,15 +1371,39 @@ export class PiSessionService {
     }
     activeForLookupAny(ref) {
         const sessionId = sessionIdFromLookup(ref);
-        const exact = this.active.get(sessionId);
+        const exact = this.activeForSessionId(sessionId);
         if (exact !== undefined && lookupMatchesActiveSession(ref, exact))
             return exact;
-        for (const [candidateId, active] of this.active.entries()) {
+        for (const active of this.active.values()) {
+            const candidateId = active.runtime.session.sessionId;
             if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active))
                 return active;
         }
         return undefined;
     }
+    getActiveForCommand(sessionId, eventScope) {
+        const active = eventScope === undefined ? this.activeForSessionId(sessionId) : this.activeForSessionIdAndScope(sessionId, eventScope);
+        if (active === undefined)
+            throw new Error(`Session not active: ${sessionId}`);
+        return Promise.resolve(active);
+    }
+    submitCommandPrompt(sessionId, text, eventScope) {
+        const active = this.activeForSessionIdAndScope(sessionId, eventScope);
+        if (active === undefined)
+            throw new Error(`Session not active: ${sessionId}`);
+        return this.submitPrompt(active.runtime.session, text, undefined, [], false);
+    }
+    activeForSessionId(sessionId) {
+        return this.activeSessionsForId(sessionId)[0];
+    }
+    activeForSessionIdAndScope(sessionId, eventScope) {
+        if (eventScope === undefined)
+            return undefined;
+        return this.active.get(activeSessionKey(sessionId, eventScope));
+    }
+    activeSessionsForId(sessionId) {
+        return [...new Set(this.active.values())].filter((active) => active.runtime.session.sessionId === sessionId);
+    }
     async create(sessionManager, cwd, options = {}) {
         const runtime = await this.createAgentRuntime(this.createRuntime, {
             cwd,
@@ -1385,15 +1412,15 @@ export class PiSessionService {
             ...(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) };
+        this.active.set(activeSessionKey(runtime.session.sessionId, active.eventScope), active);
         await this.bindSessionExtensions(runtime.session);
-        const active = { runtime, unsubscribe: noop, managementContextKey: managementContextKey(options.managementContext) };
         this.bindRuntime(active);
         runtime.setRebindSession(async (session) => {
             await this.bindSessionExtensions(session);
             this.bindRuntime(active);
             await this.recoverSubsessionTrackingForOpenedSession(session);
         });
-        this.active.set(runtime.session.sessionId, active);
         await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
         this.publishStatus(runtime.session);
         return active;
@@ -1403,7 +1430,7 @@ export class PiSessionService {
             onError: (error) => {
                 const message = `${error.extensionPath}: ${error.error}`;
                 this.publishActivity(session, "extension error", "error", message);
-                this.events.publish(session.sessionId, { type: "session.error", message });
+                this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
             },
         });
     }
@@ -1413,12 +1440,12 @@ export class PiSessionService {
         for (const [sessionId, candidate] of this.active.entries()) {
             if (candidate === active) {
                 this.active.delete(sessionId);
-                if (sessionId !== session.sessionId)
-                    this.clearCompactionPromptQueue(sessionId);
+                if (!sessionId.endsWith(`\0${session.sessionId}`))
+                    this.clearCompactionPromptQueue(candidate.runtime.session.sessionId);
             }
         }
         active.unsubscribe = session.subscribe((event) => {
-            this.events.publish(session.sessionId, toClientEvent(event));
+            this.events.publish(session.sessionId, toClientEvent(event), active.eventScope);
             this.publishActivityForEvent(session, event);
             const eventType = getString(event, "type");
             if (eventType === "compaction_end")
@@ -1428,7 +1455,7 @@ export class PiSessionService {
             this.publishStatus(session);
             this.updateSubsessionTracking(session);
         });
-        this.active.set(session.sessionId, active);
+        this.active.set(activeSessionKey(session.sessionId, active.eventScope), active);
     }
     scheduleCompactionQueueDrain(sessionId, delayMs = 0) {
         if (!this.compactionPromptQueues.has(sessionId) || this.compactionDrainTimers.has(sessionId))
@@ -1440,7 +1467,7 @@ export class PiSessionService {
         this.compactionDrainTimers.set(sessionId, timer);
     }
     drainCompactionPromptQueue(sessionId) {
-        const active = this.active.get(sessionId);
+        const active = this.activeForSessionId(sessionId);
         if (active === undefined)
             return;
         const { session } = active.runtime;
@@ -1509,20 +1536,24 @@ export class PiSessionService {
     }
     applyAuthChange(change = {}) {
         this.modelRegistry.refresh();
+        this.managementModelRegistry.refresh();
+        const changedScope = change.scope ?? "normal";
         for (const active of this.active.values()) {
+            if (authScopeFromEventScope(active.eventScope) !== changedScope)
+                continue;
             const { session } = active.runtime;
             session.modelRegistry.refresh();
-            this.syncCurrentModelAuthWarning(session, change.removedProviderId);
+            this.syncCurrentModelAuthWarning(session, active.eventScope, change.removedProviderId);
             this.publishStatus(session);
         }
     }
-    syncCurrentModelAuthWarning(session, removedProviderId) {
+    syncCurrentModelAuthWarning(session, eventScope, removedProviderId) {
         const model = session.model;
         if (model === undefined)
             return;
         if (model.provider === "unknown" && model.id === "unknown")
             return;
-        const warningKey = authLossWarningKey(session.sessionId, model.provider, model.id);
+        const warningKey = authLossWarningKey(session.sessionId, eventScope, model.provider, model.id);
         const registered = session.modelRegistry.find(model.provider, model.id);
         if (registered === undefined)
             return;
@@ -1537,12 +1568,11 @@ export class PiSessionService {
             type: "command.output",
             level: "error",
             message: `Authentication for ${model.provider}/${model.id} was removed. Use /model to select another model.`,
-        });
+        }, eventScope);
     }
     clearAuthLossWarningsForSession(sessionId) {
-        const prefix = `${sessionId}:`;
         for (const key of this.authLossWarnings) {
-            if (key.startsWith(prefix))
+            if (key.includes(`:${sessionId}:`))
                 this.authLossWarnings.delete(key);
         }
     }
@@ -1550,8 +1580,9 @@ export class PiSessionService {
         const event = session.sessionName === undefined
             ? { type: "session.name", sessionId: session.sessionId }
             : { type: "session.name", sessionId: session.sessionId, name: session.sessionName };
-        this.events.publish(session.sessionId, event);
-        this.events.publishGlobal(event);
+        const eventScope = this.eventScopeForSession(session);
+        this.events.publish(session.sessionId, event, eventScope);
+        this.events.publishGlobal(event, eventScope);
     }
     publishHeartbeats() {
         for (const active of this.active.values()) {
@@ -1560,7 +1591,7 @@ export class PiSessionService {
             // the session still reports active work transiently, so the event-driven
             // latch may not fire. The heartbeat re-checks once the session settles.
             this.updateSubsessionTracking(session);
-            const activity = this.activities.get(session.sessionId);
+            const activity = this.activities.get(activeSessionKey(session.sessionId, active.eventScope));
             if (!this.hasActiveWork(session)) {
                 if (activity?.phase === "active")
                     this.publishStatus(session);
@@ -1642,29 +1673,42 @@ export class PiSessionService {
     publishActivity(session, label, phase, detail) {
         const at = new Date().toISOString();
         const stored = detail === undefined ? { phase, label, at } : { phase, label, detail, at };
-        this.activities.set(session.sessionId, stored);
+        const eventScope = this.eventScopeForSession(session);
+        this.activities.set(activeSessionKey(session.sessionId, eventScope), stored);
         const activity = detail === undefined ? { sessionId: session.sessionId, phase, label, at } : { sessionId: session.sessionId, phase, label, detail, at };
-        this.workspaceActivity?.applySessionActivity(session.sessionManager.getCwd(), activity);
-        this.events.publish(session.sessionId, { type: "activity.update", activity });
-        this.events.publishGlobal({ type: "activity.update", activity });
+        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);
     }
     publishStatus(session) {
         const status = this.statusFromSession(session);
         this.clearStaleActiveActivity(session);
-        this.workspaceActivity?.applySessionStatus(session.sessionManager.getCwd(), status);
-        this.events.publish(session.sessionId, { type: "status.update", status });
-        this.events.publishGlobal({ type: "status.update", status });
+        const eventScope = this.eventScopeForSession(session);
+        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);
     }
     clearStaleActiveActivity(session) {
-        const current = this.activities.get(session.sessionId);
+        const eventScope = this.eventScopeForSession(session);
+        const current = this.activities.get(activeSessionKey(session.sessionId, eventScope));
         if (current?.phase !== "active" || this.hasActiveWork(session))
             return;
         const at = new Date().toISOString();
         const stored = { phase: "idle", label: "idle", at };
-        this.activities.set(session.sessionId, stored);
+        this.activities.set(activeSessionKey(session.sessionId, eventScope), stored);
         const activity = { sessionId: session.sessionId, ...stored };
-        this.events.publish(session.sessionId, { type: "activity.update", activity });
-        this.events.publishGlobal({ type: "activity.update", activity });
+        this.events.publish(session.sessionId, { type: "activity.update", activity }, eventScope);
+        this.events.publishGlobal({ type: "activity.update", activity }, eventScope);
+    }
+    activityForSession(session) {
+        return this.activities.get(activeSessionKey(session.sessionId, this.eventScopeForSession(session)));
+    }
+    eventScopeForSession(session) {
+        for (const active of this.active.values()) {
+            if (active.runtime.session === session)
+                return active.eventScope;
+        }
+        return NORMAL_SESSION_EVENT_SCOPE;
     }
     statusFromSession(session) {
         const stats = session.getSessionStats();