@chainingintention/pi-web-cn 1.202608.8 → 2.0.0

package/dist/server/sessions/piSessionService.js

@@ -1,7 +1,8 @@
-import { realpathSync, statSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { constants, realpathSync, statSync } from "node:fs";
+import { copyFile, mkdir, 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, readStoredCredential, SessionManager, } from "@earendil-works/pi-coding-agent";
+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";
 import { eventScopeFromManagementContext, managementContextKey, NORMAL_SESSION_EVENT_SCOPE } from "../realtime/sessionEventScope.js";
@@ -19,10 +20,9 @@ import { createPiSessionManagerGateway } from "./piSessionManagerGateway.js";
 import { SessionPinStore } from "./sessionPinStore.js";
 import { SessionActivityCoordinator } from "./sessionActivityCoordinator.js";
 import { searchSessionContent } from "./sessionContentSearch.js";
+import { createLocalOnlyModelRuntime } from "./authService.js";
 import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
 import { readSessionHeaderSummary } from "./sessionFileHeader.js";
-import { countOutOfListingChildren, locateOutOfListingParents } from "./parentSessionLocator.js";
-import { siblingWorkspaceCwds } from "../workspaces/projectWorkspaceCwds.js";
 import { workbenchAccessHandle } from "../managementEmbed.js";
 import { DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS, piWebDataDir } from "../../config.js";
 import { createScopedSettingsManager, resolveSettingsScopeDirectory } from "./projectSettingsScope.js";
@@ -61,6 +61,25 @@ const STARTUP_PHASE_EXTENSIONS = "正在加载会话扩展";
 const STARTUP_CONCURRENT_CATALOG_REFRESH = "服务商模型列表正在刷新";
 const MAX_UNREAD_PUBLICATION_RETRY_MS = 30_000;
 const MAX_PENDING_UNREAD_MUTATIONS = SESSION_UNREAD_LIMIT + 1;
+function auditVisibleAssistantMessage(message) {
+    if (!isAuditRecord(message))
+        return message;
+    const record = message;
+    const content = record["content"];
+    if (!Array.isArray(content))
+        return message;
+    return {
+        ...record,
+        content: content.filter(part => (typeof part !== "object"
+            || part === null
+            || Array.isArray(part)
+            || !isAuditRecord(part)
+            || part["type"] !== "thinking")),
+    };
+}
+function isAuditRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function noop() {
     // Intentionally empty default unsubscribe callback.
 }
@@ -69,6 +88,9 @@ function spawnTargetError(decision) {
         return new Error("派生会话不在已注册项目中");
     return new Error(`cwd 必须是此项目的工作区。允许的路径：${decision.allowedCwds.join(", ")}`);
 }
+function subsessionCwdError(spawningCwd, requestedCwd) {
+    return new Error(`跟踪子会话只能在父会话的工作区中运行（${spawningCwd}），不能使用 ${requestedCwd}。如需在其它工作区运行，请使用 spawn_session 创建独立会话。`);
+}
 function modelSpecOf(model) {
     return `${model.provider}/${model.id}`;
 }
@@ -153,6 +175,8 @@ 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) => {
@@ -168,34 +192,77 @@ export function filterManagedGlobalContextFiles(cwd, agentDir, base) {
 }
 export function filterManagedProjectSkills(cwd, base) {
     const projectRoot = realpathSync(cwd);
+    const pathAllowed = (path) => pathInsideRealDirectory(projectRoot, path);
     return {
         ...base,
-        skills: base.skills.filter((skill) => {
-            try {
-                return pathInsideOrEqual(projectRoot, realpathSync(skill.filePath));
-            }
-            catch {
-                return false;
-            }
-        }),
+        skills: base.skills.filter((skill) => pathAllowed(skill.filePath)),
+        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(receipt.skills.map((skill) => resolve(projectRoot, ".pi", "skills", skill.directory)));
+    const allowedDirectories = new Set([
+        resolve(projectRoot, MANAGED_RELAY_SKILL_DIRECTORY),
+        ...receipt.skills.map((skill) => resolve(projectRoot, ".pi", "skills", skill.directory)),
+    ]);
+    const pathAllowed = (path) => [...allowedDirectories].some((directory) => pathInsideRealDirectory(directory, path));
     return {
         ...base,
-        skills: base.skills.filter((skill) => {
-            try {
-                const path = realpathSync(skill.filePath);
-                return [...allowedDirectories].some((directory) => pathInsideOrEqual(directory, path));
-            }
-            catch {
-                return false;
-            }
-        }),
+        skills: base.skills.filter((skill) => pathAllowed(skill.filePath)),
+        diagnostics: filterManagedSkillDiagnostics(base.diagnostics, pathAllowed),
     };
 }
+function filterManagedSkillDiagnostics(diagnostics, pathAllowed) {
+    return diagnostics.filter((diagnostic) => diagnostic.path === undefined || pathAllowed(diagnostic.path));
+}
+function pathInsideRealDirectory(directory, path) {
+    try {
+        return pathInsideOrEqual(directory, realpathSync(path));
+    }
+    catch {
+        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);
@@ -337,7 +404,13 @@ function createRuntimeWithContextAndOneShotSessionOptions(createRuntime, managem
         });
     };
 }
