@jmfederico/pi-web 1.202607.3 → 1.202608.1

package/dist/server/sessions/piSessionService.js

@@ -16,8 +16,6 @@ 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 { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
 import { readSessionHeaderSummary } from "./sessionFileHeader.js";
-import { countOutOfListingChildren, locateOutOfListingParents } from "./parentSessionLocator.js";
-import { siblingWorkspaceCwds } from "../workspaces/projectWorkspaceCwds.js";
 import { createAskUserToolDefinition } from "./askUserTool.js";
 import { PendingAskStore, renderAskUserAnswersText } from "./pendingAskStore.js";
 import { PendingExtensionDialogStore } from "./pendingExtensionDialogStore.js";
@@ -56,20 +54,44 @@ function spawnTargetError(decision) {
         return new Error("Spawning session is not in a registered project");
     return new Error(`cwd must be a workspace of this project. Allowed: ${decision.allowedCwds.join(", ")}`);
 }
-function authLossWarningKey(sessionId, provider, modelId) {
-    return `${sessionId}:${provider}/${modelId}`;
+/**
+ * Tracked subsessions are worktree-scoped, so a requested target other than the
+ * parent's own cwd fails closed instead of being silently retargeted. The
+ * message names the rule and both supported ways to get work done elsewhere.
+ */
+function subsessionCwdError(spawningCwd, requestedCwd) {
+    return new Error(`A tracked subsession runs in this session's working directory (${spawningCwd}); ${requestedCwd} was requested. Instruct the child to work elsewhere from this workspace, or use spawn_session for an independent session in another workspace.`);
 }
-function sessionIdFromLookup(ref) {
-    return typeof ref === "string" ? ref : ref.id;
+function modelSpecOf(model) {
+    return `${model.provider}/${model.id}`;
 }
-function isPiSessionRef(ref) {
-    return typeof ref !== "string";
+/**
+ * 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) };
 }
-function lookupMatchesActiveSession(ref, active) {
-    return !isPiSessionRef(ref) || cwdPathsEqual(active.runtime.cwd, ref.cwd);
+/**
+ * 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(`Unknown model "${modelSpec}". Pass an exact "provider/model-id".`);
 }
-function lookupMatchesStartupSession(ref, session) {
-    return !isPiSessionRef(ref) || cwdPathsEqual(session.sessionManager.getCwd(), ref.cwd);
+function authLossWarningKey(sessionId, provider, modelId) {
+    return `${sessionId}:${provider}/${modelId}`;
+}
+function refMatchesActiveSession(ref, active) {
+    return cwdPathsEqual(active.runtime.cwd, ref.cwd);
+}
+function refMatchesStartupSession(ref, session) {
+    return cwdPathsEqual(session.sessionManager.getCwd(), ref.cwd);
 }
 function sessionTreeNavigationOptions(request) {
     switch (request.summary.mode) {
@@ -220,26 +242,31 @@ 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 = createRuntimeWithOneShotSessionOptions(createRuntime, options.initialModel, options.delegationToolsEnabled);
+    const runtimeFactory = createRuntimeWithOneShotSessionOptions(createRuntime, options.initialModel, options.initialThinkingLevel, options.delegationToolsEnabled);
     return createAgentSessionRuntime(runtimeFactory, {
         cwd: options.cwd,
         agentDir: options.agentDir,
         sessionManager: options.sessionManager,
     });
 }
-function createRuntimeWithOneShotSessionOptions(createRuntime, initialModel, delegationToolsEnabled) {
+function createRuntimeWithOneShotSessionOptions(createRuntime, initialModel, initialThinkingLevel, delegationToolsEnabled) {
     // These inputs belong only to the session being opened. A later runtime
-    // replacement resolves its own model and delegation capability.
+    // replacement resolves its own model and delegation capability, and restores
+    // the thinking level from the existing session file.
     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,
             ...(model === undefined ? {} : { initialModel: model }),
+            ...(thinkingLevel === undefined ? {} : { initialThinkingLevel: thinkingLevel }),
             ...(toolsEnabled === undefined ? {} : { delegationToolsEnabled: toolsEnabled }),
         });
     };
@@ -254,9 +281,28 @@ export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn,
         ...(askUser === undefined ? [] : [createAskUserToolDefinition(askUser)]),
     ];
 }
-function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subsessions, askUser) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, delegationToolsEnabled }) => {
-        const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime });
+/**
+ * Resource-loader options that append PI WEB's own system-prompt sections.
+ *
+ * `appendSystemPromptOverride` composes with what the loader already resolved,
+ * so the operator's `SYSTEM.md` / `APPEND_SYSTEM.md` files keep their content
+ * and PI WEB's sections land after them. Returns `undefined` when there is
+ * nothing to add, leaving the loader exactly as pi configures it.
+ */
+export function piWebResourceLoaderOptions(appendSystemPromptSections) {
+    if (appendSystemPromptSections.length === 0)
+        return undefined;
+    return { appendSystemPromptOverride: (base) => [...base, ...appendSystemPromptSections] };
+}
+function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subsessions, askUser, appendSystemPromptSections = []) {
+    const resourceLoaderOptions = piWebResourceLoaderOptions(appendSystemPromptSections);
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled }) => {
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            modelRuntime,
+            ...(resourceLoaderOptions === undefined ? {} : { resourceLoaderOptions }),
+        });
         const resolvedDelegationToolsEnabled = delegationToolsEnabled
             ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
         const customTools = createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions, askUser);
