@chainingintention/pi-web-cn 1.202609.0 → 1.202609.2

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, writeFile } 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";
@@ -14,6 +13,7 @@ import { findArchiveCandidateByIdOrPrefix, planSessionArchiveTree } from "./sess
 import { deterministicSessionName, fallbackSessionName, generateShortSessionName } from "./sessionNameGenerator.js";
 import { computeEditPreview } from "./editPreview.js";
 import { attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachmentService.js";
+import { loadEffectiveProjectAttachmentsConfig } from "../workspaces/projectPiWebConfig.js";
 import { parsePromptAttachments } from "../../shared/promptAttachments.js";
 import { ASK_USER_ANSWERS_CUSTOM_TYPE, SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH, SESSION_UNREAD_LIMIT } from "../../shared/apiTypes.js";
 import { createPiSessionManagerGateway } from "./piSessionManagerGateway.js";
@@ -38,12 +38,13 @@ 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 { deduplicateBundledRelaySkill, ensureManagedRelaySkill, MANAGED_RELAY_SKILL_DIRECTORY } from "./relaySkill.js";
 import { SessionUnreadStore } from "./sessionUnreadStore.js";
 import { archiveCandidateFromActiveSession, archiveCandidateFromArchivedRecord, archiveCandidateFromListEntry, archiveInputFromActiveSession, archiveInputFromCandidate, archiveInputFromListEntry, clientSessionFromArchivedRecord, compareArchivedRecords, } from "./sessionArchiveMapping.js";
 import { annotateAssistantThinkingLevel, getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
 import { WorkbenchHttpError } from "../workbench/workbenchClient.js";
 import { createWorkbenchToolDefinitions } from "../workbench/workbenchTools.js";
-import { applyEnabledModelToggle, catalogWithEnabledFirst, liveScopedModelIds, modelScopeId, persistedEnabledModelPatterns, resolveEnabledModelIds, resolveSessionModelOptions } from "./sessionModelScope.js";
+import { applyEnabledModelToggle, catalogWithEnabledFirst, modelScopeId, persistedEnabledModelPatterns, resolveEnabledModelIds, resolveSessionModelOptions, scopedModelsFromEnabledIds } from "./sessionModelScope.js";
 const noopLogger = { info() { } };
 const DEFAULT_UNREAD_PUBLICATION_RETRY_MS = 1_000;
 /**
@@ -62,6 +63,7 @@ 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;
+const IDLE_SESSION_FILE_RESOLUTION_THROTTLE_MS = 30_000;
 function auditVisibleAssistantMessage(message) {
     if (!isAuditRecord(message))
         return message;
@@ -176,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) => {
@@ -200,25 +200,6 @@ 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([
@@ -243,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);
@@ -431,13 +391,16 @@ function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRu
             globalAgentDir: agentDir,
             mode: "normal",
         });
-        const resourceLoaderOptions = piWebResourceLoaderOptions(appendSystemPromptSections);
+        const resourceLoaderOptions = {
+            ...piWebResourceLoaderOptions(appendSystemPromptSections),
+            skillsOverride: (base) => deduplicateBundledRelaySkill(cwd, base),
+        };
         const services = await createAgentSessionServices({
             cwd,
             agentDir,
             modelRuntime: scopedModelRuntime,
             settingsManager,
-            ...(resourceLoaderOptions === undefined ? {} : { resourceLoaderOptions }),
+            resourceLoaderOptions,
         });
         const modelOptions = await resolveSessionModelOptions({
             services,
@@ -609,6 +572,13 @@ export class PiSessionService {
         this.treeNavigations = new WeakSet();
         /** Counts async operations that may append an entry before they settle. */
         this.sessionEntryMutationCounts = new WeakMap();
+        /** Serializes enabled-model read/modify/write operations. */
+        this.modelScopeMutationQueue = Promise.resolve();
+        /** Effective enabled-model state keyed by the project-scoped settings store. */
+        this.modelScopeStates = new Map();
+        this.modelScopeInitializations = new Map();
+        this.modelScopeRevision = 0;
+        this.modelScopeCache = new WeakMap();
         /** Runtime/session-identity reservations for operations that must not overlap tree navigation. */
         this.treeExclusiveRuntimeOperationCounts = new WeakMap();
         this.treeExclusiveSessionOperationCounts = new Map();
@@ -633,6 +603,7 @@ export class PiSessionService {
          */
         this.subsessionNotifyArmed = new Map();
         this.notificationGenerationBySession = new WeakMap();
+        this.idleSessionFileResolutions = new WeakMap();
         /** The parked extension Promise resolvers behind the store's open dialogs. */
         this.dialogWaiters = new ExtensionDialogWaiters();
         this.pendingUnreadMutations = [];
@@ -671,6 +642,7 @@ export class PiSessionService {
         this.pendingExtensionDialogStore = deps.pendingExtensionDialogStore ?? new PendingExtensionDialogStore();
         this.extensionDialogsTimeoutMs = deps.extensionDialogsTimeoutMs ?? DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS;
         this.catalogRefreshStatus = deps.catalogRefreshStatus;
+        this.config = deps.config;
         this.unreadPublicationRetryInitialMs = Math.max(0, deps.unreadPublicationRetryDelayMs ?? DEFAULT_UNREAD_PUBLICATION_RETRY_MS);
         this.unreadPublicationRetryDelayMs = this.unreadPublicationRetryInitialMs;
         // Subsessions are gated behind their own flag, and they
@@ -987,24 +959,84 @@ export class PiSessionService {
             ...(modelUsed === undefined ? {} : { model: modelSpecOf(modelUsed) }),
         };
     }
-    /**
-     * The models a session may pick from: its scoped set when model-scoped,
-     * otherwise the runtime's available snapshot. Refreshes the runtime catalog
-     * first so callers see newly configured providers and models.
-     */
+    modelScopeContext(session) {
+        const settingsKey = session.settingsManager.piWebScopeKey ?? "global";
+        const projectSettings = session.settingsManager.getProjectSettings?.() ?? {};
+        if (Object.hasOwn(projectSettings, "enabledModels")) {
+            const workspace = canonicalizeStoredCwd(session.sessionManager.getCwd());
+            return { key: `${settingsKey}:workspace:${workspace}`, editable: false };
+        }
+        return { key: settingsKey, editable: session.settingsManager.piWebModelScopeEditable !== false };
+    }
+    async modelScopeSnapshot(session, context = this.modelScopeContext(session)) {
+        const existing = this.modelScopeStates.get(context.key);
+        if (existing !== undefined)
+            return existing;
+        const pending = this.modelScopeInitializations.get(context.key);
+        if (pending !== undefined)
+            return pending;
+        const initialization = (async () => {
+            const enabledIds = await resolveEnabledModelIds({
+                settingsManager: session.settingsManager,
+                // Runtime-backed sessions always hold the SDK ModelRuntime; PiAgentSession keeps a narrow public seam for tests.
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                modelRuntime: session.modelRuntime,
+                scopedModels: session.scopedModels,
+            });
+            const snapshot = { enabledIds: enabledIds === null ? null : [...enabledIds], revision: 0 };
+            this.modelScopeStates.set(context.key, snapshot);
+            return snapshot;
+        })();
+        this.modelScopeInitializations.set(context.key, initialization);
+        try {
+            return await initialization;
+        }
+        finally {
+            if (this.modelScopeInitializations.get(context.key) === initialization)
+                this.modelScopeInitializations.delete(context.key);
+        }
+    }
+    async synchronizeSessionModelScope(session, available) {
+        const context = this.modelScopeContext(session);
+        const snapshot = await this.modelScopeSnapshot(session, context);
+        const catalogKey = available.map(modelScopeId).join("\0");
+        const cached = this.modelScopeCache.get(session);
+        if (cached?.scopeKey === context.key && cached.revision === snapshot.revision && cached.catalogKey === catalogKey)
+            return;
+        session.setScopedModels(scopedModelsFromEnabledIds(available, snapshot.enabledIds, session.scopedModels));
+        this.modelScopeCache.set(session, { scopeKey: context.key, revision: snapshot.revision, catalogKey });
+    }
     async sessionModelCandidates(session) {
-        // 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();
+        const available = session.modelRuntime.getAvailableSnapshot();
+        await this.synchronizeSessionModelScope(session, available);
+        return session.scopedModels.length > 0 ? session.scopedModels.map((scoped) => scoped.model) : available;
     }
-    async enabledModelCatalog(runtime) {
-        const session = runtime.session;
+    async enabledModelCatalog(session) {
         await session.modelRuntime.refresh({ allowNetwork: false });
-        const enabledIds = await resolveEnabledModelIds(sessionScopeSource(runtime));
-        return catalogWithEnabledFirst(session.modelRuntime.getAvailableSnapshot(), enabledIds);
+        const available = session.modelRuntime.getAvailableSnapshot();
+        await this.synchronizeSessionModelScope(session, available);
+        const context = this.modelScopeContext(session);
+        return catalogWithEnabledFirst(available, (await this.modelScopeSnapshot(session, context)).enabledIds);
+    }
+    runModelScopeMutation(operation) {
+        const queued = this.modelScopeMutationQueue.then(operation);
+        this.modelScopeMutationQueue = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    applyEnabledModelScope(session, available, enabledIds) {
+        const context = this.modelScopeContext(session);
+        const availableIds = available.map(modelScopeId);
+        const persisted = persistedEnabledModelPatterns(enabledIds, availableIds);
+        const nextState = {
+            enabledIds: persisted === undefined ? null : enabledIds === null ? [] : [...enabledIds],
+            revision: ++this.modelScopeRevision,
+        };
+        session.settingsManager.setEnabledModels(persisted);
+        this.modelScopeStates.set(context.key, nextState);
+        session.setScopedModels(scopedModelsFromEnabledIds(available, nextState.enabledIds, session.scopedModels));
+        this.modelScopeCache.set(session, { scopeKey: context.key, revision: nextState.revision, catalogKey: available.map(modelScopeId).join("\0") });
+        this.events.publishGlobal({ type: "models.changed", revision: nextState.revision });
     }
     /**
      * Resolve a strict `provider/model-id` spec from a spawn tool against the
@@ -1548,10 +1580,14 @@ export class PiSessionService {
     }
     async messages(ref, page, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
-        return pageMessagesAtSafeBoundary(historyMessages(session), page);
+        return pageMessagesAtSafeBoundary(historyMessagesFromEntries(await this.readableSessionBranch(session)), page);
     }
     async status(ref, managementContext) {
-        return this.statusFromSession(await this.sessionForStatusOrDialogClose(ref, managementContext));
+        const session = await this.sessionForStatusOrDialogClose(ref, managementContext);
+        if (this.hasActiveWork(session))
+            return this.statusFromSession(session);
+        const branch = await this.readableSessionBranch(session);
+        return this.statusFromSession(session, transcriptMessageCount(branch));
     }
     async searchCandidates(cwd, normalizedQuery, managementContext) {
         const listing = await this.listWorkspaceSessions(cwd, managementContext);
@@ -1588,38 +1624,60 @@ export class PiSessionService {
         return models.map(modelToClientModel);
     }
     async modelCatalog(ref, managementContext) {
-        const runtime = (await this.getActive(ref, managementContext)).runtime;
-        return (await this.enabledModelCatalog(runtime)).map(catalogEntryToClientModel);
+        const session = await this.getOrOpen(ref, managementContext);
+        const scope = this.modelScopeContext(session);
+        return (await this.enabledModelCatalog(session)).map((entry) => catalogEntryToClientModel(entry, scope.editable));
     }
     async setModelEnabled(ref, provider, modelId, enabled, managementContext) {
         if (managementContext !== undefined)
             throw new Error("管理嵌入模式不允许修改已启用模型范围");
         await this.assertWritable(ref);
-        const runtime = (await this.getActive(ref)).runtime;
-        const session = runtime.session;
-        this.assertTreeNavigationInactive(session, "change enabled models");
-        await session.modelRuntime.refresh({ allowNetwork: false });
-        const currentIds = await resolveEnabledModelIds(sessionScopeSource(runtime));
-        const available = session.modelRuntime.getAvailableSnapshot();
-        const availableIds = available.map(modelScopeId);
-        const targetId = `${provider}/${modelId}`;
-        if (!availableIds.includes(targetId))
-            throw new Error(`未找到模型：${targetId}`);
-        const nextIds = applyEnabledModelToggle(currentIds, availableIds, targetId, enabled);
-        this.assertTreeNavigationInactive(session, "change enabled models");
-        if (nextIds !== currentIds) {
-            const liveIds = liveScopedModelIds(nextIds, availableIds);
-            const modelsById = new Map(available.map((model) => [modelScopeId(model), model]));
-            const scoped = liveIds === null
-                ? []
-                : liveIds.flatMap((id) => {
-                    const model = modelsById.get(id);
-                    return model === undefined ? [] : [{ model }];
-                });
-            session.settingsManager.setEnabledModels(persistedEnabledModelPatterns(nextIds, availableIds));
-            session.setScopedModels(scoped);
-        }
-        return (await this.enabledModelCatalog(runtime)).map(catalogEntryToClientModel);
+        const session = await this.getOrOpen(ref);
+        return this.runModelScopeMutation(async () => {
+            const scope = this.modelScopeContext(session);
+            if (!scope.editable)
+                throw new Error("模型可用范围由此工作区的 .pi/settings.json 控制");
+            this.assertTreeNavigationInactive(session, "change enabled models");
+            await session.modelRuntime.refresh({ allowNetwork: false });
+            const currentIds = (await this.modelScopeSnapshot(session, scope)).enabledIds;
+            const available = session.modelRuntime.getAvailableSnapshot();
+            const availableIds = available.map(modelScopeId);
+            const targetId = `${provider}/${modelId}`;
+            if (!availableIds.includes(targetId))
+                throw new Error(`未找到模型：${targetId}`);
+            if (!enabled && session.model !== undefined && modelScopeId(session.model) === targetId)
+                throw new Error("不能停用当前模型");
+            const nextIds = applyEnabledModelToggle(currentIds, availableIds, targetId, enabled);
+            this.assertTreeNavigationInactive(session, "change enabled models");
+            if (nextIds !== currentIds)
+                this.applyEnabledModelScope(session, available, nextIds);
+            return (await this.enabledModelCatalog(session)).map((entry) => catalogEntryToClientModel(entry));
+        });
+    }
+    async setModelScope(ref, mode, managementContext) {
+        if (managementContext !== undefined)
+            throw new Error("管理嵌入模式不允许修改已启用模型范围");
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        return this.runModelScopeMutation(async () => {
+            const scope = this.modelScopeContext(session);
+            if (!scope.editable)
+                throw new Error("模型可用范围由此工作区的 .pi/settings.json 控制");
+            this.assertTreeNavigationInactive(session, "change enabled models");
+            await session.modelRuntime.refresh({ allowNetwork: false });
+            const available = session.modelRuntime.getAvailableSnapshot();
+            const availableIds = available.map(modelScopeId);
+            let nextIds = null;
+            if (mode === "current") {
+                const current = session.model;
+                if (current === undefined || !availableIds.includes(modelScopeId(current)))
+                    throw new Error("当前模型不可用");
+                nextIds = [modelScopeId(current)];
+            }
+            this.assertTreeNavigationInactive(session, "change enabled models");
+            this.applyEnabledModelScope(session, available, nextIds);
+            return (await this.enabledModelCatalog(session)).map((entry) => catalogEntryToClientModel(entry));
+        });
     }
     async setModel(ref, provider, modelId, managementContext) {
         await this.assertWritable(ref);
@@ -1639,7 +1697,11 @@ export class PiSessionService {
     async cycleModel(ref, direction, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        const result = await this.runSessionEntryMutation(session, "change models", () => session.cycleModel(direction));
+        const result = await this.runModelScopeMutation(async () => {
+            await session.modelRuntime.refresh({ allowNetwork: false });
+            await this.synchronizeSessionModelScope(session, session.modelRuntime.getAvailableSnapshot());
+            return this.runSessionEntryMutation(session, "change models", () => session.cycleModel(direction));
+        });
         if (result === undefined)
             throw new Error(session.scopedModels.length > 0 ? "作用域内只有一个模型" : "只有一个可用模型");
         this.publishActivity(session, `模型：${result.model.id}`, "idle", result.model.provider);
@@ -1752,7 +1814,13 @@ export class PiSessionService {
             return [];
         await this.assertWritable(ref);
         const active = await this.getActive(ref, managementContext);
-        return saveAttachmentsToWorkspace(active.runtime.cwd, parsed, folder === undefined ? {} : { folder });
+        const cwd = active.runtime.cwd;
+        const effectiveFolder = folder ?? (await this.workspaceAttachmentsConfig(cwd)).defaultFolder;
+        return saveAttachmentsToWorkspace(cwd, parsed, effectiveFolder === undefined ? {} : { folder: effectiveFolder });
+    }
+    async workspaceAttachmentsConfig(cwd) {
+        const globalConfig = this.config === undefined ? {} : (await this.config.read()).effectiveConfig;
+        return loadEffectiveProjectAttachmentsConfig(cwd, globalConfig);
     }
     async shell(ref, text, managementContext) {
         await this.assertWritable(ref);
@@ -2492,6 +2560,35 @@ export class PiSessionService {
         const reachable = this.activeForLookup(ref, managementContext)?.runtime.session ?? this.startupSessionForLookup(ref, managementContext);
         return reachable ?? this.getOrOpen(ref, managementContext);
     }
+    async readableSessionBranch(session) {
+        if (this.hasActiveWork(session) || this.sessionManager.readBranch === undefined)
+            return session.sessionManager.getBranch();
+        const leafId = session.sessionManager.getLeafId();
+        const latestEntry = session.sessionManager.getEntries?.().at(-1);
+        // Unsummarized tree navigation changes only the SDK's in-memory leaf.
+        if (isRecord(latestEntry) && typeof latestEntry["id"] === "string" && latestEntry["id"] !== leafId)
+            return session.sessionManager.getBranch();
+        const sessionFile = session.sessionFile ?? session.sessionManager.getSessionFile();
+        const resolvedPath = sessionFile === undefined ? await this.idleSessionFilePath(session) : undefined;
+        if (this.hasActiveWork(session))
+            return session.sessionManager.getBranch();
+        const path = sessionFile ?? resolvedPath;
+        if (path === undefined)
+            return session.sessionManager.getBranch();
+        const snapshot = await this.sessionManager.readBranch(path);
+        if (snapshot === undefined)
+            return session.sessionManager.getBranch();
+        return this.hasActiveWork(session) || session.sessionManager.getLeafId() !== leafId ? session.sessionManager.getBranch() : snapshot;
+    }
+    async idleSessionFilePath(session) {
+        const cached = this.idleSessionFileResolutions.get(session);
+        const at = this.now().getTime();
+        if (cached !== undefined && at - cached.at < IDLE_SESSION_FILE_RESOLUTION_THROTTLE_MS)
+            return cached.path;
+        const match = await this.sessionManager.resolveSessionFile?.(session.sessionManager.getCwd(), session.sessionId);
+        this.idleSessionFileResolutions.set(session, { at, path: match?.path });
+        return match?.path;
+    }
     async getActive(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
         if (active !== undefined)
@@ -3153,7 +3250,7 @@ export class PiSessionService {
         for (const session of sessions)
             this.publishStatus(session);
     }
-    statusFromSession(session) {
+    statusFromSession(session, messageCount = session.messages.length) {
         const stats = session.getSessionStats();
         const model = session.model === undefined ? undefined : modelToClientModel(session.model);
         const contextUsage = session.getContextUsage();
@@ -3170,7 +3267,7 @@ export class PiSessionService {
             isBashRunning: session.isBashRunning,
             pendingMessageCount: this.pendingMessageCount(session),
             queuedMessages: queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)),
-            messageCount: session.messages.length,
+            messageCount,
             tokens: stats.tokens,
             cost: stats.cost,
             ...(contextUsage === undefined ? {} : { contextUsage }),
@@ -3684,14 +3781,15 @@ function modelToClientModel(model) {
         ...(reasoning === undefined ? {} : { reasoning }),
     };
 }
-function sessionScopeSource(runtime) {
-    const modelRuntime = runtime.services?.modelRuntime;
-    if (modelRuntime === undefined)
-        throw new Error("会话模型目录不可用");
-    return { settingsManager: runtime.session.settingsManager, modelRuntime, scopedModels: runtime.session.scopedModels };
-}
-function catalogEntryToClientModel(entry) {
-    return { ...modelToClientModel(entry.model), provider: entry.model.provider, id: entry.model.id, enabled: entry.enabled };
+function catalogEntryToClientModel(entry, editable = true) {
+    return {
+        ...modelToClientModel(entry.model),
+        provider: entry.model.provider,
+        id: entry.model.id,
+        enabled: entry.enabled,
+        catalogIndex: entry.catalogIndex,
+        ...(editable ? {} : { editable: false }),
+    };
 }
 function notificationIdentityForSession(session) {
     return {
@@ -3963,9 +4061,12 @@ function historyMessages(session) {
     return historyMessagesFromManager(session.sessionManager);
 }
 function historyMessagesFromManager(sessionManager) {
+    return historyMessagesFromEntries(sessionManager.getBranch());
+}
+function historyMessagesFromEntries(entries) {
     const messages = [];
     let thinkingLevel;
-    for (const entry of sessionManager.getBranch()) {
+    for (const entry of entries) {
         if (!isRecord(entry))
             continue;
         if (entry["type"] === "message")
@@ -3984,6 +4085,14 @@ function historyMessagesFromManager(sessionManager) {
     }
     return messages;
 }
+function transcriptMessageCount(entries) {
+    let count = 0;
+    for (const entry of entries) {
+        if (isRecord(entry) && entry["type"] === "message")
+            count += 1;
+    }
+    return count;
+}
 /** custom entry type used to persist parent -> child subsession links outside LLM context. */
 const SUBSESSION_LINK_CUSTOM_TYPE = "pi-web.subsession.link";
 /** custom entry type used to mark a child as created by spawn_subsession. */