@chainingintention/pi-web-cn 1.202608.5 → 1.202608.7

package/dist/server/sessions/piSessionService.js

@@ -23,10 +23,13 @@ import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
 import { readSessionHeaderSummary } from "./sessionFileHeader.js";
 import { countOutOfListingChildren, locateOutOfListingParents } from "./parentSessionLocator.js";
 import { siblingWorkspaceCwds } from "../workspaces/projectWorkspaceCwds.js";
-import { piWebDataDir } from "../../config.js";
+import { workbenchAccessHandle } from "../managementEmbed.js";
+import { DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS, piWebDataDir } from "../../config.js";
 import { createScopedSettingsManager, resolveSettingsScopeDirectory } from "./projectSettingsScope.js";
 import { createAskUserToolDefinition } from "./askUserTool.js";
 import { PendingAskStore, renderAskUserAnswersText } from "./pendingAskStore.js";
+import { PendingExtensionDialogStore } from "./pendingExtensionDialogStore.js";
+import { ExtensionDialogWaiters, effectiveExtensionDialogTimeoutMs, extensionDialogCancelValue } from "./extensionDialogWaiters.js";
 import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
 import { createSubsessionToolDefinitions } from "./spawnSubsessionTool.js";
 import { buildTranscriptView } from "./subsessionTranscript.js";
@@ -37,7 +40,9 @@ import { SessionNotificationStore } from "./sessionNotificationStore.js";
 import { plainTextTheme } from "./plainTextTheme.js";
 import { SessionUnreadStore } from "./sessionUnreadStore.js";
 import { archiveCandidateFromActiveSession, archiveCandidateFromArchivedRecord, archiveCandidateFromListEntry, archiveInputFromActiveSession, archiveInputFromCandidate, archiveInputFromListEntry, clientSessionFromArchivedRecord, compareArchivedRecords, } from "./sessionArchiveMapping.js";
-import { getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
+import { annotateAssistantThinkingLevel, getBoolean, getProperty, getString, toClientEvent } from "./sessionUiEvents.js";
+import { WorkbenchHttpError } from "../workbench/workbenchClient.js";
+import { createWorkbenchToolDefinitions } from "../workbench/workbenchTools.js";
 const noopLogger = { info() { } };
 const DEFAULT_UNREAD_PUBLICATION_RETRY_MS = 1_000;
 /**
@@ -64,6 +69,28 @@ function spawnTargetError(decision) {
         return new Error("派生会话不在已注册项目中");
     return new Error(`cwd 必须是此项目的工作区。允许的路径：${decision.allowedCwds.join(", ")}`);
 }
+function modelSpecOf(model) {
+    return `${model.provider}/${model.id}`;
+}
+/**
+ * Parse a strict `provider/model-id` spec: split on the first `/` (model ids
+ * may themselves contain `/`) and require both parts to be non-empty.
+ */
+function parseModelSpec(spec) {
+    const slash = spec.indexOf("/");
+    if (slash <= 0 || slash === spec.length - 1)
+        return undefined;
+    return { provider: spec.slice(0, slash), modelId: spec.slice(slash + 1) };
+}
+/**
+ * Error for a spawn-tool model spec that matched nothing. States the facts —
+ * the bad spec and the required format — with deliberately no model list
+ * (a list would invite guesses). The agent loop turns the throw into an
+ * error tool result; how to recover is the agent's call.
+ */
+function unknownSpawnModelError(modelSpec) {
+    return new Error(`未找到模型“${modelSpec}”。请传入精确的“provider/model-id”。`);
+}
 function authLossWarningKey(sessionId, eventScope, provider, modelId) {
     return `${eventScope}:${sessionId}:${provider}/${modelId}`;
 }
@@ -76,6 +103,9 @@ function isPiSessionRef(ref) {
 function lookupMatchesActiveSession(ref, active) {
     return !isPiSessionRef(ref) || cwdPathsEqual(active.runtime.cwd, ref.cwd);
 }
+function lookupMatchesStartupSession(ref, session) {
+    return !isPiSessionRef(ref) || cwdPathsEqual(session.sessionManager.getCwd(), ref.cwd);
+}
 function activeSessionKey(sessionId, eventScope) {
     return `${eventScope}\0${sessionId}`;
 }
@@ -150,6 +180,22 @@ export function filterManagedProjectSkills(cwd, base) {
         }),
     };
 }