-function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions, askUser, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd) {
+/** Append PI WEB-owned prompt sections after the operator's Pi prompt files. */
+export function piWebResourceLoaderOptions(appendSystemPromptSections) {
+    if (appendSystemPromptSections.length === 0)
+        return undefined;
+    return { appendSystemPromptOverride: (base) => [...base, ...appendSystemPromptSections] };
+}
+function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions, askUser, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd, appendSystemPromptSections = []) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, initialThinkingLevel, delegationToolsEnabled = true }) => {
         const scopedModelRuntime = managementContext === undefined ? await normalModelRuntimeForCwd(cwd) : await managementModelRuntime();
         if (managementContext !== undefined) {
@@ -356,7 +429,14 @@ function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRu
             scopeDirectory: await resolveSettingsScope(cwd, "normal"),
             globalAgentDir: agentDir,
         });
-        const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime: scopedModelRuntime, settingsManager });
+        const resourceLoaderOptions = piWebResourceLoaderOptions(appendSystemPromptSections);
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            modelRuntime: scopedModelRuntime,
+            settingsManager,
+            ...(resourceLoaderOptions === undefined ? {} : { resourceLoaderOptions }),
+        });
         const customTools = createPiWebCustomToolDefinitions(cwd, delegationToolsEnabled, spawn, subsessions, askUser);
         const result = await createAgentSessionFromServices({
             services,
@@ -371,6 +451,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);
         const auditIdentity = await resolveManagementAuditIdentity(cwd, managementContext, managementProjectIdForCwd, logger);
         const accessHandle = workbenchAccessHandle(managementContext);
         const state = workbench === undefined ? undefined : workbench.accessStates.require(accessHandle);
@@ -526,7 +607,6 @@ export class PiSessionService {
         /** 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
@@ -539,20 +619,6 @@ export class PiSessionService {
         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();
@@ -565,7 +631,7 @@ export class PiSessionService {
         });
         let defaultModelRuntime;
         const resolveDefaultModelRuntime = () => {
-            defaultModelRuntime ??= deps.modelRuntime === undefined ? ModelRuntime.create() : Promise.resolve(deps.modelRuntime);
+            defaultModelRuntime ??= deps.modelRuntime === undefined ? createLocalOnlyModelRuntime() : Promise.resolve(deps.modelRuntime);
             return defaultModelRuntime;
         };
         this.normalModelRuntimeForCwd = deps.normalModelRuntimeForCwd ?? resolveDefaultModelRuntime;
@@ -574,7 +640,6 @@ export class PiSessionService {
             ? resolveDefaultModelRuntime
             : () => Promise.resolve(managementModelRuntime);
         this.spawnTargets = deps.spawnTargets;
-        this.projectWorkspaces = deps.projectWorkspaces;
         this.logger = deps.logger ?? noopLogger;
         this.normalToolAudit = deps.normalToolAudit;
         this.managementAudit = deps.managementAudit;
@@ -582,13 +647,14 @@ export class PiSessionService {
         this.now = deps.now ?? (() => new Date());
         this.notificationStore = deps.notificationStore ?? new SessionNotificationStore();
         this.unreadStore = deps.unreadStore ?? new SessionUnreadStore();
+        this.onUnreadChanged = deps.onUnreadChanged;
         this.pendingAskStore = deps.pendingAskStore ?? new PendingAskStore();
         this.pendingExtensionDialogStore = deps.pendingExtensionDialogStore ?? new PendingExtensionDialogStore();
         this.extensionDialogsTimeoutMs = deps.extensionDialogsTimeoutMs ?? DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS;
         this.catalogRefreshStatus = deps.catalogRefreshStatus;
         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
+        // Subsessions are gated behind their own flag, and they
         // also require the spawn capability (they share its project-scope resolver).
         const subsessionsActive = this.spawnTargets !== undefined && deps.subsessionsEnabled === true;
         this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.normalModelRuntimeForCwd, this.managementModelRuntime, (cwd, mode) => this.resolveSettingsScopeDirectory(cwd, mode), this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
@@ -596,7 +662,7 @@ 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, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd);
+        }, deps.askUserEnabled === true ? { open: (input) => this.openAsk(input) } : undefined, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd, deps.appendSystemPromptSections ?? []);
         this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
         this.workspaceActivity = deps.workspaceActivity;
         this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
@@ -709,7 +775,6 @@ 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();
@@ -788,67 +853,11 @@ export class PiSessionService {
             .map((record) => clientSessionFromArchivedRecord(record, sessionsById.get(record.sessionId)))
             .filter(isDefined);
         return {
-            sessions: await this.withRelatedSessionsElsewhere([...unarchivedSessions, ...archivedSessions], cwd),
+            sessions: [...unarchivedSessions, ...archivedSessions],
             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);
@@ -890,7 +899,7 @@ export class PiSessionService {
     async spawnSession(input) {
         if (this.spawnTargets === undefined)
             throw new Error("派生会话已禁用");
-        const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
+        const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd, eventScopeFromManagementContext(input.managementContext));
         if (!decision.allowed)
             throw spawnTargetError(decision);
         // A model spec overrides the inherited model. Only a spec triggers a
@@ -915,16 +924,14 @@ export class PiSessionService {
             ...(modelUsed === undefined ? {} : { model: modelSpecOf(modelUsed) }),
         };
     }
-    /**
-     * Start a *tracked* child session on behalf of a LLM. Identical to
-     * {@link spawnSession} in how the target cwd is resolved, but the child
-     * records its parent (so it shows in the session tree) and is registered so
-     * the parent is notified when it stops working and can inspect it later.
-     */
+    /** Start a tracked child in the parent's workspace so it remains visible in the same session tree. */
     async spawnSubsession(input) {
         if (this.spawnTargets === undefined)
             throw new Error("派生会话已禁用");
-        const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
+        if (input.cwd !== undefined && input.cwd !== "" && !cwdPathsEqual(input.cwd, input.spawningCwd)) {
+            throw subsessionCwdError(input.spawningCwd, input.cwd);
+        }
+        const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, undefined, eventScopeFromManagementContext(input.managementContext));
         if (!decision.allowed)
             throw spawnTargetError(decision);
         // A model spec overrides the inherited model and is resolved against the
@@ -967,7 +974,9 @@ export class PiSessionService {
      * first so callers see newly configured providers and models.
      */
     async sessionModelCandidates(session) {
-        await session.modelRuntime.refresh();
+        // Pi 0.84 keeps request paths local-only; the bounded catalog refresher is
+        // the only path allowed to fetch provider catalogs over the network.
+        await session.modelRuntime.refresh({ allowNetwork: false });
         return session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
             : await session.modelRuntime.getAvailable();
@@ -1018,9 +1027,9 @@ export class PiSessionService {
      * work (`deliverAs: "followUp"`), which is how the run that `ask_user`
      * terminated continues.
      */
-    async submitAsk(ref, askId, submission) {
+    async submitAsk(ref, askId, submission, managementContext) {
         await this.assertWritable(ref);
-        const session = await this.getOrOpen(ref);
+        const session = await this.getOrOpen(ref, managementContext);
         // Checked before the store closes the ask so a refused delivery cannot
         // discard answers the user already submitted.
         this.assertTreeNavigationInactive(session, "answer questions");
@@ -1031,9 +1040,9 @@ export class PiSessionService {
      * question as unanswered: it was promised a follow-up message and would
      * otherwise wait for one that never comes.
      */
-    async cancelAsk(ref, askId) {
+    async cancelAsk(ref, askId, managementContext) {
         await this.assertWritable(ref);
-        const session = await this.getOrOpen(ref);
+        const session = await this.getOrOpen(ref, managementContext);
         this.assertTreeNavigationInactive(session, "dismiss questions");
         return this.closeAsk(session, this.pendingAskStore.cancel(session.sessionId, askId));
     }
@@ -1657,6 +1666,7 @@ export class PiSessionService {
         void this.submitPrompt(session, promptText, behavior, images, echoUserMessage);
     }
     submitPrompt(session, text, behavior, images = [], echoUserMessage = true) {
+        this.auditUserPrompt(session, text);
         this.publishActivity(session, behavior === "steer" ? "插队消息已排队" : behavior === "followUp" ? "消息已排队" : "消息已接收", "active");
         const eventScope = this.eventScopeForSession(session);
         if (behavior === undefined && echoUserMessage)
@@ -1784,6 +1794,73 @@ export class PiSessionService {
             }
         }
     }
+    async forkFromTree(ref, request, managementContext) {
+        if (request.entryId.trim() === "")
+            throw new Error("Session tree entry is required");
+        const requestedSessionId = sessionIdFromLookup(ref);
+        if (this.isTreeExclusiveSessionIdentityActive(requestedSessionId)) {
+            throw new Error("Stop current session activity before forking the session tree");
+        }
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref, managementContext);
+        if (this.hasActiveWork(session))
+            throw new Error("Stop current session activity before forking the session tree");
+        const sourceSessionId = session.sessionId;
+        const sourceEventScope = this.eventScopeForSession(session);
+        const sourceCwd = session.sessionManager.getCwd();
+        this.publishActivity(session, "正在从会话树条目分叉", "active");
+        this.publishStatus(session);
+        try {
+            const result = await this.commandService.forkEntry(session.sessionId, request.entryId, sourceEventScope, {
+                expectedLeafId: request.expectedLeafId,
+            });
+            if (result.type === "unsupported")
+                throw new Error(result.message);
+            if (result.type !== "done")
+                throw new Error("Session fork is unavailable");
+            if (result.session === undefined) {
+                if (this.isCurrentActiveSession(session)) {
+                    this.publishActivity(session, "会话分叉已取消", "idle");
+                    this.publishStatus(session);
+                }
+                return { cancelled: true };
+            }
+            const forked = this.activeForLookup({ id: result.session.id, cwd: result.session.cwd }, managementContext)?.runtime.session;
+            if (forked !== undefined && this.isCurrentActiveSession(forked)) {
+                this.publishActivity(forked, "会话已分叉", "idle");
+                this.publishStatus(forked);
+            }
+            if (result.session.id !== sourceSessionId)
+                this.clearSupersededSessionActivity(sourceSessionId, sourceCwd, sourceEventScope);
+            return {
+                cancelled: false,
+                session: result.session,
+                ...(result.promptDraft === undefined ? {} : { promptDraft: result.promptDraft }),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (this.isCurrentActiveSession(session)) {
+                this.publishActivity(session, "会话分叉失败", "error", message);
+                this.events.publish(session.sessionId, { type: "session.error", message }, sourceEventScope);
+                this.publishStatus(session);
+            }
+            throw error;
+        }
+    }
+    clearSupersededSessionActivity(sessionId, cwd, eventScope) {
+        const sessionKey = activeSessionKey(sessionId, eventScope);
+        if (this.activities.get(sessionKey)?.phase === "active") {
+            const at = new Date().toISOString();
+            const stored = { phase: "idle", label: "空闲", at };
+            this.activities.set(sessionKey, stored);
+            const activity = { sessionId, ...stored };
+            this.events.publish(sessionId, { type: "activity.update", activity }, eventScope);
+            this.events.publishGlobal({ type: "activity.update", activity }, eventScope);
+        }
+        this.workspaceActivity?.removeSession(sessionId, cwd, eventScope);
+        this.activities.delete(sessionKey);
+    }
     async archive(ref, managementContext) {
         const active = await this.getActive(ref, managementContext);
         const session = active.runtime.session;
@@ -2023,6 +2100,7 @@ export class PiSessionService {
         if (sessionFile === undefined || sessionFile === "")
             throw new Error("会话尚未持久化");
         await clearParentSession(sessionFile);
+        this.sessionManager.invalidateSessionFile?.(sessionFile);
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
         await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }]);
@@ -2365,8 +2443,10 @@ export class PiSessionService {
             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))
-            : (await this.sessionManager.listAll?.() ?? []).find((s) => s.id === ref || s.id.startsWith(ref));
+            ? this.sessionManager.resolveSessionFile === undefined
+                ? findSessionByIdOrPrefix(await this.sessionManager.list(ref.cwd), ref.id)
+                : await this.sessionManager.resolveSessionFile(ref.cwd, ref.id)
+            : findSessionByIdOrPrefix(await this.sessionManager.listAll?.() ?? [], ref);
         if (!match)
             throw new Error("未找到会话");
         return this.openPending(match.id, match.cwd, managementContext, () => this.sessionManager.open(match.path));
@@ -2494,6 +2574,7 @@ export class PiSessionService {
         active.unsubscribe = session.subscribe((event) => {
             this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel), active.eventScope);
             this.auditToolExecutionEvent(active, event);
+            this.auditAssistantResponseEvent(active, event);
             this.publishActivityForEvent(session, event);
             const eventType = getString(event, "type");
             if (eventType === "agent_end")
@@ -2842,7 +2923,12 @@ export class PiSessionService {
         }, "Pi tool execution audit");
         if (managementIdentity !== undefined) {
             try {
-                this.managementAudit?.record({ action: "tool_execution", ...managementIdentity, ...auditEvent });
+                this.managementAudit?.record({
+                    action: "tool_execution",
+                    ...managementIdentity,
+                    ...auditEvent,
+                    content: isEnd ? getProperty(event, "result") : getProperty(event, "args"),
+                });
             }
             catch (error) {
                 this.logger.info({ sessionId: auditEvent.sessionId, toolCallId: auditEvent.toolCallId, error: error instanceof Error ? error.message : String(error) }, "failed to enqueue management-mode tool audit");
@@ -2862,6 +2948,43 @@ export class PiSessionService {
             }, "failed to persist ordinary-mode tool audit");
         }
     }
+    auditAssistantResponseEvent(active, event) {
+        if (getString(event, "type") !== "message_end")
+            return;
+        const message = getProperty(event, "message");
+        if (getString(message, "role") !== "assistant")
+            return;
+        this.recordManagementContentAudit(active, "assistant_response", auditVisibleAssistantMessage(message));
+    }
+    auditUserPrompt(session, text) {
+        const active = [...new Set(this.active.values())]
+            .find(candidate => candidate.runtime.session === session);
+        if (active === undefined)
+            return;
+        this.recordManagementContentAudit(active, "user_prompt", text);
+    }
+    recordManagementContentAudit(active, action, content) {
+        const identity = active.managementAuditIdentity;
+        if (identity === undefined || this.managementAudit === undefined)
+            return;
+        try {
+            this.managementAudit.record({
+                action,
+                status: "completed",
+                ...identity,
+                sessionId: active.runtime.session.sessionId,
+                cwd: active.runtime.cwd,
+                content,
+            });
+        }
+        catch (error) {
+            this.logger.info({
+                sessionId: active.runtime.session.sessionId,
+                action,
+                error: error instanceof Error ? error.message : String(error),
+            }, "failed to enqueue management-mode content audit");
+        }
+    }
     /**
      * Build the reporter for one session construction.
      *
@@ -3027,6 +3150,16 @@ export class PiSessionService {
         await this.publishUnreadMutations([]);
         return this.unreadStore.durableCatalogSnapshot();
     }
+    /** Scope-filtered unread view used only by the daemon-owned status tree. */
+    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, {
             ...request,
@@ -3330,6 +3463,17 @@ export class PiSessionService {
         void this.publishUnreadMutations(mutations).catch(() => undefined);
     }
     publishUnreadMutations(mutations) {
+        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.forEach((scope) => this.onUnreadChanged?.(scope));
+        }
         this.enqueueUnreadMutations(mutations);
         this.unreadPublicationFlushRequested = true;
         if (this.unreadPublication === undefined && this.unreadPublicationRetryTimer !== undefined) {
@@ -3820,6 +3964,11 @@ async function resolveManagementAuditIdentity(cwd, context, resolveProjectId, lo
             logger.info({ userId: context.user.id, cwd, error: error instanceof Error ? error.message : String(error) }, "failed to resolve management audit project; using the authorized default");
         }
     }
-    return { userId: context.user.id, rootUserId: context.user.rootUserId, projectId };
+    return {
+        userId: context.user.id,
+        rootUserId: context.user.rootUserId,
+        ...(context.user.displayName === undefined ? {} : { userDisplayName: context.user.displayName }),
+        projectId,
+    };
 }
 //# sourceMappingURL=piSessionService.js.map