@@ -266,6 +312,7 @@ function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subse
             customTools,
             ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
             ...(initialModel === undefined ? {} : { model: initialModel }),
+            ...(initialThinkingLevel === undefined ? {} : { thinkingLevel: initialThinkingLevel }),
         });
         return { ...result, services, diagnostics: services.diagnostics };
     };
@@ -325,8 +372,6 @@ export class PiSessionService {
         this.subsessionLinks = new Map();
         /** 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
@@ -339,37 +384,23 @@ 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.agentDir = deps.agentDir;
         this.sessionManager = deps.sessionManager;
         this.modelRuntime = deps.modelRuntime;
         this.spawnTargets = deps.spawnTargets;
-        this.projectWorkspaces = deps.projectWorkspaces;
         this.logger = deps.logger ?? noopLogger;
         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.modelRuntime, this.sessionManager, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
@@ -377,11 +408,11 @@ 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.appendSystemPromptSections ?? []);
         this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
         this.workspaceActivity = deps.workspaceActivity;
         this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
-        this.commandService = new SessionCommandService((sessionId) => this.getActive(sessionId), (sessionId, text) => this.prompt(sessionId, text, undefined, undefined, { echoUserMessage: false }), events, {
+        this.commandService = new SessionCommandService((sessionId) => this.getActive(this.activeSessionRef(sessionId)), (sessionId, text) => this.prompt(this.activeSessionRef(sessionId), text, undefined, undefined, { echoUserMessage: false }), events, {
             onCompactionStart: (session) => {
                 this.beginSessionEntryMutation(session, "compact the session");
                 this.publishActivity(session, "compacting", "active");
@@ -465,7 +496,6 @@ export class PiSessionService {
             await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
             readyDeleteRecords.push(record);
         }
-        await this.ensureArchivedRecordsMoved(readyDeleteRecords);
         const deletedSessionIds = new Set(await this.archiveStoreDeleteArchivedMany(readyDeleteRecords.map((record) => record.sessionId)));
         deleteRecords.push(...readyDeleteRecords.filter((record) => deletedSessionIds.has(record.sessionId)));
         await this.forgetUnreadSessions(deleteRecords);
@@ -506,7 +536,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();
@@ -524,9 +553,7 @@ export class PiSessionService {
     async list(cwd) {
         const [sessions, archivedRecords] = await Promise.all([this.sessionManager.list(cwd), this.archiveStore.list()]);
         const sessionsById = new Map(sessions.map((session) => [session.id, session]));
-        const archivedForCwd = await Promise.all(archivedRecords
-            .filter((record) => record.cwd === cwd)
-            .map((record) => this.ensureArchivedSessionMoved(record, sessionsById.get(record.sessionId))));
+        const archivedForCwd = archivedRecords.filter((record) => record.cwd === cwd);
         const archivedById = new Map(archivedForCwd.map((record) => [record.sessionId, record]));
         for (const record of archivedForCwd) {
             this.publishNotificationMutations(this.notificationStore.clearSession(record.sessionId, "archive-reconcile"));
@@ -539,63 +566,7 @@ export class PiSessionService {
             .sort(compareArchivedRecords)
             .map((record) => clientSessionFromArchivedRecord(record, sessionsById.get(record.sessionId)))
             .filter(isDefined);
-        return await this.withRelatedSessionsElsewhere([...unarchivedSessions, ...archivedSessions], cwd);
-    }
-    /**
-     * 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();
-        }
+        return [...unarchivedSessions, ...archivedSessions];
     }
     async start(cwd, options = {}) {
         return this.startSession(cwd, options);
@@ -605,6 +576,7 @@ export class PiSessionService {
             startupIntent: "create",
             ...(options.startupToken === undefined ? {} : { startupToken: options.startupToken }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
             ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
         });
         const { session } = active.runtime;
@@ -637,28 +609,55 @@ 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 resolves
+        // against the spawning session; the default path must not depend on it.
+        const model = input.modelSpec === undefined
+            ? input.model
+            : await this.resolveSpawnModel({ id: input.spawningSessionId, cwd: input.spawningCwd }, input.modelSpec);
+        const created = await this.start(decision.cwd, {
+            ...(model === undefined ? {} : { initialModel: model }),
+            ...(input.thinkingLevel === undefined ? {} : { initialThinkingLevel: input.thinkingLevel }),
+        });
+        const modelUsed = this.active.get(created.id)?.runtime.session.model;
+        await this.prompt(created, input.prompt);
         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
-     * {@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 session on behalf of a LLM. Unlike
+     * {@link spawnSession}, a tracked child always runs in the parent's own
+     * workspace: parent/child trees are worktree-scoped, so a child elsewhere
+     * would be invisible to the parent's listing. 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.
      */
     async spawnSubsession(input) {
         if (this.spawnTargets === undefined)
             throw new Error("Spawning sessions is disabled");
-        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);
+        }
+        // Resolved against the parent's own cwd only: this still refuses spawning
+        // from an unregistered directory, which keeps the child visible in the UI.
+        const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, undefined);
         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 resolves against the parent.