+export function filterManagedWorkbenchSkills(cwd, base, receipt) {
+    const projectRoot = realpathSync(cwd);
+    const allowedDirectories = new Set(receipt.skills.map((skill) => resolve(projectRoot, ".pi", "skills", skill.directory)));
+    return {
+        ...base,
+        skills: base.skills.filter((skill) => {
+            try {
+                const path = realpathSync(skill.filePath);
+                return [...allowedDirectories].some((directory) => pathInsideOrEqual(directory, path));
+            }
+            catch {
+                return false;
+            }
+        }),
+    };
+}
 function pathInsideOrEqual(parent, child) {
     const normalizedParent = resolve(parent);
     const normalizedChild = resolve(child);
@@ -262,42 +308,47 @@ export function dismissSessionWarning(session, dismissId) {
 function defaultCreateAgentRuntime(createRuntime, options) {
     if (!(options.sessionManager instanceof SessionManager))
         throw new Error("Default runtime creation requires an SDK SessionManager");
-    const runtimeFactory = createRuntimeWithContextAndOneShotInitialModel(createRuntime, options.managementContext, options.initialModel, options.delegationToolsEnabled);
+    const runtimeFactory = createRuntimeWithContextAndOneShotSessionOptions(createRuntime, options.managementContext, options.initialModel, options.initialThinkingLevel, options.delegationToolsEnabled);
     return createAgentSessionRuntime(runtimeFactory, {
         cwd: options.cwd,
         agentDir: options.agentDir,
         sessionManager: options.sessionManager,
     });
 }
-function createRuntimeWithContextAndOneShotInitialModel(createRuntime, managementContext, initialModel, delegationToolsEnabled) {
-    // The inherited model belongs only to the session being spawned. Do not keep
-    // reapplying it if that runtime later creates/forks/switches sessions itself.
+function createRuntimeWithContextAndOneShotSessionOptions(createRuntime, managementContext, initialModel, initialThinkingLevel, delegationToolsEnabled) {
+    // These inherited options belong only to the session being spawned. A later
+    // runtime replacement restores its own model and thinking level from disk.
     let pendingInitialModel = initialModel;
+    let pendingInitialThinkingLevel = initialThinkingLevel;
     let pendingDelegationToolsEnabled = delegationToolsEnabled;
     return async (options) => {
         const model = pendingInitialModel;
+        const thinkingLevel = pendingInitialThinkingLevel;
         const toolsEnabled = pendingDelegationToolsEnabled;
         pendingInitialModel = undefined;
+        pendingInitialThinkingLevel = undefined;
         pendingDelegationToolsEnabled = undefined;
         return createRuntime({
             ...options,
             ...(managementContext === undefined ? {} : { managementContext }),
             ...(model === undefined ? {} : { initialModel: model }),
+            ...(thinkingLevel === undefined ? {} : { initialThinkingLevel: thinkingLevel }),
             ...(toolsEnabled === undefined ? {} : { delegationToolsEnabled: toolsEnabled }),
         });
     };
 }
-function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions, askUser) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, delegationToolsEnabled = true }) => {
+function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions, askUser, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd) {
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, initialThinkingLevel, delegationToolsEnabled = true }) => {
         const scopedModelRuntime = managementContext === undefined ? await normalModelRuntimeForCwd(cwd) : await managementModelRuntime();
         if (managementContext !== undefined) {
-            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext)({
+            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd)({
                 cwd,
                 agentDir,
                 sessionManager,
                 delegationToolsEnabled,
                 ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
                 ...(initialModel === undefined ? {} : { initialModel }),
+                ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
             });
         }
         const settingsManager = await createScopedSettingsManager({
@@ -313,13 +364,46 @@ function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRu
             customTools,
             ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
             ...(initialModel === undefined ? {} : { model: initialModel }),
+            ...(initialThinkingLevel === undefined ? {} : { thinkingLevel: initialThinkingLevel }),
         });
         return { ...result, services, diagnostics: services.diagnostics };
     };
 }
-function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, delegationToolsEnabled = true }) => {
-        const policyAgentDir = await writeManagementPermissionSystemPolicy(agentDir, cwd, managementContext);
+function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spawn, subsessions, askUser, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd) {
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled = true }) => {
+        const auditIdentity = await resolveManagementAuditIdentity(cwd, managementContext, managementProjectIdForCwd, logger);
+        const accessHandle = workbenchAccessHandle(managementContext);
+        const state = workbench === undefined ? undefined : workbench.accessStates.require(accessHandle);
+        let receipt;
+        try {
+            receipt = state === undefined ? undefined : await workbench?.skills.synchronize(cwd, state, {
+                ...(managementAudit === undefined ? {} : { recorder: managementAudit }),
+                ...auditIdentity,
+                sessionId: sessionManager.getSessionId(),
+                cwd,
+            });
+        }
+        catch (error) {
+            if (error instanceof WorkbenchHttpError && error.status === 401 && accessHandle !== undefined)
+                workbench?.accessStates.delete(accessHandle);
+            throw error;
+        }
+        const workbenchTools = state === undefined || workbench === undefined ? [] : createWorkbenchToolDefinitions({
+            getState: () => workbench.accessStates.require(accessHandle),
+            workbench: workbench.client,
+            mcp: workbench.mcp,
+            invalidate: () => { if (accessHandle !== undefined)
+                workbench.accessStates.delete(accessHandle); },
+            logger,
+            ...(managementAudit === undefined ? {} : { audit: managementAudit }),
+            auditContext: {
+                ...auditIdentity,
+                sessionId: sessionManager.getSessionId(),
+                cwd,
+            },
+        });
+        const workbenchToolNames = workbenchTools.map((tool) => tool.name);
+        const policyAgentDir = await writeManagementPermissionSystemPolicy(agentDir, cwd, managementContext, workbenchToolNames);
         return withRuntimeCreationEnvironment({ [PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR]: policyAgentDir }, async () => {
             const settingsManager = await createScopedSettingsManager({
                 cwd,
@@ -333,24 +417,35 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spaw
                 settingsManager,
                 resourceLoaderOptions: {
                     agentsFilesOverride: (base) => filterManagedGlobalContextFiles(cwd, agentDir, base),
-                    skillsOverride: (base) => filterManagedProjectSkills(cwd, base),
+                    skillsOverride: (base) => receipt === undefined ? filterManagedProjectSkills(cwd, base) : filterManagedWorkbenchSkills(cwd, base, receipt),
                 },
             });
             const managedToolOptions = createManagedAgentToolOptions(cwd);
+            const scopedSpawn = spawn === undefined
+                ? undefined
+                : (input) => spawn({ ...input, managementContext });
+            const scopedSubsessions = subsessions === undefined
+                ? undefined
+                : {
+                    ...subsessions,
+                    spawn: (input) => subsessions.spawn({ ...input, managementContext }),
+                };
             const customTools = [
                 ...managedAgentToolDefinitions(cwd, managedToolOptions),
                 createManagedPythonToolDefinition(cwd, managementContext),
-                ...(delegationToolsEnabled && spawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))] : []),
-                ...(delegationToolsEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool)) : []),
+                ...(delegationToolsEnabled && scopedSpawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn: scopedSpawn }))] : []),
+                ...(delegationToolsEnabled && scopedSubsessions !== undefined ? createSubsessionToolDefinitions(cwd, scopedSubsessions).map((tool) => defineTool(tool)) : []),
                 ...(askUser === undefined ? [] : [createAskUserToolDefinition(askUser)]),
+                ...workbenchTools,
             ];
             const options = {
                 services,
                 sessionManager,
                 ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
                 customTools,
-                tools: managementAgentToolNames(managementContext),
+                tools: managementAgentToolNames(managementContext, workbenchToolNames),
                 ...(initialModel === undefined ? {} : { model: initialModel }),
+                ...(initialThinkingLevel === undefined ? {} : { thinkingLevel: initialThinkingLevel }),
             };
             const result = await createAgentSessionFromServices(options);
             return { ...result, services, diagnostics: services.diagnostics };
@@ -404,6 +499,8 @@ export class PiSessionService {
         this.active = new Map();
         this.runtimeBySession = new WeakMap();
         this.pendingSessionOpens = new Map();
+        /** Sessions whose extension binding is parked on a `session_start` dialog. */
+        this.startupSessions = new Map();
         this.activities = new SessionActivityCoordinator();
         /** Runtime-identity gate held while Pi may await abandoned-branch summarization. */
         this.treeNavigations = new WeakSet();
@@ -434,6 +531,8 @@ export class PiSessionService {
          */
         this.subsessionNotifyArmed = new Map();
         this.notificationGenerationBySession = new WeakMap();
+        /** The parked extension Promise resolvers behind the store's open dialogs. */
+        this.dialogWaiters = new ExtensionDialogWaiters();
         this.pendingUnreadMutations = [];
         this.unreadPublicationFlushRequested = false;
         this.unreadPublicationStopped = false;
@@ -474,10 +573,15 @@ export class PiSessionService {
         this.spawnTargets = deps.spawnTargets;
         this.projectWorkspaces = deps.projectWorkspaces;
         this.logger = deps.logger ?? noopLogger;
+        this.normalToolAudit = deps.normalToolAudit;
+        this.managementAudit = deps.managementAudit;
+        this.managementProjectIdForCwd = deps.managementProjectIdForCwd;
         this.now = deps.now ?? (() => new Date());
         this.notificationStore = deps.notificationStore ?? new SessionNotificationStore();
         this.unreadStore = deps.unreadStore ?? new SessionUnreadStore();
         this.pendingAskStore = deps.pendingAskStore ?? new PendingAskStore();
+        this.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;
@@ -489,7 +593,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.askUserEnabled === true ? { open: (input) => this.openAsk(input) } : undefined, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd);
         this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
         this.workspaceActivity = deps.workspaceActivity;
         this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
@@ -578,6 +682,10 @@ export class PiSessionService {
         this.clearUnreadPublicationRetry();
         clearInterval(this.heartbeat);
         this.clearCompactionDrainTimers();
+        // Same startup-park hazard as closeActive(): settle `session_start` dialogs
+        // of sessions still binding extensions before awaiting their pending opens.
+        for (const startup of this.startupSessions.values())
+            this.endSessionExtensionDialogs(startup.session);
         const pendingOpens = this.pendingSessionOpenPromises();
         if (pendingOpens.length > 0)
             await Promise.allSettled(pendingOpens);
@@ -585,9 +693,11 @@ export class PiSessionService {
         for (const active of activeSessions) {
             this.forgetUnreadActivity(active.runtime.session);
             this.pendingAskStore.forgetSession(active.runtime.session.sessionId);
+            this.endSessionExtensionDialogs(active.runtime.session);
         }
         this.active.clear();
         this.pendingSessionOpens.clear();
+        this.startupSessions.clear();
         this.activities.clear();
         this.compactionPromptQueues.clear();
         this.authLossWarnings.clear();
@@ -641,7 +751,7 @@ export class PiSessionService {
         return { sessionIds };
     }
     async setPinned(ref, pinned, managementContext) {
-        if (typeof ref === "string" || ref.cwd === "")
+        if (ref.cwd === "")
             throw new Error("置顶会话必须提供工作区");
         const sessions = await this.list(ref.cwd, managementContext);
         const session = sessions.find((candidate) => candidate.id === ref.id);
@@ -745,6 +855,7 @@ export class PiSessionService {
         const active = await this.create(this.sessionManager.create(cwd, options.parentSession === undefined ? undefined : { parentSession: options.parentSession }), cwd, {
             ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
             ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
             ...(options.startupToken === undefined ? {} : { startupToken: options.startupToken }),
             startupIntent: "create",
@@ -779,10 +890,27 @@ export class PiSessionService {
         const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
         if (!decision.allowed)
             throw spawnTargetError(decision);
-        const created = await this.start(decision.cwd, input.model === undefined ? {} : { initialModel: input.model });
-        await this.prompt(created.id, input.prompt);
+        // A model spec overrides the inherited model. Only a spec triggers a
+        // spawning-session lookup; the default path must not depend on it.
+        let model = input.model;
+        if (input.modelSpec !== undefined) {
+            model = await this.resolveSpawnModel({ id: input.spawningSessionId, cwd: input.spawningCwd }, input.modelSpec, input.managementContext);
+        }
+        const created = await this.start(decision.cwd, {
+            ...(model === undefined ? {} : { initialModel: model }),
+            ...(input.thinkingLevel === undefined ? {} : { initialThinkingLevel: input.thinkingLevel }),
+            ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
+        });
+        const modelUsed = this.activeForLookup(created.id, input.managementContext)?.runtime.session.model;
+        await this.prompt(created.id, input.prompt, undefined, undefined, {
+            ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
+        });
         this.logger.info({ spawningCwd: input.spawningCwd, sessionId: created.id, cwd: decision.cwd, promptLength: input.prompt.length }, "spawn_session started a new session");
-        return { sessionId: created.id, cwd: decision.cwd };
+        return {
+            sessionId: created.id,
+            cwd: decision.cwd,
+            ...(modelUsed === undefined ? {} : { model: modelSpecOf(modelUsed) }),
+        };
     }
     /**
      * Start a *tracked* child session on behalf of a LLM. Identical to
@@ -792,15 +920,23 @@ export class PiSessionService {
      */
     async spawnSubsession(input) {
         if (this.spawnTargets === undefined)
-            throw new Error("Spawning sessions is disabled");
+            throw new Error("派生会话已禁用");
         const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
         if (!decision.allowed)
             throw spawnTargetError(decision);
+        // A model spec overrides the inherited model and is resolved against the
+        // parent's model runtime; only a spec triggers that lookup.
+        const model = input.modelSpec === undefined
+            ? input.model
+            : await this.resolveSpawnModel({ id: input.parentSessionId, cwd: input.spawningCwd }, input.modelSpec, input.managementContext);
         const created = await this.startSession(decision.cwd, {
             ...(input.parentSessionFile === undefined ? {} : { parentSession: input.parentSessionFile }),
-            ...(input.model === undefined ? {} : { initialModel: input.model }),
+            ...(model === undefined ? {} : { initialModel: model }),
+            ...(input.thinkingLevel === undefined ? {} : { initialThinkingLevel: input.thinkingLevel }),
+            ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
             creationProvenance: "tracked-subsession",
         });
+        const modelUsed = this.activeForLookup(created.id, input.managementContext)?.runtime.session.model;
         const parentSessionFile = nonEmptyString(input.parentSessionFile);
         const link = {
             parentSessionId: input.parentSessionId,
@@ -812,9 +948,45 @@ export class PiSessionService {
         await this.registerVerifiedSubsession(link);
         this.persistSubsessionLink(link);
         this.persistSubsessionChildMarker(input.parentSessionId, created.id);
-        await this.prompt(created.id, input.prompt);
+        await this.prompt(created.id, input.prompt, undefined, undefined, {
+            ...(input.managementContext === undefined ? {} : { managementContext: input.managementContext }),
+        });
         this.logger.info({ parentSessionId: input.parentSessionId, sessionId: created.id, cwd: decision.cwd, promptLength: input.prompt.length }, "spawn_subsession started a tracked child session");
-        return { sessionId: created.id, cwd: decision.cwd };
+        return {
+            sessionId: created.id,
+            cwd: decision.cwd,
+            ...(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.
+     */
+    async sessionModelCandidates(session) {
+        await session.modelRuntime.refresh();
+        return session.scopedModels.length > 0
+            ? session.scopedModels.map((scoped) => scoped.model)
+            : await session.modelRuntime.getAvailable();
+    }
+    /**
+     * Resolve a strict `provider/model-id` spec from a spawn tool against the
+     * *spawning* session's model runtime, using the same candidates
+     * {@link setModel} offers plus a direct runtime lookup as fallback. Unknown
+     * or malformed specs throw; the agent loop turns that into an error tool
+     * result the spawning agent can retry from.
+     */
+    async resolveSpawnModel(spawningSession, modelSpec, managementContext) {
+        const session = await this.getOrOpen(spawningSession, managementContext);
+        const parsed = parseModelSpec(modelSpec);
+        const candidates = await this.sessionModelCandidates(session);
+        const model = parsed === undefined
+            ? undefined
+            : candidates.find((candidate) => candidate.provider === parsed.provider && candidate.id === parsed.modelId)
+                ?? session.modelRuntime.getModel(parsed.provider, parsed.modelId);
+        if (model === undefined)
+            throw unknownSpawnModelError(modelSpec);
+        return model;
     }
     /**
      * Register the question set an agent wants the user to answer as the session's
@@ -895,14 +1067,129 @@ export class PiSessionService {
         this.publishStatus(session);
     }
     /**
-     * Publish status for a session known only by id, as the ask tools are: they
-     * run inside the session's own runtime, so the active entry is the session.
+     * Record the user's answer to an open extension dialog and resolve the
+     * extension's parked Promise with it. Unlike an ask, nothing is delivered to
+     * the model: the waiter is extension code inside an already in-flight run
+     * (or an idle handler), so no custom message and no turn are triggered.
      */
-    publishStatusForSessionId(sessionId) {
-        const session = this.active.get(sessionId)?.runtime.session;
-        if (session !== undefined)
+    async answerDialog(ref, dialogId, value, managementContext) {
+        await this.assertWritable(ref);
+        const session = await this.sessionForStatusOrDialogClose(ref, managementContext);
+        const result = this.pendingExtensionDialogStore.answer(this.dialogSessionKey(session), dialogId, value);
+        if (result.status === "stale")
+            return { result: "stale", sessionStatus: this.statusFromSession(session) };
+        const { outcome } = result;
+        this.publishDialogClosed(session, outcome);
+        // `value` is what the store validated and recorded as the outcome's answer.
+        this.dialogWaiters.settleWithAnswer(dialogId, value);
+        this.publishStatus(session);
+        return { result: "closed", outcome, sessionStatus: this.statusFromSession(session) };
+    }
+    /** Close an open extension dialog without an answer; the extension's wait settles with its kind's cancel value. */
+    async cancelDialog(ref, dialogId, managementContext) {
+        await this.assertWritable(ref);
+        const session = await this.sessionForStatusOrDialogClose(ref, managementContext);
+        const result = this.pendingExtensionDialogStore.cancel(this.dialogSessionKey(session), dialogId, "cancelled");
+        if (result.status === "stale")
+            return { result: "stale", sessionStatus: this.statusFromSession(session) };
+        const { outcome } = result;
+        this.publishDialogClosed(session, outcome);
+        this.dialogWaiters.settleWithCancelValue(dialogId);
+        this.publishStatus(session);
+        return { result: "closed", outcome, sessionStatus: this.statusFromSession(session) };
+    }
+    /**
+     * Implement one `ctx.ui.select()`/`confirm()`/`input()` call from extension
+     * code: open the store record, tell the browsers, and park a Promise that
+     * settles when the browser answers or cancels, the extension's own
+     * `signal`/`timeout` dismisses the dialog, the daemon default timeout
+     * elapses, or the runtime goes away. `store.open` validates the dialog, so a
+     * malformed one rejects the extension's call rather than rendering garbage.
+     * `async` so a rejected dialog becomes a rejection rather than a synchronous
+     * throw from a promise-returning method.
+     */
+    async openExtensionDialog(session, request, opts) {
+        const signal = opts?.signal;
+        // A pre-aborted signal dismisses the dialog before it ever opens.
+        if (signal?.aborted === true)
+            return extensionDialogCancelValue(request.kind);
+        const timeoutMs = effectiveExtensionDialogTimeoutMs(opts?.timeout, this.extensionDialogsTimeoutMs);
+        const dialog = this.pendingExtensionDialogStore.open({
+            sessionId: this.dialogSessionKey(session),
+            kind: request.kind,
+            title: request.title,
+            ...(request.message === undefined ? {} : { message: request.message }),
+            ...(request.options === undefined ? {} : { options: request.options }),
+            ...(request.placeholder === undefined ? {} : { placeholder: request.placeholder }),
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+            runScoped: session.isStreaming,
+        });
+        this.events.publish(session.sessionId, { type: "dialog.opened", dialog }, this.eventScopeForSession(session));
+        this.publishStatus(session);
+        return this.dialogWaiters.park(dialog, {
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+            ...(signal === undefined ? {} : { signal }),
+            onTrigger: (reason) => {
+                if (this.closeExtensionDialogFromTrigger(session, dialog.dialogId, reason))
+                    this.publishStatus(session);
+            },
+        });
+    }
+    /**
+     * Close a dialog whose wait ended without the browser (timeout, signal
+     * abort, run end, runtime teardown) and settle its parked Promise. Returns
+     * whether this call closed the dialog; a stale close means a browser answer
+     * or an earlier trigger already settled everything.
+     */
+    closeExtensionDialogFromTrigger(session, dialogId, reason) {
+        const result = this.pendingExtensionDialogStore.cancel(this.dialogSessionKey(session), dialogId, reason);
+        if (result.status !== "closed")
+            return false;
+        this.publishDialogClosed(session, result.outcome);
+        this.dialogWaiters.settleWithCancelValue(dialogId);
+        return true;
+    }
+    /**
+     * Settle the session's run-scoped dialogs as `"aborted"`. Runs at
+     * abort-request time (a user abort parks the agent loop behind the dialog
+     * handler, so `agent_end` would never arrive on its own) and again from
+     * the `agent_end` observer as the run-crash backstop — the store makes the
+     * second settlement a stale no-op. Idle-opened dialogs (a `session_start`
+     * probe, say) are not run-scoped and survive, because their waiter
+     * outlives the run.
+     */
+    abortRunScopedExtensionDialogs(session) {
+        let closedAny = false;
+        for (const dialog of this.pendingExtensionDialogStore.pendingDialogs(this.dialogSessionKey(session))) {
+            if (dialog.runScoped)
+                closedAny = this.closeExtensionDialogFromTrigger(session, dialog.dialogId, "aborted") || closedAny;
+        }
+        if (closedAny)
+            this.publishStatus(session);
+    }
+    /**
+     * Settle every dialog of the session as `"session-ended"`: the runtime
+     * whose extension code is parked on them is being closed, replaced, or
+     * disposed, so those Promises would otherwise never settle.
+     */
+    endSessionExtensionDialogs(session) {
+        let closedAny = false;
+        for (const dialog of this.pendingExtensionDialogStore.pendingDialogs(this.dialogSessionKey(session))) {
+            closedAny = this.closeExtensionDialogFromTrigger(session, dialog.dialogId, "session-ended") || closedAny;
+        }
+        // Publishes only while the session is still (or already re-)registered as
+        // active, so teardown paths stay silent and runtime replacement refreshes.
+        if (closedAny)
             this.publishStatus(session);
     }
+    publishDialogClosed(session, outcome) {
+        this.events.publish(session.sessionId, {
+            type: "dialog.closed",
+            dialogId: outcome.dialogId,
+            reason: outcome.reason,
+            ...(outcome.answer === undefined ? {} : { answer: outcome.answer }),
+        }, this.eventScopeForSession(session));
+    }
     /** Summaries of the tracked subsessions spawned by `parentSessionId`. */
     async listSubsessions(parentSessionId, parentSessionFile) {
         const parentFile = nonEmptyString(parentSessionFile);
@@ -1227,7 +1514,7 @@ export class PiSessionService {
         return pageMessagesAtSafeBoundary(historyMessages(session), page);
     }
     async status(ref, managementContext) {
-        return this.statusFromSession(await this.getOrOpen(ref, managementContext));
+        return this.statusFromSession(await this.sessionForStatusOrDialogClose(ref, managementContext));
     }
     async searchCandidates(cwd, normalizedQuery, managementContext) {
         const listing = await this.listWorkspaceSessions(cwd, managementContext);
@@ -1255,24 +1542,20 @@ export class PiSessionService {
         const streamingMessage = session.state.streamingMessage;
         const partial = streamingMessage === undefined || streamingMessage === null
             ? null
-            : projectBrowserMessage(streamingMessage);
+            : annotateAssistantThinkingLevel(projectBrowserMessage(streamingMessage), session.thinkingLevel);
         return { seq, partial };
     }
     async availableModels(ref, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
-        await session.modelRuntime.refresh();
-        const models = session.scopedModels.length > 0
-            ? session.scopedModels.map((scoped) => scoped.model)
-            : await session.modelRuntime.getAvailable();
+        const models = await this.sessionModelCandidates(session);
         return models.map(modelToClientModel);
     }
     async setModel(ref, provider, modelId, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        await session.modelRuntime.refresh();
-        const candidates = session.scopedModels.length > 0
-            ? session.scopedModels.map((scoped) => scoped.model)
-            : await session.modelRuntime.getAvailable();
+        this.assertTreeNavigationInactive(session, "change models");
+        const candidates = await this.sessionModelCandidates(session);
+        this.assertTreeNavigationInactive(session, "change models");
         const model = candidates.find((candidate) => candidate.provider === provider && candidate.id === modelId)
             ?? session.modelRuntime.getModel(provider, modelId);
         if (model === undefined)
@@ -1748,6 +2031,7 @@ export class PiSessionService {
         const sessionId = active.runtime.session.sessionId;
         this.clearCompactionPromptQueue(sessionId);
         clearSessionQueue(active.runtime.session);
+        this.abortRunScopedExtensionDialogs(active.runtime.session);
         try {
             await this.abortSessionOperations(active.runtime.session);
             this.publishActivity(active.runtime.session, "已停止", "idle");
@@ -1770,7 +2054,17 @@ export class PiSessionService {
         return this.statusFromSession(session);
     }
     async stop(ref, managementContext) {
-        const active = this.activeForLookup(ref, managementContext);
+        let active = this.activeForLookup(ref, managementContext);
+        if (active === undefined) {
+            const startup = this.startupSessionForLookup(ref, managementContext);
+            if (startup !== undefined) {
+                this.endSessionExtensionDialogs(startup);
+                const pendingOpens = this.pendingSessionOpenPromises(startup.sessionId);
+                if (pendingOpens.length > 0)
+                    await Promise.allSettled(pendingOpens);
+                active = this.activeForLookup(ref, managementContext);
+            }
+        }
         if (active !== undefined) {
             await this.closeActiveSession(active);
             return;
@@ -1780,19 +2074,7 @@ export class PiSessionService {
         }
     }
     async bulkSessionLookupContext(refs) {
-        const cwdSet = new Set();
-        let needsAllSessions = false;
-        for (const ref of refs) {
-            if (ref.cwd === undefined)
-                needsAllSessions = true;
-            else
-                cwdSet.add(ref.cwd);
-        }
-        const [sessionsByCwd, allSessions] = await Promise.all([
-            this.listSessionsByCwd([...cwdSet]),
-            needsAllSessions ? this.sessionManager.listAll?.() ?? Promise.resolve([]) : Promise.resolve(undefined),
-        ]);
-        return allSessions === undefined ? { sessionsByCwd } : { sessionsByCwd, allSessions };
+        return { sessionsByCwd: await this.listSessionsByCwd(refs.map((ref) => ref.cwd)) };
     }
     async listSessionsByCwd(cwds) {
         const uniqueCwds = uniqueStrings(cwds);
@@ -1966,6 +2248,10 @@ export class PiSessionService {
         return [...names];
     }
     async closeActive(sessionId, notificationPolicy = CLEAR_RUNTIME_NOTIFICATIONS) {
+        for (const startup of this.startupSessions.values()) {
+            if (startup.session.sessionId === sessionId)
+                this.endSessionExtensionDialogs(startup.session);
+        }
         const pendingOpens = this.pendingSessionOpenPromises(sessionId);
         if (pendingOpens.length > 0)
             await Promise.allSettled(pendingOpens);
@@ -1996,6 +2282,7 @@ export class PiSessionService {
         }
         this.forgetUnreadActivity(active.runtime.session);
         this.pendingAskStore.forgetSession(sessionId);
+        this.endSessionExtensionDialogs(active.runtime.session);
         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);
@@ -2045,6 +2332,26 @@ export class PiSessionService {
     async getOrOpen(ref, managementContext) {
         return (await this.getActive(ref, managementContext)).runtime.session;
     }
+    startupSessionForLookup(ref, managementContext) {
+        const contextKey = managementContextKey(managementContext);
+        const eventScope = eventScopeFromManagementContext(managementContext);
+        const sessionId = sessionIdFromLookup(ref);
+        const exact = this.startupSessions.get(activeSessionKey(sessionId, eventScope));
+        if (exact !== undefined && exact.managementContextKey === contextKey && lookupMatchesStartupSession(ref, exact.session))
+            return exact.session;
+        for (const startup of this.startupSessions.values()) {
+            if (startup.managementContextKey !== contextKey || !startup.session.sessionId.startsWith(sessionId))
+                continue;
+            if (lookupMatchesStartupSession(ref, startup.session))
+                return startup.session;
+        }
+        return undefined;
+    }
+    /** Resolve status and dialog-close calls even while extension startup is waiting for the browser. */
+    async sessionForStatusOrDialogClose(ref, managementContext) {
+        const reachable = this.activeForLookup(ref, managementContext)?.runtime.session ?? this.startupSessionForLookup(ref, managementContext);
+        return reachable ?? this.getOrOpen(ref, managementContext);
+    }
     async getActive(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
         if (active !== undefined)
@@ -2151,17 +2458,25 @@ export class PiSessionService {
             startup.end();
         }
     }
-    async bindSessionExtensions(session, generation) {
+    async bindSessionExtensions(session, generation, owner) {
         const uiContext = this.sessionUiContext(session, generation);
-        await session.bindExtensions({
-            uiContext,
-            mode: "rpc",
-            onError: (error) => {
-                const message = `${error.extensionPath}: ${error.error}`;
-                this.publishActivity(session, "扩展错误", "error", message);
-                this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
-            },
-        });
+        const key = activeSessionKey(session.sessionId, owner.eventScope);
+        this.startupSessions.set(key, { session, ...owner });
+        try {
+            await session.bindExtensions({
+                uiContext,
+                mode: "rpc",
+                onError: (error) => {
+                    const message = `${error.extensionPath}: ${error.error}`;
+                    this.publishActivity(session, "扩展错误", "error", message);
+                    this.events.publish(session.sessionId, { type: "session.error", message }, owner.eventScope);
+                },
+            });
+        }
+        finally {
+            if (this.startupSessions.get(key)?.session === session)
+                this.startupSessions.delete(key);
+        }
     }
     bindRuntime(active, session = active.runtime.session) {
         this.runtimeBySession.set(session, active.runtime);
@@ -2174,9 +2489,12 @@ export class PiSessionService {
             }
         }
         active.unsubscribe = session.subscribe((event) => {
-            this.events.publish(session.sessionId, toClientEvent(event), active.eventScope);
+            this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel), active.eventScope);
+            this.auditToolExecutionEvent(active, event);
             this.publishActivityForEvent(session, event);
             const eventType = getString(event, "type");
+            if (eventType === "agent_end")
+                this.abortRunScopedExtensionDialogs(session);
             if (eventType === "compaction_end")
                 this.scheduleCompactionQueueDrain(session.sessionId);
             if (eventType === "agent_start" || eventType === "agent_end")
@@ -2501,6 +2819,46 @@ export class PiSessionService {
         if (this.hasActiveWork(session))
             this.publishActivity(session, "正在处理", "active");
     }
+    auditToolExecutionEvent(active, event) {
+        const eventType = getString(event, "type");
+        if (eventType !== "tool_execution_start" && eventType !== "tool_execution_end")
+            return;
+        const isEnd = eventType === "tool_execution_end";
+        const auditEvent = {
+            sessionId: active.runtime.session.sessionId,
+            cwd: active.runtime.cwd,
+            toolName: getString(event, "toolName") ?? "unknown",
+            toolCallId: getString(event, "toolCallId") ?? "unknown",
+            status: isEnd ? (getBoolean(event, "isError") === true ? "failed" : "completed") : "started",
+        };
+        const managementIdentity = active.managementAuditIdentity;
+        this.logger.info({
+            mode: active.managementContextKey === undefined ? "normal" : "management",
+            ...(managementIdentity ?? {}),
+            ...auditEvent,
+        }, "Pi tool execution audit");
+        if (managementIdentity !== undefined) {
+            try {
+                this.managementAudit?.record({ action: "tool_execution", ...managementIdentity, ...auditEvent });
+            }
+            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");
+            }
+            return;
+        }
+        if (this.normalToolAudit === undefined)
+            return;
+        try {
+            this.normalToolAudit.record(auditEvent);
+        }
+        catch (error) {
+            this.logger.info({
+                sessionId: auditEvent.sessionId,
+                toolCallId: auditEvent.toolCallId,
+                error: error instanceof Error ? error.message : String(error),
+            }, "failed to persist ordinary-mode tool audit");
+        }
+    }
     /**
      * Build the reporter for one session construction.
      *
@@ -2589,14 +2947,34 @@ export class PiSessionService {
             if (active.runtime.session === session)
                 return active.eventScope;
         }
+        for (const startup of this.startupSessions.values()) {
+            if (startup.session === session)
+                return startup.eventScope;
+        }
         return NORMAL_SESSION_EVENT_SCOPE;
     }
+    dialogSessionKey(session) {
+        const eventScope = this.eventScopeForSession(session);
+        return eventScope === NORMAL_SESSION_EVENT_SCOPE ? session.sessionId : activeSessionKey(session.sessionId, eventScope);
+    }
+    publishStatusForSessionId(sessionId) {
+        const sessions = new Set();
+        for (const active of this.activeSessionsForId(sessionId))
+            sessions.add(active.runtime.session);
+        for (const startup of this.startupSessions.values()) {
+            if (startup.session.sessionId === sessionId)
+                sessions.add(startup.session);
+        }
+        for (const session of sessions)
+            this.publishStatus(session);
+    }
     statusFromSession(session) {
         const stats = session.getSessionStats();
         const model = session.model === undefined ? undefined : modelToClientModel(session.model);
         const contextUsage = session.getContextUsage();
         const warnings = this.warningsForSession(session);
         const pendingAsk = this.pendingAskStore.pendingAsk(session.sessionId);
+        const pendingDialogs = this.pendingExtensionDialogStore.pendingDialogs(this.dialogSessionKey(session));
         return {
             sessionId: session.sessionId,
             persisted: sessionFileExists(session.sessionFile),
@@ -2613,6 +2991,7 @@ export class PiSessionService {
             ...(contextUsage === undefined ? {} : { contextUsage }),
             ...(warnings.length === 0 ? {} : { warnings }),
             ...(pendingAsk === undefined ? {} : { pendingAsk }),
+            ...(pendingDialogs.length === 0 ? {} : { pendingDialogs }),
         };
     }
     /**
@@ -2746,12 +3125,16 @@ export class PiSessionService {
             delegationToolsEnabled,
             ...(options.managementContext === undefined ? {} : { managementContext: options.managementContext }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
         });
         const active = {
             runtime,
             unsubscribe: noop,
             managementContextKey: managementContextKey(options.managementContext),
             eventScope: eventScopeFromManagementContext(options.managementContext),
+            ...(options.managementContext === undefined ? {} : {
+                managementAuditIdentity: await resolveManagementAuditIdentity(cwd, options.managementContext, this.managementProjectIdForCwd, this.logger),
+            }),
         };
         let boundSession = runtime.session;
         let notificationGeneration = options.notificationGeneration;
@@ -2783,7 +3166,7 @@ export class PiSessionService {
                 await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
             }
             startup.report(STARTUP_PHASE_EXTENSIONS);
-            await this.bindSessionExtensions(runtime.session, notificationGeneration);
+            await this.bindSessionExtensions(runtime.session, notificationGeneration, active);
             this.bindRuntime(active);
             runtime.setRebindSession(async (session) => {
                 const priorGeneration = notificationGeneration;
@@ -2796,8 +3179,12 @@ export class PiSessionService {
                         this.notificationGenerationBySession.set(session, candidateGeneration);
                     }
                     this.bindRuntime(active, session);
+                    // The runtime being replaced parked every dialog the store still
+                    // holds for this session; settle those waits before the new
+                    // runtime's extensions can open fresh dialogs under the same id.
+                    this.endSessionExtensionDialogs(boundSession);
                     boundSession = session;
-                    await this.bindSessionExtensions(session, candidateGeneration);
+                    await this.bindSessionExtensions(session, candidateGeneration, active);
                     if (candidateGeneration !== undefined) {
                         this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
                         notificationGeneration = candidateGeneration;
@@ -2831,6 +3218,7 @@ export class PiSessionService {
             }
             active.unsubscribe();
             this.forgetUnreadActivity(boundSession);
+            this.endSessionExtensionDialogs(boundSession);
             let removedActive = false;
             for (const [sessionKey, candidate] of this.active.entries()) {
                 if (candidate !== active)
@@ -2878,15 +3266,26 @@ export class PiSessionService {
                 notificationId: added.notification.id,
             });
         };
-        // PI WEB owns the browser-facing notification and text-formatting
-        // boundaries. Delegate every other UI method to Pi's headless defaults so
-        // unsupported dialogs cancel safely instead of hanging.
+        // PI WEB owns the browser-facing dialog, notification, and text-formatting
+        // boundaries: the three dialog primitives park daemon-held Promises that
+        // the browser answers, while every other UI method delegates to Pi's
+        // headless defaults so unsupported surfaces cancel safely instead of
+        // hanging.
         return new Proxy(baseUiContext, {
-            get(target, property, receiver) {
+            get: (target, property, receiver) => {
                 if (property === "notify")
                     return notify;
                 if (property === "theme")
                     return plainTextTheme;
+                if (property === "confirm") {
+                    return (title, message, opts) => this.openExtensionDialog(session, { kind: "confirm", title, message }, opts);
+                }
+                if (property === "select") {
+                    return (title, options, opts) => this.openExtensionDialog(session, { kind: "select", title, options }, opts);
+                }
+                if (property === "input") {
+                    return (title, placeholder, opts) => this.openExtensionDialog(session, { kind: "input", title, placeholder }, opts);
+                }
                 const value = Reflect.get(target, property, receiver);
                 return value;
             },
@@ -3040,7 +3439,7 @@ function uniqueBulkSessionRefs(refs) {
     const seen = new Set();
     const unique = [];
     for (const ref of refs) {
-        const key = `${ref.cwd ?? ""}\0${ref.id}`;
+        const key = `${ref.cwd}\0${ref.id}`;
         if (seen.has(key))
             continue;
         seen.add(key);
@@ -3049,15 +3448,13 @@ function uniqueBulkSessionRefs(refs) {
     return unique;
 }
 function bulkRefToLookup(ref) {
-    return ref.cwd === undefined ? ref.id : { id: ref.id, cwd: ref.cwd };
+    return ref;
 }
 function findArchivedRecordForBulkRef(records, ref) {
-    return records.find((record) => (ref.cwd === undefined || record.cwd === ref.cwd) && (record.sessionId === ref.id || record.sessionId.startsWith(ref.id)));
+    return records.find((record) => record.cwd === ref.cwd && (record.sessionId === ref.id || record.sessionId.startsWith(ref.id)));
 }
 function findListedSessionForBulkRef(context, ref) {
-    if (ref.cwd !== undefined)
-        return findSessionByIdOrPrefix(context.sessionsByCwd.get(ref.cwd) ?? [], ref.id);
-    return context.allSessions === undefined ? undefined : findSessionByIdOrPrefix(context.allSessions, ref.id);
+    return findSessionByIdOrPrefix(context.sessionsByCwd.get(ref.cwd) ?? [], ref.id);
 }
 function findSessionByIdOrPrefix(sessions, sessionId) {
     return sessions.find((session) => session.id === sessionId) ?? sessions.find((session) => session.id.startsWith(sessionId));
@@ -3352,11 +3749,17 @@ function historyMessages(session) {
 }
 function historyMessagesFromManager(sessionManager) {
     const messages = [];
+    let thinkingLevel;
     for (const entry of sessionManager.getBranch()) {
         if (!isRecord(entry))
             continue;
         if (entry["type"] === "message")
-            messages.push(entry["message"]);
+            messages.push(annotateAssistantThinkingLevel(entry["message"], thinkingLevel));
+        else if (entry["type"] === "thinking_level_change") {
+            const level = getString(entry, "thinkingLevel");
+            if (level !== undefined)
+                thinkingLevel = level;
+        }
         else if (entry["type"] === "custom_message" && entry["display"] === true)
             messages.push({ role: "custom", content: entry["content"], customType: entry["customType"], details: entry["details"] });
         else if (entry["type"] === "compaction")
@@ -3404,4 +3807,16 @@ function finalAssistantText(messages) {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
+async function resolveManagementAuditIdentity(cwd, context, resolveProjectId, logger) {
+    let projectId = context.projects[0]?.id ?? "default-project";
+    if (resolveProjectId !== undefined) {
+        try {
+            projectId = await resolveProjectId(cwd, context);
+        }
+        catch (error) {
+            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 };
+}
 //# sourceMappingURL=piSessionService.js.map