+        const model = input.modelSpec === undefined
+            ? input.model
+            : await this.resolveSpawnModel({ id: input.parentSessionId, cwd: input.spawningCwd }, input.modelSpec);
         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 }),
             creationProvenance: "tracked-subsession",
         });
+        const modelUsed = this.active.get(created.id)?.runtime.session.model;
         const parentSessionFile = nonEmptyString(input.parentSessionFile);
         const link = {
             parentSessionId: input.parentSessionId,
@@ -670,9 +669,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, input.prompt);
         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. The refresh
+     * stays local (`allowNetwork: false`); network refreshes belong to the
+     * bounded background catalog refresher, not this request path.
+     */
+    async sessionModelCandidates(session) {
+        await session.modelRuntime.refresh({ allowNetwork: false });
+        return session.scopedModels.length > 0
+            ? session.scopedModels.map((scoped) => scoped.model)
+            : session.modelRuntime.getAvailableSnapshot();
+    }
+    /**
+     * 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(spawningRef, modelSpec) {
+        const session = await this.getOrOpen(spawningRef);
+        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
@@ -1240,26 +1275,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) {
         const session = await this.getOrOpen(ref);
-        await session.modelRuntime.refresh();
-        const models = session.scopedModels.length > 0
-            ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRuntime.getAvailableSnapshot();
+        const models = await this.sessionModelCandidates(session);
         return models.map(modelToClientModel);
     }
     async setModel(ref, provider, modelId) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref);
         this.assertTreeNavigationInactive(session, "change models");
-        await session.modelRuntime.refresh();
+        const candidates = await this.sessionModelCandidates(session);
         this.assertTreeNavigationInactive(session, "change models");
-        const candidates = session.scopedModels.length > 0
-            ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRuntime.getAvailableSnapshot();
         const model = candidates.find((candidate) => candidate.provider === provider && candidate.id === modelId)
             ?? session.modelRuntime.getModel(provider, modelId);
         if (model === undefined)
@@ -1432,7 +1461,7 @@ export class PiSessionService {
     async navigateTree(ref, request) {
         if (request.targetId.trim() === "")
             throw new Error("Session tree target is required");
-        if (this.isTreeExclusiveSessionIdentityActive(sessionIdFromLookup(ref))) {
+        if (this.isTreeExclusiveSessionIdentityActive(ref.id)) {
             throw new Error("Stop current session activity before navigating the session tree");
         }
         await this.assertWritable(ref);
@@ -1482,6 +1511,83 @@ export class PiSessionService {
             }
         }
     }
+    /**
+     * Fork the session from one entry of its tree into a new session file,
+     * leaving the original session untouched. The forked runtime replaces the
+     * current one, so the outcome is reported for the session the client is
+     * about to join rather than the forked-from record.
+     */
+    async forkFromTree(ref, request) {
+        if (request.entryId.trim() === "")
+            throw new Error("Session tree entry is required");
+        if (this.isTreeExclusiveSessionIdentityActive(ref.id)) {
+            throw new Error("Stop current session activity before forking the session tree");
+        }
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        if (this.hasActiveWork(session))
+            throw new Error("Stop current session activity before forking the session tree");
+        if (session.sessionManager.getLeafId() !== request.expectedLeafId) {
+            throw new Error("The session changed since /tree was opened. Reopen /tree and try again.");
+        }
+        this.publishActivity(session, "forking session from entry", "active");
+        this.publishStatus(session);
+        try {
+            const result = await this.commandService.forkEntry(session.sessionId, request.entryId, {
+                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, "fork cancelled", "idle");
+                    this.publishStatus(session);
+                }
+                return { cancelled: true };
+            }
+            const forkedSession = this.active.get(result.session.id)?.runtime.session;
+            if (forkedSession !== undefined && this.isCurrentActiveSession(forkedSession)) {
+                this.publishActivity(forkedSession, "session forked", "idle");
+                this.publishStatus(forkedSession);
+            }
+            if (result.session.id !== session.sessionId)
+                this.clearSupersededSessionActivity(session);
+            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, "fork failed", "error", message);
+                this.events.publish(session.sessionId, { type: "session.error", message });
+                this.publishStatus(session);
+            }
+            throw error;
+        }
+    }
+    /**
+     * A changed-id fork can rebind its runtime after a heartbeat published the
+     * prior identity as active. Clear every observable owner before forgetting
+     * that identity's local activity record.
+     */
+    clearSupersededSessionActivity(session) {
+        const sessionId = session.sessionId;
+        if (this.activities.get(sessionId)?.phase === "active") {
+            const at = new Date().toISOString();
+            const stored = { phase: "idle", label: "idle", at };
+            this.activities.set(sessionId, stored);
+            const activity = { sessionId, ...stored };
+            this.events.publish(sessionId, { type: "activity.update", activity });
+            this.events.publishGlobal({ type: "activity.update", activity });
+        }
+        this.workspaceActivity?.removeSession(sessionId, session.sessionManager.getCwd());
+        this.activities.delete(sessionId);
+    }
     async reloadSessionRuntime(session) {
         if (this.hasActiveWork(session))
             throw new Error("Stop current session activity before reloading");
@@ -1531,7 +1637,7 @@ export class PiSessionService {
         const uniqueRefs = uniqueBulkSessionRefs(refs);
         const [archivedRecords, sessionContext] = await Promise.all([
             this.archiveStore.list(),
-            this.bulkSessionLookupContext(uniqueRefs),
+            this.bulkSessionRefContext(uniqueRefs),
         ]);
         const failures = [];
         const alreadyArchivedSessionIds = [];
@@ -1545,7 +1651,7 @@ export class PiSessionService {
                 unreadArchivedIdentities.push(archived);
                 continue;
             }
-            const active = this.activeForLookup(bulkRefToLookup(ref));
+            const active = this.activeForRef(bulkRefToSessionRef(ref));
             const listed = findListedSessionForBulkRef(sessionContext, ref);
             const resolvedSessionId = active?.runtime.session.sessionId ?? listed?.id ?? ref.id;
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
@@ -1569,7 +1675,7 @@ export class PiSessionService {
         }
         const readyPlanItems = [];
         for (const item of planItems) {
-            const active = this.activeForLookup({ id: item.input.sessionId, cwd: item.input.cwd });
+            const active = this.activeForRef({ id: item.input.sessionId, cwd: item.input.cwd });
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
                 failures.push({ sessionId: item.input.sessionId, error: "Stop current session activity before archiving" });
                 continue;
@@ -1646,18 +1752,6 @@ export class PiSessionService {
         await this.archiveStore.restore(archived.sessionId);
         await this.forgetUnreadSessions([archived]);
     }
-    async deleteArchived(ref) {
-        const record = await this.getArchived(ref);
-        if (record === undefined)
-            throw new Error("Archived session not found");
-        if (this.archiveStore.deleteArchived === undefined)
-            throw new Error("Archive store does not support deletion");
-        await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
-        if (record.archivePath === undefined)
-            await this.ensureArchivedRecordMoved(record);
-        await this.archiveStore.deleteArchived(record.sessionId);
-        await this.forgetUnreadSessions([record]);
-    }
     async deleteArchivedMany(refs) {
         if (this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
@@ -1671,7 +1765,7 @@ export class PiSessionService {
                 failures.push({ sessionId: ref.id, error: "Archived session not found" });
                 continue;
             }
-            const active = this.activeForLookup({ id: record.sessionId, cwd: record.cwd });
+            const active = this.activeForRef({ id: record.sessionId, cwd: record.cwd });
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
                 failures.push({ sessionId: record.sessionId, error: "Stop current session activity before deleting archived session" });
                 continue;
@@ -1688,12 +1782,7 @@ export class PiSessionService {
                 failures.push({ sessionId: item.record.sessionId, error: errorMessage(error) });
             }
         }
-        const moveFailures = await this.moveLegacyArchivedRecordsForDelete(readyRecords);
-        failures.push(...moveFailures);
-        const moveFailureIds = new Set(moveFailures.map((failure) => failure.sessionId));
-        const deleteIds = readyRecords
-            .map((record) => record.sessionId)
-            .filter((sessionId) => !moveFailureIds.has(sessionId));
+        const deleteIds = readyRecords.map((record) => record.sessionId);
         let deletedSessionIds = [];
         try {
             deletedSessionIds = await this.archiveStoreDeleteArchivedMany(deleteIds);
@@ -1746,6 +1835,11 @@ export class PiSessionService {
         if (sessionFile === undefined || sessionFile === "")
             throw new Error("Session is not persisted");
         await clearParentSession(sessionFile);
+        // The header rewrite keeps the inode, and whenever it leaves the file's
+        // size unchanged it is invisible to the gateway's summary memo, which
+        // cannot detect such rewrites from identity + size alone and would keep
+        // listing the old parent link until restart.
+        this.sessionManager.invalidateSessionFile(sessionFile);
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
         await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }]);
@@ -1765,7 +1859,7 @@ export class PiSessionService {
         return this.statusFromSession(session);
     }
     async abort(ref) {
-        const active = this.activeForLookup(ref);
+        const active = this.activeForRef(ref);
         if (active === undefined)
             return;
         const sessionId = active.runtime.session.sessionId;
@@ -1791,31 +1885,26 @@ export class PiSessionService {
         }
     }
     async stop(ref) {
-        const active = this.activeForLookup(ref);
+        const active = this.activeForRef(ref);
         if (active !== undefined) {
             await this.closeActive(active.runtime.session.sessionId);
             return;
         }
-        if (isPiSessionRef(ref)) {
-            this.publishNotificationMutations(this.notificationStore.clearSessionIdentity(ref.id, canonicalizeStoredCwd(ref.cwd), "runtime-close"));
+        // A session whose open is parked (e.g. on a session_start dialog) is not
+        // active yet; close it through the same path so stopping cannot block
+        // behind the dialog timeout.
+        const startup = this.startupSessionForRef(ref);
+        if (startup !== undefined) {
+            await this.closeActive(startup.sessionId);
             return;
         }
-        await this.closeActive(ref);
+        this.publishNotificationMutations(this.notificationStore.clearSessionIdentity(ref.id, canonicalizeStoredCwd(ref.cwd), "runtime-close"));
     }
-    async bulkSessionLookupContext(refs) {
+    async bulkSessionRefContext(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 };
+        for (const ref of refs)
+            cwdSet.add(ref.cwd);
+        return { sessionsByCwd: await this.listSessionsByCwd([...cwdSet]) };
     }
     async listSessionsByCwd(cwds) {
         const uniqueCwds = uniqueStrings(cwds);
@@ -1843,36 +1932,8 @@ export class PiSessionService {
             await this.archiveStore.deleteArchived(sessionId);
         return [...sessionIds];
     }
-    async moveLegacyArchivedRecordsForDelete(records) {
-        const legacyRecords = records.filter((record) => record.archivePath === undefined);
-        if (legacyRecords.length === 0)
-            return [];
-        let sessionsByCwd;
-        try {
-            sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
-        }
-        catch (error) {
-            return legacyRecords.map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
-        }
-        const moveInputs = legacyRecords
-            .map((record) => findSessionByIdOrPrefix(sessionsByCwd.get(record.cwd) ?? [], record.sessionId))
-            .filter(isDefined)
-            .map(archiveInputFromListEntry);
-        if (moveInputs.length === 0)
-            return [];
-        try {
-            await this.archiveStoreArchiveMany(moveInputs);
-            return [];
-        }
-        catch (error) {
-            const failedIds = new Set(moveInputs.map((input) => input.sessionId));
-            return legacyRecords
-                .filter((record) => failedIds.has(record.sessionId))
-                .map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
-        }
-    }
     async cleanupPlan(request) {
-        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.listAll?.() ?? [], this.archiveStore.list()]);
+        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.listAll(), this.archiveStore.list()]);
         return planSessionCleanup({
             sessions,
             archivedRecords,
@@ -1901,34 +1962,6 @@ export class PiSessionService {
         }
         return [...sessionIds];
     }
-    async ensureArchivedSessionMoved(record, session) {
-        if (session === undefined || this.active.has(record.sessionId))
-            return record;
-        try {
-            return await this.archiveStore.archive(archiveInputFromListEntry(session));
-        }
-        catch {
-            return record;
-        }
-    }
-    async ensureArchivedRecordMoved(record) {
-        const session = (await this.sessionManager.list(record.cwd)).find((candidate) => candidate.id === record.sessionId);
-        if (session === undefined)
-            return record;
-        const [moved] = await this.archiveStoreArchiveMany([archiveInputFromListEntry(session)]);
-        return moved ?? record;
-    }
-    async ensureArchivedRecordsMoved(records) {
-        const legacyRecords = records.filter((record) => record.archivePath === undefined);
-        if (legacyRecords.length === 0)
-            return;
-        const sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
-        const moveInputs = legacyRecords
-            .map((record) => sessionsByCwd.get(record.cwd)?.find((candidate) => candidate.id === record.sessionId))
-            .filter(isDefined)
-            .map(archiveInputFromListEntry);
-        await this.archiveStoreArchiveMany(moveInputs);
-    }
     async archiveInputForSession(session) {
         const cwd = session.sessionManager.getCwd();
         const sessionFile = session.sessionFile;
@@ -2065,7 +2098,7 @@ export class PiSessionService {
         return (await this.getActive(ref)).runtime.session;
     }
     async getActive(ref, options = {}) {
-        const active = this.activeForLookup(ref);
+        const active = this.activeForRef(ref);
         if (active !== undefined)
             return active;
         const archived = await this.getArchived(ref);
@@ -2073,15 +2106,17 @@ export class PiSessionService {
             const { archivePath } = archived;
             return this.openExistingSession(archived.sessionId, archived.cwd, () => 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));
+        // Resolve the session file directly by id: opening one known session must
+        // not depend on — or wait behind — a full transcript listing of its whole
+        // workspace. `getActive` routes prompt/shell/runCommand, so coupling it to
+        // the listing would let an in-flight listing serialize unrelated sends.
+        const match = await this.sessionManager.resolveSessionFile(ref.cwd, ref.id);
         if (!match)
             throw new Error("Session not found");
         return this.openExistingSession(match.id, match.cwd, () => this.sessionManager.open(match.path), options);
     }
     openExistingSession(sessionId, cwd, openSessionManager, options = {}) {
-        const active = this.activeForLookup({ id: sessionId, cwd });
+        const active = this.activeForRef({ id: sessionId, cwd });
         if (active !== undefined)
             return Promise.resolve(active);
         const key = JSON.stringify([canonicalizeStoredCwd(cwd), sessionId]);
@@ -2105,34 +2140,45 @@ export class PiSessionService {
             .map((pending) => pending.promise);
     }
     async getArchived(ref) {
-        const archived = await this.archiveStore.get(sessionIdFromLookup(ref));
+        const archived = await this.archiveStore.get(ref.id);
         if (archived === undefined)
             return undefined;
-        if (isPiSessionRef(ref) && archived.cwd !== ref.cwd)
+        if (archived.cwd !== ref.cwd)
             return undefined;
         return archived;
     }
     isCurrentActiveSession(session) {
         return this.active.get(session.sessionId)?.runtime.session === session;
     }
-    activeForLookup(ref) {
-        const sessionId = sessionIdFromLookup(ref);
+    /**
+     * The command service tracks sessions by id alone; its callbacks only ever
+     * run against a session the caller just resolved as active, so the cwd
+     * needed for a full ref comes from that active runtime.
+     */
+    activeSessionRef(sessionId) {
+        const active = this.active.get(sessionId);
+        if (active === undefined)
+            throw new Error("Session not found");
+        return { id: sessionId, cwd: active.runtime.cwd };
+    }
+    activeForRef(ref) {
+        const sessionId = ref.id;
         const exact = this.active.get(sessionId);
-        if (exact !== undefined && lookupMatchesActiveSession(ref, exact))
+        if (exact !== undefined && refMatchesActiveSession(ref, exact))
             return exact;
         for (const [candidateId, active] of this.active.entries()) {
-            if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active))
+            if (candidateId.startsWith(sessionId) && refMatchesActiveSession(ref, active))
                 return active;
         }
         return undefined;
     }
-    startupSessionForLookup(ref) {
-        const sessionId = sessionIdFromLookup(ref);
+    startupSessionForRef(ref) {
+        const sessionId = ref.id;
         const exact = this.startupSessions.get(sessionId);
-        if (exact !== undefined && lookupMatchesStartupSession(ref, exact))
+        if (exact !== undefined && refMatchesStartupSession(ref, exact))
             return exact;
         for (const [candidateId, session] of this.startupSessions.entries()) {
-            if (candidateId.startsWith(sessionId) && lookupMatchesStartupSession(ref, session))
+            if (candidateId.startsWith(sessionId) && refMatchesStartupSession(ref, session))
                 return session;
         }
         return undefined;
@@ -2144,7 +2190,7 @@ export class PiSessionService {
      * its status projection).
      */
     async sessionForStatusOrDialogClose(ref) {
-        const reachable = this.activeForLookup(ref)?.runtime.session ?? this.startupSessionForLookup(ref);
+        const reachable = this.activeForRef(ref)?.runtime.session ?? this.startupSessionForRef(ref);
         if (reachable !== undefined)
             return reachable;
         return this.getOrOpen(ref);
@@ -2175,6 +2221,7 @@ export class PiSessionService {
             sessionManager,
             delegationToolsEnabled,
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
         });
         const active = { runtime, unsubscribe: noop };
         let boundSession = runtime.session;
@@ -2322,14 +2369,6 @@ export class PiSessionService {
             }
             const added = this.notificationStore.addNotification(generation, message, type);
             this.publishNotificationMutations(added.mutations);
-            if (added.notification === undefined)
-                return;
-            this.events.publish(session.sessionId, {
-                type: "command.output",
-                level: type === "error" ? "error" : "info",
-                message,
-                notificationId: added.notification.id,
-            });
         };
         // PI WEB owns the browser-facing dialog, notification, and text-formatting
         // boundaries: the three dialog primitives park daemon-held Promises that
@@ -2387,6 +2426,11 @@ export class PiSessionService {
         void this.publishUnreadMutations(mutations).catch(() => undefined);
     }
     publishUnreadMutations(mutations) {
+        // The store applied the mutations already, so the status projection is told
+        // now rather than after the durable flush: it reads in-memory unread state
+        // and must not lag behind the rows the browser is about to see.
+        if (mutations.length > 0)
+            this.onUnreadChanged?.();
         this.enqueueUnreadMutations(mutations);
         this.unreadPublicationFlushRequested = true;
         if (this.unreadPublication === undefined && this.unreadPublicationRetryTimer !== undefined) {
@@ -2476,7 +2520,7 @@ export class PiSessionService {
             }
         }
         active.unsubscribe = session.subscribe((event) => {
-            this.events.publish(session.sessionId, toClientEvent(event));
+            this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel));
             this.publishActivityForEvent(session, event);
             const eventType = getString(event, "type");
             if (eventType === "agent_end")
@@ -2957,7 +3001,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);
@@ -2965,16 +3009,14 @@ function uniqueBulkSessionRefs(refs) {
     }
     return unique;
 }
-function bulkRefToLookup(ref) {
-    return ref.cwd === undefined ? ref.id : { id: ref.id, cwd: ref.cwd };
+function bulkRefToSessionRef(ref) {
+    return { id: ref.id, cwd: ref.cwd };
 }
 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));
@@ -3357,13 +3399,34 @@ function buildPromptOptions(behavior, images) {
 function stringValue(value) {
     return typeof value === "string" ? value : "";
 }
+/**
+ * Attach the thinking level in effect when an assistant message was generated,
+ * so chat bubbles can show it next to the model. Non-assistant messages pass
+ * through by reference; assistant messages are copied only when a level is set.
+ * "off" is the absence of thinking, not a level worth labeling on every bubble.
+ */
+function annotateAssistantThinkingLevel(message, thinkingLevel) {
+    if (thinkingLevel === undefined || thinkingLevel === "" || thinkingLevel === "off")
+        return message;
+    if (!isRecord(message) || message["role"] !== "assistant")
+        return message;
+    return { ...message, thinkingLevel };
+}
 function historyMessages(session) {
     const messages = [];
+    // Pi records the initial level at session creation and every later change, so
+    // walking the branch yields the level in effect for each assistant message.
+    let thinkingLevel;
     for (const entry of session.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")
@@ -3408,7 +3471,7 @@ function finalAssistantText(messages) {
     }
     return "";
 }
-function toClientEvent(event) {
+function toClientEvent(event, thinkingLevel) {
     const eventType = getString(event, "type");
     const assistantMessageEvent = getProperty(event, "assistantMessageEvent");
     if (eventType === "message_update" && getString(assistantMessageEvent, "type") === "text_delta") {
@@ -3435,7 +3498,9 @@ function toClientEvent(event) {
         return { type: "agent.end" };
     if (eventType === "message_end") {
         const message = getProperty(event, "message");
-        return message === undefined ? { type: "message.end" } : { type: "message.end", message };
+        if (message === undefined)
+            return { type: "message.end" };
+        return { type: "message.end", message: annotateAssistantThinkingLevel(message, thinkingLevel) };
     }
     return { type: "pi.event", eventType: eventType ?? "unknown" };
 }