@hyperdreamer/pi-webui 1.11.0-beta.6 → 1.11.0-beta.8

package/dist/server/sessions/piSessionService.js

@@ -7,28 +7,34 @@ import { projectBrowserMessage } from "../browserMessageProjection.js";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
 import { exportSessionHistoryHtml } from "./sessionHistoryExport.js";
 import { BUILTIN_COMMANDS } from "./builtinCommands.js";
-import { SessionCommandService, clientSessionFromRuntime } from "./sessionCommandService.js";
-import { projectSessionTree } from "./sessionTreeProjection.js";
-import { SessionArchiveStore } from "./sessionArchiveStore.js";
+import { SessionCommandService, clientSessionFromRuntime, } from "./sessionCommandService.js";
+import { projectSessionTree, } from "./sessionTreeProjection.js";
+import { SessionArchiveStore, } from "./sessionArchiveStore.js";
 import { SessionMetadataStore } from "./sessionMetadataStore.js";
-import { findArchiveCandidateByIdOrPrefix, planSessionArchiveTree } from "./sessionArchiveTree.js";
-import { deterministicSessionName, fallbackSessionName, generateShortSessionName } from "./sessionNameGenerator.js";
+import { findArchiveCandidateByIdOrPrefix, planSessionArchiveTree, } from "./sessionArchiveTree.js";
+import { deterministicSessionName, fallbackSessionName, generateShortSessionName, } from "./sessionNameGenerator.js";
 import { computeEditPreview } from "./editPreview.js";
-import { attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachmentService.js";
+import { attachmentsToInlineImages, saveAttachmentsToWorkspace, } from "./attachmentService.js";
 import { parsePromptAttachments } from "../../shared/promptAttachments.js";
 import { isKnownThinkingLevel } from "../../shared/thinkingLevels.js";
-import { SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH, SESSION_UNREAD_LIMIT } from "../../shared/apiTypes.js";
+import { SESSION_TREE_CUSTOM_INSTRUCTIONS_MAX_LENGTH, SESSION_UNREAD_LIMIT, } from "../../shared/apiTypes.js";
 import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
-import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
-import { createSubsessionToolDefinitions } from "./spawnSubsessionTool.js";
+import { createSpawnSessionToolDefinition, } from "./spawnSessionTool.js";
+import { createSubsessionToolDefinitions, } from "./spawnSubsessionTool.js";
+import { createModelPolicyToolDefinition, } from "./modelPolicyTool.js";
+import { buildModelPolicyCapability, } from "./modelPolicyCapability.js";
 import { buildTranscriptView } from "./subsessionTranscript.js";
-import { planForceCleanup, planSessionCleanup, summarizeForceCleanupExecution, summarizeSessionCleanupExecution } from "./sessionCleanup.js";
+import { planForceCleanup, planSessionCleanup, summarizeForceCleanupExecution, summarizeSessionCleanupExecution, } from "./sessionCleanup.js";
 import { SessionNotificationStore, } from "./sessionNotificationStore.js";
 import { plainTextTheme } from "./plainTextTheme.js";
-import { SessionUnreadStore } from "./sessionUnreadStore.js";
-import { createModelTierRegistry, isModelTier, runtimeThinkingLevels } from "./modelTierRegistry.js";
+import { SessionUnreadStore, } from "./sessionUnreadStore.js";
+import { createModelTierRegistry, isModelTier, runtimeThinkingLevels, } from "./modelTierRegistry.js";
 import { inspectSessionModelPolicy, planSessionModelPolicyUpdate, serializeSessionModelPolicy, SESSION_MODEL_POLICY_CUSTOM_TYPE, } from "./sessionModelPolicy.js";
-const noopLogger = { info() { } };
+const noopLogger = {
+    info() {
+        /* no-op */
+    },
+};
 const DEFAULT_UNREAD_PUBLICATION_RETRY_MS = 1_000;
 const MAX_UNREAD_PUBLICATION_RETRY_MS = 30_000;
 const MAX_PENDING_UNREAD_MUTATIONS = SESSION_UNREAD_LIMIT + 1;
@@ -90,13 +96,13 @@ function requirePromptText(value) {
         throw new Error("Prompt text is required");
     return value;
 }
-function leadingTierDirective(prompt) {
-    const match = /^(?:\uFEFF)?\/tier-([^\s\r\n]+)(?:[ \t]*(?:\r?\n|$))/u.exec(prompt);
+function leadingTierEcho(prompt) {
+    const match = /^(?:\uFEFF)?Model tier: ([^\s\r\n]+)(?:[ \t]*(?:\r?\n|$))/u.exec(prompt);
     if (match === null)
         return undefined;
     const value = match[1];
     if (value === undefined || !isModelTier(value))
-        throw new Error(`Unknown leading tier directive: /tier-${value ?? ""}`);
+        throw new Error(`Unknown leading model tier label: ${value ?? ""}`);
     return value;
 }
 function parsePromptStreamingBehavior(value) {
@@ -106,7 +112,10 @@ function parsePromptStreamingBehavior(value) {
         return value;
     throw new Error('Prompt streamingBehavior must be "steer" or "followUp"');
 }
-const CLEAR_RUNTIME_NOTIFICATIONS = { kind: "clear", reason: "runtime-close" };
+const CLEAR_RUNTIME_NOTIFICATIONS = {
+    kind: "clear",
+    reason: "runtime-close",
+};
 const DEFER_RUNTIME_NOTIFICATIONS = { kind: "defer" };
 function resourceDiagnosticToWarning(diagnostic, source) {
     return {
@@ -117,7 +126,11 @@ function resourceDiagnosticToWarning(diagnostic, source) {
     };
 }
 function runtimeDiagnosticToWarning(diagnostic) {
-    return { severity: diagnostic.type, message: diagnostic.message, source: "runtime" };
+    return {
+        severity: diagnostic.type,
+        message: diagnostic.message,
+        source: "runtime",
+    };
 }
 /**
  * Compute the live warnings for a runtime by re-reading its current resource
@@ -141,7 +154,12 @@ export function collectRuntimeWarnings(runtime) {
         for (const diagnostic of resourceLoader.getThemes().diagnostics)
             warnings.push(resourceDiagnosticToWarning(diagnostic, "theme"));
         for (const error of resourceLoader.getExtensions().errors) {
-            warnings.push({ severity: "error", message: `${error.path}: ${error.error}`, source: "extension", path: error.path });
+            warnings.push({
+                severity: "error",
+                message: `${error.path}: ${error.error}`,
+                source: "extension",
+                path: error.path,
+            });
         }
     }
     return warnings;
@@ -207,7 +225,10 @@ export function dismissSessionWarning(session, dismissId) {
     if (dismissId !== ANTHROPIC_EXTRA_USAGE_DISMISS_ID) {
         throw new Error(`Unknown session warning dismiss id: ${dismissId}`);
     }
-    session.settingsManager.setWarnings({ ...session.settingsManager.getWarnings(), anthropicExtraUsage: false });
+    session.settingsManager.setWarnings({
+        ...session.settingsManager.getWarnings(),
+        anthropicExtraUsage: false,
+    });
 }
 function defaultCreateAgentRuntime(createRuntime, options) {
     if (!(options.sessionManager instanceof SessionManager))
@@ -235,31 +256,53 @@ function createRuntimeWithOneShotSessionOptions(createRuntime, initialModel, ini
         return createRuntime({
             ...options,
             ...(model === undefined ? {} : { initialModel: model }),
-            ...(thinkingLevel === undefined ? {} : { initialThinkingLevel: thinkingLevel }),
-            ...(toolsEnabled === undefined ? {} : { delegationToolsEnabled: toolsEnabled }),
+            ...(thinkingLevel === undefined
+                ? {}
+                : { initialThinkingLevel: thinkingLevel }),
+            ...(toolsEnabled === undefined
+                ? {}
+                : { delegationToolsEnabled: toolsEnabled }),
         });
     };
 }
-export function createPiWebUiCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions) {
+export function createPiWebUiCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions, modelPolicy) {
     return [
         createPiWebUiEditToolDefinition(cwd),
-        ...(delegationEnabled && spawn !== undefined ? [createSpawnSessionToolDefinition(cwd, { spawn })] : []),
-        ...(delegationEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions) : []),
+        ...(delegationEnabled && spawn !== undefined
+            ? [createSpawnSessionToolDefinition(cwd, { spawn })]
+            : []),
+        ...(delegationEnabled && subsessions !== undefined
+            ? createSubsessionToolDefinitions(cwd, subsessions)
+            : []),
+        // Paired with the subsession tools: the policy view exists so a dispatching
+        // agent can verify tier dispatch before using it, so it is pointless without
+        // the dispatch capability and misleading if advertised separately.
+        ...(delegationEnabled &&
+            subsessions !== undefined &&
+            modelPolicy !== undefined
+            ? [createModelPolicyToolDefinition(modelPolicy)]
+            : []),
     ];
 }
-function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subsessions) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled }) => {
-        const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime });
-        const resolvedDelegationToolsEnabled = delegationToolsEnabled
-            ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
-        const customTools = createPiWebUiCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions);
+function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subsessions, modelPolicy) {
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled, }) => {
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            modelRuntime,
+        });
+        const resolvedDelegationToolsEnabled = delegationToolsEnabled ??
+            (await sessionAllowsDelegationTools(sessionManager, sessionManagers));
+        const customTools = createPiWebUiCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions, modelPolicy);
         const result = await createAgentSessionFromServices({
             services,
             sessionManager,
             customTools,
             ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
             ...(initialModel === undefined ? {} : { model: initialModel }),
-            ...(initialThinkingLevel === undefined ? {} : { thinkingLevel: initialThinkingLevel }),
+            ...(initialThinkingLevel === undefined
+                ? {}
+                : { thinkingLevel: initialThinkingLevel }),
         });
         return { ...result, services, diagnostics: services.diagnostics };
     };
@@ -270,16 +313,29 @@ function createPiWebUiEditToolDefinition(cwd) {
         name: editTool.name,
         label: editTool.label,
         description: editTool.description,
-        ...(editTool.promptSnippet === undefined ? {} : { promptSnippet: editTool.promptSnippet }),
-        ...(editTool.promptGuidelines === undefined ? {} : { promptGuidelines: editTool.promptGuidelines }),
+        ...(editTool.promptSnippet === undefined
+            ? {}
+            : { promptSnippet: editTool.promptSnippet }),
+        ...(editTool.promptGuidelines === undefined
+            ? {}
+            : { promptGuidelines: editTool.promptGuidelines }),
         parameters: editTool.parameters,
-        ...(editTool.renderShell === undefined ? {} : { renderShell: editTool.renderShell }),
-        ...(editTool.prepareArguments === undefined ? {} : { prepareArguments: editTool.prepareArguments }),
-        ...(editTool.executionMode === undefined ? {} : { executionMode: editTool.executionMode }),
+        ...(editTool.renderShell === undefined
+            ? {}
+            : { renderShell: editTool.renderShell }),
+        ...(editTool.prepareArguments === undefined
+            ? {}
+            : { prepareArguments: editTool.prepareArguments }),
+        ...(editTool.executionMode === undefined
+            ? {}
+            : { executionMode: editTool.executionMode }),
         async execute(toolCallId, params, signal, onUpdate, ctx) {
             const preview = await computeEditPreview(params.path, params.edits, cwd);
             if (signal?.aborted !== true) {
-                onUpdate?.({ content: [{ type: "text", text: "Edit preview computed." }], details: { preview } });
+                onUpdate?.({
+                    content: [{ type: "text", text: "Edit preview computed." }],
+                    details: { preview },
+                });
             }
             return editTool.execute(toolCallId, params, signal, onUpdate, ctx);
         },
@@ -367,34 +423,56 @@ export class PiSessionService {
         this.spawnTargets = deps.spawnTargets;
         this.logger = deps.logger ?? noopLogger;
         this.now = deps.now ?? (() => new Date());
-        this.notificationStore = deps.notificationStore ?? new SessionNotificationStore();
+        this.notificationStore =
+            deps.notificationStore ?? new SessionNotificationStore();
         this.unreadStore = deps.unreadStore ?? new SessionUnreadStore();
         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
         // 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 : {
-            spawn: (input) => this.spawnSubsession(input),
-            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),
-        });
-        this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
-        this.modelTierRegistry = deps.modelTierRegistry ?? createModelTierRegistry({
-            loadConfig: () => {
-                const loaded = loadPiWebUiConfig();
-                return {
-                    ...(loaded.config.modelTiers === undefined ? {} : { modelTiers: loaded.config.modelTiers }),
-                    ...(loaded.modelTiersError === undefined ? {} : { modelTiersError: loaded.modelTiersError }),
-                };
-            },
-            models: () => this.modelRuntime.getAvailableSnapshot(),
-            supportedThinkingLevels: runtimeThinkingLevels,
-        });
+        this.createRuntime =
+            deps.createRuntime ??
+                createDefaultRuntimeFactory(this.modelRuntime, this.sessionManager, this.spawnTargets === undefined
+                    ? undefined
+                    : (input) => this.spawnSession(input), !subsessionsActive
+                    ? undefined
+                    : {
+                        spawn: (input) => this.spawnSubsession(input),
+                        list: (parentSessionId, parentSessionFile) => this.listSubsessions(parentSessionId, parentSessionFile),
+                        check: (parentSessionId, sessionId, parentSessionFile) => this.checkSubsession(parentSessionId, sessionId, parentSessionFile),
+                        read: (parentSessionId, sessionId, query, parentSessionFile) => this.readSubsession(parentSessionId, sessionId, query, parentSessionFile),
+                    }, !subsessionsActive
+                    ? undefined
+                    : {
+                        inspect: (sessionId) => this.modelPolicyCapability(sessionId),
+                    });
+        this.createAgentRuntime =
+            deps.createAgentRuntime ?? defaultCreateAgentRuntime;
+        this.modelTierRegistry =
+            deps.modelTierRegistry ??
+                createModelTierRegistry({
+                    loadConfig: () => {
+                        const loaded = loadPiWebUiConfig();
+                        return {
+                            ...(loaded.config.modelTiers === undefined
+                                ? {}
+                                : { modelTiers: loaded.config.modelTiers }),
+                            ...(loaded.modelTiersError === undefined
+                                ? {}
+                                : { modelTiersError: loaded.modelTiersError }),
+                        };
+                    },
+                    models: () => this.modelRuntime.getAvailableSnapshot(),
+                    supportedThinkingLevels: runtimeThinkingLevels,
+                });
         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.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, {
             onCompactionStart: (session) => {
                 this.beginSessionEntryMutation(session, "compact the session");
                 this.publishActivity(session, "compacting", "active");
@@ -407,7 +485,8 @@ export class PiSessionService {
             },
             reloadSession: (session) => this.reloadSessionRuntime(session),
             getSessionTree: (session) => {
-                if (typeof session.sessionManager.getTree !== "function" || typeof session.navigateTree !== "function")
+                if (typeof session.sessionManager.getTree !== "function" ||
+                    typeof session.navigateTree !== "function")
                     return undefined;
                 return projectSessionTree(session.sessionManager.getTree(), session.sessionManager.getLeafId());
             },
@@ -452,7 +531,9 @@ export class PiSessionService {
     }
     async cleanup(request) {
         const plan = await this.cleanupPlan(request);
-        if (plan.deleteRecords.length > 0 && this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
+        if (plan.deleteRecords.length > 0 &&
+            this.archiveStore.deleteArchived === undefined &&
+            this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
         const archiveInputs = [];
         const readyArchiveInputs = [];
@@ -464,7 +545,10 @@ export class PiSessionService {
                 skippedBusySessionIds.add(input.sessionId);
                 continue;
             }
-            await this.closeActive(input.sessionId, { kind: "clear", reason: "archive" });
+            await this.closeActive(input.sessionId, {
+                kind: "clear",
+                reason: "archive",
+            });
             readyArchiveInputs.push(input);
         }
         await this.archiveStoreArchiveMany(readyArchiveInputs);
@@ -475,7 +559,10 @@ export class PiSessionService {
                 skippedBusySessionIds.add(record.sessionId);
                 continue;
             }
-            await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
+            await this.closeActive(record.sessionId, {
+                kind: "clear",
+                reason: "delete",
+            });
             readyDeleteRecords.push(record);
         }
         await this.ensureArchivedRecordsMoved(readyDeleteRecords);
@@ -491,7 +578,8 @@ export class PiSessionService {
         });
     }
     async forceCleanup() {
-        if (this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
+        if (this.archiveStore.deleteArchived === undefined &&
+            this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
         const archivedRecords = await this.archiveStore.list();
         const plan = planForceCleanup({
@@ -506,7 +594,10 @@ export class PiSessionService {
                 skippedBusySessionIds.add(record.sessionId);
                 continue;
             }
-            await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
+            await this.closeActive(record.sessionId, {
+                kind: "clear",
+                reason: "delete",
+            });
             readyDeleteRecords.push(record);
         }
         await this.ensureArchivedRecordsMoved(readyDeleteRecords);
@@ -587,14 +678,26 @@ export class PiSessionService {
     }
     async start(cwd, options) {
         const modelPolicy = options?.modelPolicy;
-        return this.startSession(cwd, { initializeModelPolicy: modelPolicy ?? true });
+        return this.startSession(cwd, {
+            initializeModelPolicy: modelPolicy ?? true,
+        });
     }
     async startSession(cwd, options) {
-        const active = await this.create(this.sessionManager.create(cwd, options.parentSession === undefined ? undefined : { parentSession: options.parentSession }), cwd, {
-            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
-            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
-            ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
-            ...(options.initializeModelPolicy === undefined ? {} : { initializeModelPolicy: options.initializeModelPolicy }),
+        const active = await this.create(this.sessionManager.create(cwd, options.parentSession === undefined
+            ? undefined
+            : { parentSession: options.parentSession }), cwd, {
+            ...(options.initialModel === undefined
+                ? {}
+                : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined
+                ? {}
+                : { initialThinkingLevel: options.initialThinkingLevel }),
+            ...(options.creationProvenance === undefined
+                ? {}
+                : { creationProvenance: options.creationProvenance }),
+            ...(options.initializeModelPolicy === undefined
+                ? {}
+                : { initializeModelPolicy: options.initializeModelPolicy }),
         });
         const { session } = active.runtime;
         const created = {
@@ -608,7 +711,9 @@ export class PiSessionService {
             firstMessage: "",
             // Include the parent so listeners can nest the new session in the tree
             // immediately, instead of showing it flat until the next reload.
-            ...(options.parentSession === undefined ? {} : { parentSessionPath: options.parentSession }),
+            ...(options.parentSession === undefined
+                ? {}
+                : { parentSessionPath: options.parentSession }),
         };
         // Broadcast so other clients (and the spawning agent's UI) can add the new
         // session to their list without a manual reload.
@@ -628,7 +733,12 @@ export class PiSessionService {
             throw spawnTargetError(decision);
         const created = await this.startSession(decision.cwd, input.model === undefined ? {} : { initialModel: input.model });
         await this.prompt(created.id, input.prompt);
-        this.logger.info({ spawningCwd: input.spawningCwd, sessionId: created.id, cwd: decision.cwd, promptLength: input.prompt.length }, "spawn_session started a new session");
+        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 };
     }
     /**
@@ -646,9 +756,9 @@ export class PiSessionService {
         let initialModel = input.model;
         let initialThinkingLevel;
         if (input.tier !== undefined) {
-            const echoedTier = leadingTierDirective(input.prompt);
+            const echoedTier = leadingTierEcho(input.prompt);
             if (echoedTier !== undefined && echoedTier !== input.tier) {
-                throw new Error(`Leading tier directive /tier-${echoedTier} disagrees with typed tier ${input.tier}`);
+                throw new Error(`Leading Model tier: ${echoedTier} label disagrees with typed tier ${input.tier}`);
             }
             const resolved = this.modelTierRegistry.resolve(input.tier);
             if (!isKnownThinkingLevel(resolved.thinkingLevel)) {
@@ -658,7 +768,9 @@ export class PiSessionService {
             initialThinkingLevel = resolved.thinkingLevel;
         }
         const created = await this.startSession(decision.cwd, {
-            ...(input.parentSessionFile === undefined ? {} : { parentSession: input.parentSessionFile }),
+            ...(input.parentSessionFile === undefined
+                ? {}
+                : { parentSession: input.parentSessionFile }),
             ...(initialModel === undefined ? {} : { initialModel }),
             ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
             creationProvenance: "tracked-subsession",
@@ -675,7 +787,12 @@ export class PiSessionService {
         this.persistSubsessionLink(link);
         this.persistSubsessionChildMarker(input.parentSessionId, created.id);
         await this.prompt(created.id, 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");
+        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 };
     }
     /** Summaries of the tracked subsessions spawned by `parentSessionId`. */
@@ -686,7 +803,10 @@ export class PiSessionService {
         if (childIds === undefined)
             return [];
         const authorizedChildIds = [...childIds].filter((childId) => this.subsessionLinkBelongsToParent(parentSessionId, parentFile, childId));
-        return Promise.all(authorizedChildIds.map(async (childId) => ({ sessionId: childId, ...(await this.subsessionSummaryFields(childId)) })));
+        return Promise.all(authorizedChildIds.map(async (childId) => ({
+            sessionId: childId,
+            ...(await this.subsessionSummaryFields(childId)),
+        })));
     }
     /** Status and final result of a subsession, scoped to the caller's children. */
     async checkSubsession(parentSessionId, sessionId, parentSessionFile) {
@@ -715,7 +835,8 @@ export class PiSessionService {
     async openSubsession(parentSessionId, sessionId, parentSessionFile) {
         const parentFile = nonEmptyString(parentSessionFile);
         await this.hydrateSubsessionsForParent(parentSessionId, parentFile);
-        if (this.subsessionParents.get(sessionId) !== parentSessionId || !this.subsessionLinkBelongsToParent(parentSessionId, parentFile, sessionId)) {
+        if (this.subsessionParents.get(sessionId) !== parentSessionId ||
+            !this.subsessionLinkBelongsToParent(parentSessionId, parentFile, sessionId)) {
             throw new Error(`Session ${sessionId} is not one of your subsessions`);
         }
         return this.getOrOpenTrackedSubsession(sessionId);
@@ -724,19 +845,24 @@ export class PiSessionService {
         const link = this.subsessionLinks.get(childSessionId);
         if (link?.parentSessionId !== parentSessionId)
             return false;
-        return parentSessionFile === undefined || trackedLinkParentFileMatches(link, parentSessionFile);
+        return (parentSessionFile === undefined ||
+            trackedLinkParentFileMatches(link, parentSessionFile));
     }
     activeChildForSubsessionLink(link) {
         const active = this.active.get(link.childSessionId);
         if (active === undefined)
             return undefined;
-        return activeSessionFileMatches(active, link.childSessionFile) ? active : undefined;
+        return activeSessionFileMatches(active, link.childSessionFile)
+            ? active
+            : undefined;
     }
     activeParentForSubsessionLink(link) {
         const active = this.active.get(link.parentSessionId);
         if (active === undefined)
             return undefined;
-        return activeSessionFileMatches(active, link.parentSessionFile) ? active : undefined;
+        return activeSessionFileMatches(active, link.parentSessionFile)
+            ? active
+            : undefined;
     }
     subsessionLinkForActiveChild(session) {
         const childId = session.sessionId;
@@ -744,12 +870,15 @@ export class PiSessionService {
         const link = this.subsessionLinks.get(childId);
         if (parentId === undefined || link?.parentSessionId !== parentId)
             return undefined;
-        return sessionFileMatches(session, link.childSessionFile) ? link : undefined;
+        return sessionFileMatches(session, link.childSessionFile)
+            ? link
+            : undefined;
     }
     async registerVerifiedSubsession(link) {
         const { childSessionId, parentSessionId } = link;
         const previousParentId = this.subsessionParents.get(childSessionId);
-        if (previousParentId !== undefined && previousParentId !== parentSessionId) {
+        if (previousParentId !== undefined &&
+            previousParentId !== parentSessionId) {
             const previousChildren = this.subsessionChildren.get(previousParentId);
             previousChildren?.delete(childSessionId);
             if (previousChildren?.size === 0)
@@ -803,7 +932,11 @@ export class PiSessionService {
             parent.sessionManager.appendCustomEntry(SUBSESSION_LINK_CUSTOM_TYPE, persistedParentSubsessionLinkData(link));
         }
         catch (error) {
-            this.logger.info({ parentSessionId: link.parentSessionId, sessionId: link.childSessionId, error: error instanceof Error ? error.message : String(error) }, "failed to persist subsession link");
+            this.logger.info({
+                parentSessionId: link.parentSessionId,
+                sessionId: link.childSessionId,
+                error: error instanceof Error ? error.message : String(error),
+            }, "failed to persist subsession link");
         }
     }
     persistSubsessionChildMarker(parentSessionId, childSessionId) {
@@ -816,7 +949,11 @@ export class PiSessionService {
             child.sessionManager.appendCustomEntry(SUBSESSION_CHILD_LINK_CUSTOM_TYPE, persistedChildSubsessionLinkData(parentSessionId, childSessionId));
         }
         catch (error) {
-            this.logger.info({ parentSessionId, sessionId: childSessionId, error: error instanceof Error ? error.message : String(error) }, "failed to persist subsession child marker");
+            this.logger.info({
+                parentSessionId,
+                sessionId: childSessionId,
+                error: error instanceof Error ? error.message : String(error),
+            }, "failed to persist subsession child marker");
         }
     }
     async hydrateSubsessionsForParent(parentSessionId, parentSessionFile) {
@@ -824,7 +961,9 @@ export class PiSessionService {
         if (this.subsessionHydratedParents.has(hydrationKey))
             return;
         const activeParent = this.active.get(parentSessionId);
-        if (activeParent !== undefined && (parentSessionFile === undefined || activeSessionFileMatches(activeParent, parentSessionFile))) {
+        if (activeParent !== undefined &&
+            (parentSessionFile === undefined ||
+                activeSessionFileMatches(activeParent, parentSessionFile))) {
             const activeParentFile = nonEmptyString(activeParent.runtime.session.sessionFile);
             const complete = await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile);
             if (complete)
@@ -833,7 +972,8 @@ export class PiSessionService {
         }
         if (parentSessionFile === undefined)
             return;
-        if ((await readSessionHeaderSummary(parentSessionFile))?.id !== parentSessionId)
+        if ((await readSessionHeaderSummary(parentSessionFile))?.id !==
+            parentSessionId)
             return;
         let parentManager;
         try {
@@ -875,8 +1015,11 @@ export class PiSessionService {
         return trackedSubsessionLinkFromParentLink(parentSessionId, link, parentSessionFile);
     }
     async parentLinkHasValidChildTarget(parentSessionFile, link) {
-        return link.spawnedSessionFile !== undefined
-            && await sessionFileHeaderMatches(link.spawnedSessionFile, { sessionId: link.spawnedSessionId, parentSessionFile });
+        return (link.spawnedSessionFile !== undefined &&
+            (await sessionFileHeaderMatches(link.spawnedSessionFile, {
+                sessionId: link.spawnedSessionId,
+                parentSessionFile,
+            })));
     }
     async recoverSubsessionTrackingForOpenedSession(session) {
         const link = await this.verifiedSubsessionLinkFromOpenedChild(session);
@@ -900,7 +1043,10 @@ export class PiSessionService {
         if (active !== undefined)
             return active.runtime.session;
         if (link.childSessionFile !== undefined) {
-            if (!(await sessionFileHeaderMatches(link.childSessionFile, { sessionId, parentSessionFile: link.parentSessionFile })))
+            if (!(await sessionFileHeaderMatches(link.childSessionFile, {
+                sessionId,
+                parentSessionFile: link.parentSessionFile,
+            })))
                 throw new Error("Session not found");
             const sessionManager = this.sessionManager.open(link.childSessionFile);
             return (await this.create(sessionManager, link.cwd ?? sessionManager.getCwd())).runtime.session;
@@ -911,9 +1057,16 @@ export class PiSessionService {
         const link = this.subsessionLinks.get(childSessionId);
         const active = link === undefined ? undefined : this.activeChildForSubsessionLink(link);
         if (active !== undefined) {
-            return { cwd: active.runtime.cwd, status: this.subsessionStatus(active.runtime.session) };
+            return {
+                cwd: active.runtime.cwd,
+                status: this.subsessionStatus(active.runtime.session),
+            };
         }
-        if (link?.childSessionFile !== undefined && (await sessionFileHeaderMatches(link.childSessionFile, { sessionId: childSessionId, parentSessionFile: link.parentSessionFile }))) {
+        if (link?.childSessionFile !== undefined &&
+            (await sessionFileHeaderMatches(link.childSessionFile, {
+                sessionId: childSessionId,
+                parentSessionFile: link.parentSessionFile,
+            }))) {
             return { cwd: link.cwd ?? "", status: "idle" };
         }
         if (link?.cwd !== undefined)
@@ -933,7 +1086,9 @@ export class PiSessionService {
             return [];
         return [...childIds].filter((childId) => {
             const link = this.subsessionLinks.get(childId);
-            const active = link === undefined ? undefined : this.activeChildForSubsessionLink(link);
+            const active = link === undefined
+                ? undefined
+                : this.activeChildForSubsessionLink(link);
             return active !== undefined && this.hasActiveWork(active.runtime.session);
         });
     }
@@ -975,11 +1130,13 @@ export class PiSessionService {
         const parentSessionFile = link.parentSessionFile;
         if (parentSessionFile === undefined)
             throw new Error(`Parent session ${parentSessionId} is not available for subsession notification`);
-        if ((await readSessionHeaderSummary(parentSessionFile))?.id !== parentSessionId) {
+        if ((await readSessionHeaderSummary(parentSessionFile))?.id !==
+            parentSessionId) {
             throw new Error(`Parent session ${parentSessionId} is not available for subsession notification`);
         }
         const sessionManager = this.sessionManager.open(parentSessionFile);
-        return (await this.create(sessionManager, sessionManager.getCwd())).runtime.session;
+        return (await this.create(sessionManager, sessionManager.getCwd())).runtime
+            .session;
     }
     /**
      * Deliver a subsession-completion notice to the parent as a system-authored
@@ -997,18 +1154,31 @@ export class PiSessionService {
                 this.deferredSubsessionNotifications.set(session, pending);
                 return;
             }
-            await this.deliverSubsessionNotification(session, { parentId, childId, text });
+            await this.deliverSubsessionNotification(session, {
+                parentId,
+                childId,
+                text,
+            });
         }
         catch (error) {
             this.logSubsessionNotificationFailure(parentId, childId, error);
         }
     }
     async deliverSubsessionNotification(session, notification) {
-        await this.runSessionEntryMutation(session, "deliver a subsession notification", () => session.sendCustomMessage({ customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE, content: notification.text, display: true, details: { sessionId: notification.childId } }, { triggerTurn: true, deliverAs: "followUp" }));
+        await this.runSessionEntryMutation(session, "deliver a subsession notification", () => session.sendCustomMessage({
+            customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE,
+            content: notification.text,
+            display: true,
+            details: { sessionId: notification.childId },
+        }, { triggerTurn: true, deliverAs: "followUp" }));
         this.publishStatus(session);
     }
     logSubsessionNotificationFailure(parentId, childId, error) {
-        this.logger.info({ parentSessionId: parentId, sessionId: childId, error: error instanceof Error ? error.message : String(error) }, "failed to notify parent of subsession completion");
+        this.logger.info({
+            parentSessionId: parentId,
+            sessionId: childId,
+            error: error instanceof Error ? error.message : String(error),
+        }, "failed to notify parent of subsession completion");
     }
     async exportHistory(ref) {
         return exportSessionHistoryHtml(await this.sessionFileForHistory(ref));
@@ -1048,7 +1218,9 @@ export class PiSessionService {
         const current = inspection.kind === "invalid" ? inspection.fallback : inspection.policy;
         const policy = await this.applySessionModelPolicy(session, current, update, {
             action,
-            onTransitionFailure: (reason) => { this.publishModelPolicyTransitionFailure(session, reason); },
+            onTransitionFailure: (reason) => {
+                this.publishModelPolicyTransitionFailure(session, reason);
+            },
         });
         const resolved = this.exactSelectionFromSession(session);
         this.publishActivity(session, `model policy: ${policy.mode}`, "idle", policy.mode === "tiered" ? policy.tier : resolved.model.id);
@@ -1095,8 +1267,7 @@ export class PiSessionService {
         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);
+        const model = candidates.find((candidate) => candidate.provider === provider && candidate.id === modelId) ?? session.modelRuntime.getModel(provider, modelId);
         if (model === undefined)
             throw new Error(`Model not found: ${provider}/${modelId}`);
         await this.runExactModelPolicyMutation(session, "change models", currentPolicy, () => session.setModel(model));
@@ -1111,7 +1282,9 @@ export class PiSessionService {
         const result = await this.runExactModelPolicyMutation(session, "change models", currentPolicy, async () => {
             const cycled = await session.cycleModel(direction);
             if (cycled === undefined) {
-                throw new Error(session.scopedModels.length > 0 ? "Only one model in scope" : "Only one model available");
+                throw new Error(session.scopedModels.length > 0
+                    ? "Only one model in scope"
+                    : "Only one model available");
             }
             return cycled;
         });
@@ -1159,13 +1332,31 @@ export class PiSessionService {
         const session = await this.getOrOpen(ref);
         const commands = [...BUILTIN_COMMANDS];
         for (const command of session.extensionRunner.getRegisteredCommands()) {
-            commands.push({ name: command.invocationName, ...(command.description === undefined ? {} : { description: command.description }), source: "extension" });
+            commands.push({
+                name: command.invocationName,
+                ...(command.description === undefined
+                    ? {}
+                    : { description: command.description }),
+                source: "extension",
+            });
         }
         for (const template of session.promptTemplates) {
-            commands.push({ name: template.name, ...(template.description === undefined ? {} : { description: template.description }), source: "prompt" });
+            commands.push({
+                name: template.name,
+                ...(template.description === undefined
+                    ? {}
+                    : { description: template.description }),
+                source: "prompt",
+            });
         }
         for (const skill of session.resourceLoader.getSkills().skills) {
-            commands.push({ name: `skill:${skill.name}`, ...(skill.description === undefined ? {} : { description: skill.description }), source: "skill" });
+            commands.push({
+                name: `skill:${skill.name}`,
+                ...(skill.description === undefined
+                    ? {}
+                    : { description: skill.description }),
+                source: "skill",
+            });
         }
         return commands.sort((a, b) => a.name.localeCompare(b.name));
     }
@@ -1177,7 +1368,9 @@ export class PiSessionService {
         // as a transient line that vanishes on reload.
         const echoUserMessage = options?.echoUserMessage !== false;
         const requestedBehavior = parsePromptStreamingBehavior(streamingBehavior);
-        const parsedAttachments = parsePromptAttachments(attachments, { enforceInlineSizeLimit: false });
+        const parsedAttachments = parsePromptAttachments(attachments, {
+            enforceInlineSizeLimit: false,
+        });
         const images = (await attachmentsToInlineImages(parsedAttachments)).map((entry) => entry.image);
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref);
@@ -1186,7 +1379,9 @@ export class PiSessionService {
         this.maybeGenerateSessionName(session, promptText);
         const isQueued = session.isStreaming || session.isCompacting;
         const behavior = isQueued ? requestedBehavior ?? "followUp" : undefined;
-        if (isQueued && images.length === 0 && this.hasQueuedMessageText(session, promptText)) {
+        if (isQueued &&
+            images.length === 0 &&
+            this.hasQueuedMessageText(session, promptText)) {
             this.publishActivity(session, "duplicate queued message ignored", "active");
             this.publishStatus(session);
             return;
@@ -1217,24 +1412,42 @@ export class PiSessionService {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             this.publishActivity(session, "error", "error", message);
-            this.events.publish(session.sessionId, { type: "session.error", message });
+            this.events.publish(session.sessionId, {
+                type: "session.error",
+                message,
+            });
             return Promise.resolve();
         }
-        this.publishActivity(session, behavior === "steer" ? "steering queued" : behavior === "followUp" ? "message queued" : "prompt accepted", "active");
+        this.publishActivity(session, behavior === "steer"
+            ? "steering queued"
+            : behavior === "followUp"
+                ? "message queued"
+                : "prompt accepted", "active");
         if (behavior === undefined && echoUserMessage)
-            this.events.publish(session.sessionId, { type: "message.append", message: userMessage(text, images) });
+            this.events.publish(session.sessionId, {
+                type: "message.append",
+                message: userMessage(text, images),
+            });
         const promptOptions = buildPromptOptions(behavior, images);
         const promptPromise = this.runSessionEntryMutation(session, "send a prompt", () => session.prompt(text, promptOptions)).catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             this.publishActivity(session, "error", "error", message);
-            this.events.publish(session.sessionId, { type: "session.error", message });
+            this.events.publish(session.sessionId, {
+                type: "session.error",
+                message,
+            });
         });
         void promptPromise;
         return promptPromise;
     }
     enqueuePromptDuringCompaction(session, text, kind, images = [], echoUserMessage = true) {
         const queue = this.compactionPromptQueues.get(session.sessionId) ?? [];
-        queue.push({ kind, text, ...(images.length > 0 ? { images } : {}), ...(echoUserMessage ? {} : { echoUserMessage: false }) });
+        queue.push({
+            kind,
+            text,
+            ...(images.length > 0 ? { images } : {}),
+            ...(echoUserMessage ? {} : { echoUserMessage: false }),
+        });
         this.compactionPromptQueues.set(session.sessionId, queue);
         this.publishActivity(session, "message queued during compaction", "active");
         this.publishStatus(session);
@@ -1247,7 +1460,12 @@ export class PiSessionService {
      */
     retainPromptDuringModelPolicyMutation(session, text, kind, images = [], echoUserMessage = true, position = "back") {
         const queue = this.compactionPromptQueues.get(session.sessionId) ?? [];
-        const queued = { kind, text, ...(images.length > 0 ? { images } : {}), ...(echoUserMessage ? {} : { echoUserMessage: false }) };
+        const queued = {
+            kind,
+            text,
+            ...(images.length > 0 ? { images } : {}),
+            ...(echoUserMessage ? {} : { echoUserMessage: false }),
+        };
         if (position === "front")
             queue.unshift(queued);
         else
@@ -1257,7 +1475,10 @@ export class PiSessionService {
         this.publishStatus(session);
     }
     async saveAttachments(ref, attachments, folder) {
-        const parsed = parsePromptAttachments(attachments, { enforceInlineSizeLimit: false, allowFileAttachments: true });
+        const parsed = parsePromptAttachments(attachments, {
+            enforceInlineSizeLimit: false,
+            allowFileAttachments: true,
+        });
         if (parsed.length === 0)
             return [];
         await this.assertWritable(ref);
@@ -1276,26 +1497,46 @@ export class PiSessionService {
         if (session.isBashRunning)
             throw new Error("A bash command is already running");
         this.publishActivity(session, "running bash", "active", command);
-        this.events.publish(session.sessionId, { type: "shell.start", command, excludeFromContext: isExcluded });
+        this.events.publish(session.sessionId, {
+            type: "shell.start",
+            command,
+            excludeFromContext: isExcluded,
+        });
         void this.runSessionEntryMutation(session, "run a shell command", () => session.executeBash(command, (chunk) => {
-            this.events.publish(session.sessionId, { type: "shell.chunk", chunk });
+            this.events.publish(session.sessionId, {
+                type: "shell.chunk",
+                chunk,
+            });
             this.publishActivity(session, "running bash", "active", command);
             this.publishStatus(session);
-        }, { excludeFromContext: isExcluded })).then((result) => {
+        }, { excludeFromContext: isExcluded }))
+            .then((result) => {
             this.events.publish(session.sessionId, {
                 type: "shell.end",
                 output: result.output,
-                ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+                ...(result.exitCode === undefined
+                    ? {}
+                    : { exitCode: result.exitCode }),
                 cancelled: result.cancelled,
                 truncated: result.truncated,
-                ...(result.fullOutputPath === undefined ? {} : { fullOutputPath: result.fullOutputPath }),
+                ...(result.fullOutputPath === undefined
+                    ? {}
+                    : { fullOutputPath: result.fullOutputPath }),
             });
             this.publishActivity(session, "bash complete", result.exitCode === 0 ? "idle" : "error", command);
             this.publishStatus(session);
-        }).catch((error) => {
+        })
+            .catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
-            this.events.publish(session.sessionId, { type: "shell.end", output: message, isError: true });
-            this.events.publish(session.sessionId, { type: "session.error", message });
+            this.events.publish(session.sessionId, {
+                type: "shell.end",
+                output: message,
+                isError: true,
+            });
+            this.events.publish(session.sessionId, {
+                type: "session.error",
+                message,
+            });
             this.publishActivity(session, "bash failed", "error", message);
             this.publishStatus(session);
         });
@@ -1327,7 +1568,13 @@ export class PiSessionService {
         await this.assertWritable(ref);
         const active = await this.getActive(ref);
         const sourceSession = active.runtime.session;
-        const result = await this.runTreeExclusiveOperation([{ sessionId: sourceSession.sessionId, session: sourceSession, runtime: active.runtime }], "Stop current session activity before replacing the session", () => active.runtime.fork(entryId));
+        const result = await this.runTreeExclusiveOperation([
+            {
+                sessionId: sourceSession.sessionId,
+                session: sourceSession,
+                runtime: active.runtime,
+            },
+        ], "Stop current session activity before replacing the session", () => active.runtime.fork(entryId));
         if (result.cancelled)
             return { cancelled: true };
         const session = clientSessionFromRuntime(active.runtime);
@@ -1350,7 +1597,8 @@ export class PiSessionService {
         // may enter this runtime until Pi's potentially asynchronous summary settles.
         this.treeNavigations.add(session);
         try {
-            if (expectedLeafId !== undefined && session.sessionManager.getLeafId() !== expectedLeafId) {
+            if (expectedLeafId !== undefined &&
+                session.sessionManager.getLeafId() !== expectedLeafId) {
                 throw new Error("The session changed since /tree was opened. Reopen /tree and try again.");
             }
             this.publishActivity(session, options.summarize ? "summarizing branch" : "navigating session tree", "active");
@@ -1358,19 +1606,32 @@ export class PiSessionService {
             const result = await session.navigateTree(targetId, options);
             if (result.cancelled) {
                 if (this.isCurrentActiveSession(session)) {
-                    this.publishActivity(session, result.aborted === true ? "branch summary aborted" : "tree navigation cancelled", "idle");
+                    this.publishActivity(session, result.aborted === true
+                        ? "branch summary aborted"
+                        : "tree navigation cancelled", "idle");
                 }
-                return { cancelled: true, ...(result.aborted === undefined ? {} : { aborted: result.aborted }) };
+                return {
+                    cancelled: true,
+                    ...(result.aborted === undefined ? {} : { aborted: result.aborted }),
+                };
             }
             if (this.isCurrentActiveSession(session))
                 this.publishActivity(session, "session tree navigated", "idle");
-            return { cancelled: false, ...(result.editorText === undefined ? {} : { editorText: result.editorText }) };
+            return {
+                cancelled: false,
+                ...(result.editorText === undefined
+                    ? {}
+                    : { editorText: result.editorText }),
+            };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             if (this.isCurrentActiveSession(session)) {
                 this.publishActivity(session, "tree navigation failed", "error", message);
-                this.events.publish(session.sessionId, { type: "session.error", message });
+                this.events.publish(session.sessionId, {
+                    type: "session.error",
+                    message,
+                });
             }
             throw error;
         }
@@ -1394,13 +1655,16 @@ export class PiSessionService {
             const priorGeneration = this.notificationGenerationBySession.get(session);
             let candidateGeneration;
             try {
-                await session.reload(priorGeneration === undefined ? undefined : {
-                    beforeSessionStart: () => {
-                        candidateGeneration = this.notificationStore.beginReplacement(priorGeneration, notificationIdentityForSession(session));
-                        this.notificationGenerationBySession.set(session, candidateGeneration);
-                        this.replaceSessionNotificationContext(session, candidateGeneration);
-                    },
-                });
+                await session.reload(priorGeneration === undefined
+                    ? undefined
+                    : {
+                        beforeSessionStart: () => {
+                            candidateGeneration =
+                                this.notificationStore.beginReplacement(priorGeneration, notificationIdentityForSession(session));
+                            this.notificationGenerationBySession.set(session, candidateGeneration);
+                            this.replaceSessionNotificationContext(session, candidateGeneration);
+                        },
+                    });
                 if (candidateGeneration !== undefined) {
                     this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
                 }
@@ -1414,7 +1678,10 @@ export class PiSessionService {
                 }
                 const message = error instanceof Error ? error.message : String(error);
                 this.publishActivity(session, "reload failed", "error", message);
-                this.events.publish(session.sessionId, { type: "session.error", message });
+                this.events.publish(session.sessionId, {
+                    type: "session.error",
+                    message,
+                });
                 this.publishStatus(session);
                 throw error;
             }
@@ -1426,7 +1693,10 @@ export class PiSessionService {
             throw new Error("Stop current session activity before archiving");
         await this.runTreeExclusiveOperation([{ sessionId: session.sessionId, session }], "Stop current session activity before archiving", async () => {
             const archiveInput = await this.archiveInputForSession(session);
-            await this.closeActive(session.sessionId, { kind: "clear", reason: "archive" });
+            await this.closeActive(session.sessionId, {
+                kind: "clear",
+                reason: "archive",
+            });
             await this.archiveStore.archive(archiveInput);
             await this.forgetUnreadSessions([archiveInput]);
         });
@@ -1453,7 +1723,10 @@ export class PiSessionService {
             const listed = findListedSessionForBulkRef(sessionContext, ref);
             const resolvedSessionId = active?.runtime.session.sessionId ?? listed?.id ?? ref.id;
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
-                failures.push({ sessionId: resolvedSessionId, error: "Stop current session activity before archiving" });
+                failures.push({
+                    sessionId: resolvedSessionId,
+                    error: "Stop current session activity before archiving",
+                });
                 continue;
             }
             try {
@@ -1461,21 +1734,32 @@ export class PiSessionService {
                     planItems.push({ input: archiveInputFromListEntry(listed) });
                 }
                 else if (active !== undefined) {
-                    planItems.push({ input: archiveInputFromActiveSession(active.runtime.session) });
+                    planItems.push({
+                        input: archiveInputFromActiveSession(active.runtime.session),
+                    });
                 }
                 else {
                     failures.push({ sessionId: ref.id, error: "Session not found" });
                 }
             }
             catch (error) {
-                failures.push({ sessionId: resolvedSessionId, error: errorMessage(error) });
+                failures.push({
+                    sessionId: resolvedSessionId,
+                    error: errorMessage(error),
+                });
             }
         }
         const readyPlanItems = [];
         for (const item of planItems) {
-            const active = this.activeForLookup({ id: item.input.sessionId, cwd: item.input.cwd });
+            const active = this.activeForLookup({
+                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" });
+                failures.push({
+                    sessionId: item.input.sessionId,
+                    error: "Stop current session activity before archiving",
+                });
                 continue;
             }
             readyPlanItems.push(active === undefined ? item : { ...item, active });
@@ -1484,15 +1768,23 @@ export class PiSessionService {
         const archivedSessionIds = [...alreadyArchivedSessionIds];
         await this.runTreeExclusiveOperation(readyPlanItems.map(({ input, active }) => ({
             sessionId: input.sessionId,
-            ...(active === undefined ? {} : { session: active.runtime.session, runtime: active.runtime }),
+            ...(active === undefined
+                ? {}
+                : { session: active.runtime.session, runtime: active.runtime }),
         })), "Stop current session activity before archiving", async () => {
             for (const item of readyPlanItems) {
                 try {
-                    await this.closeActive(item.input.sessionId, { kind: "clear", reason: "archive" });
+                    await this.closeActive(item.input.sessionId, {
+                        kind: "clear",
+                        reason: "archive",
+                    });
                     readyInputs.push(item.input);
                 }
                 catch (error) {
-                    failures.push({ sessionId: item.input.sessionId, error: errorMessage(error) });
+                    failures.push({
+                        sessionId: item.input.sessionId,
+                        error: errorMessage(error),
+                    });
                 }
             }
             try {
@@ -1502,7 +1794,10 @@ export class PiSessionService {
             }
             catch (error) {
                 for (const input of readyInputs)
-                    failures.push({ sessionId: input.sessionId, error: errorMessage(error) });
+                    failures.push({
+                        sessionId: input.sessionId,
+                        error: errorMessage(error),
+                    });
             }
         });
         await this.forgetUnreadSessions(unreadArchivedIdentities);
@@ -1516,22 +1811,30 @@ export class PiSessionService {
     async archiveTree(ref) {
         const session = await this.getOrOpen(ref);
         const catalog = await this.workspaceArchiveCandidates(session.sessionManager.getCwd());
-        const root = findArchiveCandidateByIdOrPrefix(catalog, session.sessionId) ?? archiveCandidateFromActiveSession(session, false);
+        const root = findArchiveCandidateByIdOrPrefix(catalog, session.sessionId) ??
+            archiveCandidateFromActiveSession(session, false);
         const plan = planSessionArchiveTree(root, catalog);
-        const busy = plan.targets.map((target) => target.activeSession).find((target) => target !== undefined && this.hasActiveWork(target));
+        const busy = plan.targets
+            .map((target) => target.activeSession)
+            .find((target) => target !== undefined && this.hasActiveWork(target));
         if (busy !== undefined)
             throw new Error(`Stop current session activity before archiving ${sessionDisplayName(busy)}`);
         const archiveInputs = plan.unarchivedTargets.map((target) => archiveInputFromCandidate(target));
         await this.runTreeExclusiveOperation(plan.unarchivedTargets.map((target) => ({
             sessionId: target.id,
-            ...(target.activeSession === undefined ? {} : { session: target.activeSession }),
+            ...(target.activeSession === undefined
+                ? {}
+                : { session: target.activeSession }),
         })), `Stop current session activity before archiving ${sessionDisplayName(session)}`, async () => {
             for (const target of plan.targets) {
                 if (target.archived)
                     this.publishNotificationMutations(this.notificationStore.clearSession(target.id, "archive"));
             }
             for (const input of archiveInputs)
-                await this.closeActive(input.sessionId, { kind: "clear", reason: "archive" });
+                await this.closeActive(input.sessionId, {
+                    kind: "clear",
+                    reason: "archive",
+                });
             await this.archiveStoreArchiveMany(archiveInputs);
         });
         await this.forgetUnreadSessions(plan.targets.map((target) => ({ sessionId: target.id, cwd: target.cwd })));
@@ -1546,7 +1849,10 @@ export class PiSessionService {
         const archived = await this.getArchived(ref);
         if (archived === undefined)
             throw new Error("Session not found");
-        await this.closeActive(archived.sessionId, { kind: "clear", reason: "restore" });
+        await this.closeActive(archived.sessionId, {
+            kind: "clear",
+            reason: "restore",
+        });
         await this.archiveStore.restore(archived.sessionId);
         await this.forgetUnreadSessions([archived]);
     }
@@ -1556,14 +1862,18 @@ export class PiSessionService {
             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" });
+        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)
+        if (this.archiveStore.deleteArchived === undefined &&
+            this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
         const uniqueRefs = uniqueBulkSessionRefs(refs);
         const archivedRecords = await this.archiveStore.list();
@@ -1572,12 +1882,21 @@ export class PiSessionService {
         for (const ref of uniqueRefs) {
             const record = findArchivedRecordForBulkRef(archivedRecords, ref);
             if (record === undefined) {
-                failures.push({ sessionId: ref.id, error: "Archived session not found" });
+                failures.push({
+                    sessionId: ref.id,
+                    error: "Archived session not found",
+                });
                 continue;
             }
-            const active = this.activeForLookup({ id: record.sessionId, cwd: record.cwd });
+            const active = this.activeForLookup({
+                id: record.sessionId,
+                cwd: record.cwd,
+            });
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
-                failures.push({ sessionId: record.sessionId, error: "Stop current session activity before deleting archived session" });
+                failures.push({
+                    sessionId: record.sessionId,
+                    error: "Stop current session activity before deleting archived session",
+                });
                 continue;
             }
             planItems.push({ record });
@@ -1585,11 +1904,17 @@ export class PiSessionService {
         const readyRecords = [];
         for (const item of planItems) {
             try {
-                await this.closeActive(item.record.sessionId, { kind: "clear", reason: "delete" });
+                await this.closeActive(item.record.sessionId, {
+                    kind: "clear",
+                    reason: "delete",
+                });
                 readyRecords.push(item.record);
             }
             catch (error) {
-                failures.push({ sessionId: item.record.sessionId, error: errorMessage(error) });
+                failures.push({
+                    sessionId: item.record.sessionId,
+                    error: errorMessage(error),
+                });
             }
         }
         const moveFailures = await this.moveLegacyArchivedRecordsForDelete(readyRecords);
@@ -1625,11 +1950,19 @@ export class PiSessionService {
             const { sessionId, cwd } = notificationIdentityForSession(session);
             let candidateGeneration;
             try {
-                await this.closeActive(sessionId, priorGeneration === undefined ? CLEAR_RUNTIME_NOTIFICATIONS : DEFER_RUNTIME_NOTIFICATIONS);
-                candidateGeneration = priorGeneration === undefined
-                    ? undefined
-                    : this.notificationStore.beginReplacement(priorGeneration, { sessionId, cwd });
-                const reopened = await this.getActive(ref, candidateGeneration === undefined ? {} : { notificationGeneration: candidateGeneration });
+                await this.closeActive(sessionId, priorGeneration === undefined
+                    ? CLEAR_RUNTIME_NOTIFICATIONS
+                    : DEFER_RUNTIME_NOTIFICATIONS);
+                candidateGeneration =
+                    priorGeneration === undefined
+                        ? undefined
+                        : this.notificationStore.beginReplacement(priorGeneration, {
+                            sessionId,
+                            cwd,
+                        });
+                const reopened = await this.getActive(ref, candidateGeneration === undefined
+                    ? {}
+                    : { notificationGeneration: candidateGeneration });
                 if (candidateGeneration !== undefined) {
                     this.publishNotificationMutations(this.notificationStore.commitReplacement(candidateGeneration));
                 }
@@ -1652,7 +1985,9 @@ export class PiSessionService {
         await clearParentSession(sessionFile);
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
-        await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }]);
+        await this.forgetUnreadSessions([
+            { sessionId: session.sessionId, cwd: session.sessionManager.getCwd() },
+        ]);
     }
     async pin(ref) {
         const session = await this.getOrOpen(ref);
@@ -1681,7 +2016,9 @@ export class PiSessionService {
             modified: new Date().toISOString(),
             messageCount: session.messages.length,
             firstMessage: "",
-            ...(session.sessionName === undefined ? {} : { name: session.sessionName }),
+            ...(session.sessionName === undefined
+                ? {}
+                : { name: session.sessionName }),
             ...(parentSessionPath === undefined ? {} : { parentSessionPath }),
             ...overrides,
         };
@@ -1743,9 +2080,13 @@ export class PiSessionService {
         }
         const [sessionsByCwd, allSessions] = await Promise.all([
             this.listSessionsByCwd([...cwdSet]),
-            needsAllSessions ? this.sessionManager.listAll?.() ?? Promise.resolve([]) : Promise.resolve(undefined),
+            needsAllSessions
+                ? this.sessionManager.listAll?.() ?? Promise.resolve([])
+                : Promise.resolve(undefined),
         ]);
-        return allSessions === undefined ? { sessionsByCwd } : { sessionsByCwd, allSessions };
+        return allSessions === undefined
+            ? { sessionsByCwd }
+            : { sessionsByCwd, allSessions };
     }
     async listSessionsByCwd(cwds) {
         const uniqueCwds = uniqueStrings(cwds);
@@ -1782,7 +2123,10 @@ export class PiSessionService {
             sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
         }
         catch (error) {
-            return legacyRecords.map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
+            return legacyRecords.map((record) => ({
+                sessionId: record.sessionId,
+                error: errorMessage(error),
+            }));
         }
         const moveInputs = legacyRecords
             .map((record) => findSessionByIdOrPrefix(sessionsByCwd.get(record.cwd) ?? [], record.sessionId))
@@ -1798,17 +2142,25 @@ export class PiSessionService {
             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) }));
+                .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,
             activeSessions: this.cleanupActiveSessionStatuses(),
             thresholds: request.thresholds,
-            ...(request.projectCwds === undefined ? {} : { projectCwds: request.projectCwds }),
+            ...(request.projectCwds === undefined
+                ? {}
+                : { projectCwds: request.projectCwds }),
             now: this.now(),
         });
     }
@@ -1826,7 +2178,8 @@ export class PiSessionService {
         const sessionIds = new Set(listedSessionIds);
         for (const active of new Set(this.active.values())) {
             const session = active.runtime.session;
-            if (session.sessionManager.getCwd() === cwd && !archivedById.has(session.sessionId))
+            if (session.sessionManager.getCwd() === cwd &&
+                !archivedById.has(session.sessionId))
                 sessionIds.add(session.sessionId);
         }
         return [...sessionIds];
@@ -1845,7 +2198,9 @@ export class PiSessionService {
         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)]);
+        const [moved] = await this.archiveStoreArchiveMany([
+            archiveInputFromListEntry(session),
+        ]);
         return moved ?? record;
     }
     async ensureArchivedRecordsMoved(records) {
@@ -1854,7 +2209,9 @@ export class PiSessionService {
             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))
+            .map((record) => sessionsByCwd
+            .get(record.cwd)
+            ?.find((candidate) => candidate.id === record.sessionId))
             .filter(isDefined)
             .map(archiveInputFromListEntry);
         await this.archiveStoreArchiveMany(moveInputs);
@@ -1870,7 +2227,10 @@ export class PiSessionService {
         return archiveInputFromActiveSession(session);
     }
     async workspaceArchiveCandidates(cwd) {
-        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.list(cwd), this.archiveStore.list()]);
+        const [sessions, archivedRecords] = await Promise.all([
+            this.sessionManager.list(cwd),
+            this.archiveStore.list(),
+        ]);
         const candidates = new Map();
         const archivedById = new Map();
         for (const record of archivedRecords) {
@@ -1896,15 +2256,22 @@ export class PiSessionService {
         }
         for (const active of new Set(this.active.values())) {
             const session = active.runtime.session;
-            if (session.sessionManager.getCwd() !== cwd || archivedById.has(session.sessionId))
+            if (session.sessionManager.getCwd() !== cwd ||
+                archivedById.has(session.sessionId))
                 continue;
             const existing = candidates.get(session.sessionId);
-            candidates.set(session.sessionId, { ...(existing ?? archiveCandidateFromActiveSession(session, false)), activeSession: session });
+            candidates.set(session.sessionId, {
+                ...(existing ?? archiveCandidateFromActiveSession(session, false)),
+                activeSession: session,
+            });
         }
         return [...candidates.values()];
     }
     async listSessionNames(cwd) {
-        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.list(cwd), this.archiveStore.list()]);
+        const [sessions, archivedRecords] = await Promise.all([
+            this.sessionManager.list(cwd),
+            this.archiveStore.list(),
+        ]);
         const names = new Set();
         for (const session of sessions)
             addSessionName(names, session.name);
@@ -1925,7 +2292,9 @@ export class PiSessionService {
             await Promise.allSettled(pendingOpens);
         const active = this.active.get(sessionId);
         if (notificationPolicy.kind === "clear") {
-            const generation = active === undefined ? undefined : this.notificationGenerationBySession.get(active.runtime.session);
+            const generation = active === undefined
+                ? undefined
+                : this.notificationGenerationBySession.get(active.runtime.session);
             const mutations = generation === undefined
                 ? this.notificationStore.clearSession(sessionId, notificationPolicy.reason)
                 : this.notificationStore.clearGeneration(generation, notificationPolicy.reason);
@@ -1977,7 +2346,7 @@ export class PiSessionService {
             throw branchSummaryAbortError;
     }
     async assertWritable(ref) {
-        if (await this.getArchived(ref) !== undefined)
+        if ((await this.getArchived(ref)) !== undefined)
             throw new Error("Archived sessions are read-only. Restore the session to continue.");
     }
     async getOrOpen(ref) {
@@ -1996,7 +2365,7 @@ export class PiSessionService {
             return archived.archivePath;
         const match = isPiSessionRef(ref)
             ? (await this.sessionManager.list(ref.cwd)).find((session) => session.id === ref.id || session.id.startsWith(ref.id))
-            : (await this.sessionManager.listAll?.() ?? []).find((session) => session.id === ref || session.id.startsWith(ref));
+            : ((await this.sessionManager.listAll?.()) ?? []).find((session) => session.id === ref || session.id.startsWith(ref));
         if (match === undefined || match.path === "")
             throw new Error("Session not found");
         return match.path;
@@ -2012,7 +2381,7 @@ export class PiSessionService {
         }
         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));
+            : ((await this.sessionManager.listAll?.()) ?? []).find((s) => s.id === ref || s.id.startsWith(ref));
         if (!match)
             throw new Error("Session not found");
         return this.openExistingSession(match.id, match.cwd, () => this.sessionManager.open(match.path), options);
@@ -2058,23 +2427,31 @@ export class PiSessionService {
         if (exact !== undefined && lookupMatchesActiveSession(ref, exact))
             return exact;
         for (const [candidateId, active] of this.active.entries()) {
-            if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active))
+            if (candidateId.startsWith(sessionId) &&
+                lookupMatchesActiveSession(ref, active))
                 return active;
         }
         return undefined;
     }
     async create(sessionManager, cwd, options = {}) {
-        const delegationToolsEnabled = options.creationProvenance !== "tracked-subsession"
-            && await sessionAllowsDelegationTools(sessionManager, this.sessionManager);
+        const delegationToolsEnabled = options.creationProvenance !== "tracked-subsession" &&
+            (await sessionAllowsDelegationTools(sessionManager, this.sessionManager));
         const runtime = await this.createAgentRuntime(this.createRuntime, {
             cwd,
             agentDir: this.agentDir,
             sessionManager,
             delegationToolsEnabled,
-            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
-            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
+            ...(options.initialModel === undefined
+                ? {}
+                : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined
+                ? {}
+                : { initialThinkingLevel: options.initialThinkingLevel }),
         });
-        const active = { runtime, unsubscribe: noop };
+        const active = {
+            runtime,
+            unsubscribe: noop,
+        };
         let boundSession = runtime.session;
         let notificationGeneration = options.notificationGeneration;
         let notificationOwnership = options.notifications === "disabled"
@@ -2139,7 +2516,8 @@ export class PiSessionService {
             if (options.initializeModelPolicy !== undefined) {
                 await this.initializeSessionModelPolicy(runtime.session, options.initializeModelPolicy);
             }
-            if (notificationOwnership === "replacement" && notificationGeneration !== undefined) {
+            if (notificationOwnership === "replacement" &&
+                notificationGeneration !== undefined) {
                 this.publishNotificationMutations(this.notificationStore.commitReplacement(notificationGeneration));
                 notificationOwnership = "external";
             }
@@ -2187,7 +2565,10 @@ export class PiSessionService {
             onError: (error) => {
                 const message = `${error.extensionPath}: ${error.error}`;
                 this.publishActivity(session, "extension error", "error", message);
-                this.events.publish(session.sessionId, { type: "session.error", message });
+                this.events.publish(session.sessionId, {
+                    type: "session.error",
+                    message,
+                });
             },
         });
     }
@@ -2240,7 +2621,8 @@ export class PiSessionService {
         const previousCwd = canonicalizeStoredCwd(previous.sessionManager.getCwd());
         this.unreadStore.forgetActivity(previous.sessionId, previousCwd);
         const nextCwd = canonicalizeStoredCwd(next.sessionManager.getCwd());
-        if (previous.sessionId === next.sessionId && cwdPathsEqual(previousCwd, nextCwd))
+        if (previous.sessionId === next.sessionId &&
+            cwdPathsEqual(previousCwd, nextCwd))
             return;
         await this.publishUnreadMutations(this.unreadStore.forgetSession(previous.sessionId, previousCwd));
     }
@@ -2263,11 +2645,14 @@ export class PiSessionService {
     publishUnreadMutations(mutations) {
         this.enqueueUnreadMutations(mutations);
         this.unreadPublicationFlushRequested = true;
-        if (this.unreadPublication === undefined && this.unreadPublicationRetryTimer !== undefined) {
+        if (this.unreadPublication === undefined &&
+            this.unreadPublicationRetryTimer !== undefined) {
             const failure = this.unreadPublicationFailure;
             return Promise.reject(failure instanceof Error
                 ? failure
-                : new Error("Session unread publication is awaiting retry", { cause: failure }));
+                : new Error("Session unread publication is awaiting retry", {
+                    cause: failure,
+                }));
         }
         return this.ensureUnreadPublication();
     }
@@ -2290,7 +2675,8 @@ export class PiSessionService {
         return publication;
     }
     async drainUnreadPublication() {
-        while (this.unreadPublicationFlushRequested || this.pendingUnreadMutations.length > 0) {
+        while (this.unreadPublicationFlushRequested ||
+            this.pendingUnreadMutations.length > 0) {
             this.unreadPublicationFlushRequested = false;
             const batch = this.pendingUnreadMutations.splice(0);
             let publishedCount = 0;
@@ -2324,7 +2710,8 @@ export class PiSessionService {
             this.pendingUnreadMutations.splice(0, excess);
     }
     scheduleUnreadPublicationRetry() {
-        if (this.unreadPublicationStopped || this.unreadPublicationRetryTimer !== undefined)
+        if (this.unreadPublicationStopped ||
+            this.unreadPublicationRetryTimer !== undefined)
             return;
         const delay = this.unreadPublicationRetryDelayMs;
         this.unreadPublicationRetryDelayMs = Math.min(Math.max(delay * 2, this.unreadPublicationRetryInitialMs), Math.max(MAX_UNREAD_PUBLICATION_RETRY_MS, this.unreadPublicationRetryInitialMs));
@@ -2393,8 +2780,11 @@ export class PiSessionService {
     recordGenerationProgress(session, message) {
         const current = this.generationMetrics.get(session);
         const providerTokens = providerOutputTokens(message);
-        const estimatedTokens = providerTokens === undefined && current?.estimated !== false ? estimatedOutputTokens(message) : undefined;
-        const outputTokens = providerTokens ?? (current?.estimated === false ? current.outputTokens : estimatedTokens);
+        const estimatedTokens = providerTokens === undefined && current?.estimated !== false
+            ? estimatedOutputTokens(message)
+            : undefined;
+        const outputTokens = providerTokens ??
+            (current?.estimated === false ? current.outputTokens : estimatedTokens);
         if (outputTokens === undefined)
             return;
         this.generationMetrics.set(session, {
@@ -2408,15 +2798,20 @@ export class PiSessionService {
         if (metrics === undefined)
             return undefined;
         const elapsedMs = this.now().getTime() - metrics.startedAt;
-        const tokensPerSecond = elapsedMs >= MIN_GENERATION_RATE_ELAPSED_MS ? metrics.outputTokens * 1_000 / elapsedMs : undefined;
+        const tokensPerSecond = elapsedMs >= MIN_GENERATION_RATE_ELAPSED_MS
+            ? (metrics.outputTokens * 1_000) / elapsedMs
+            : undefined;
         return {
             outputTokens: metrics.outputTokens,
-            ...(tokensPerSecond === undefined || !Number.isFinite(tokensPerSecond) ? {} : { tokensPerSecond }),
+            ...(tokensPerSecond === undefined || !Number.isFinite(tokensPerSecond)
+                ? {}
+                : { tokensPerSecond }),
             ...(metrics.estimated ? { estimated: true } : {}),
         };
     }
     scheduleCompactionQueueDrain(sessionId, delayMs = 0) {
-        if (!this.compactionPromptQueues.has(sessionId) || this.compactionDrainTimers.has(sessionId))
+        if (!this.compactionPromptQueues.has(sessionId) ||
+            this.compactionDrainTimers.has(sessionId))
             return;
         const timer = setTimeout(() => {
             this.compactionDrainTimers.delete(sessionId);
@@ -2447,7 +2842,9 @@ export class PiSessionService {
             return;
         this.publishStatus(session);
         const submitted = this.submitPrompt(session, prompt.text, undefined, prompt.images, prompt.echoUserMessage ?? true);
-        void submitted.finally(() => { this.scheduleCompactionQueueDrain(sessionId); });
+        void submitted.finally(() => {
+            this.scheduleCompactionQueueDrain(sessionId);
+        });
     }
     takeCompactionPromptQueue(sessionId) {
         const queued = this.compactionPromptQueues.get(sessionId) ?? [];
@@ -2475,7 +2872,10 @@ export class PiSessionService {
         this.compactionDrainTimers.clear();
     }
     maybeGenerateSessionName(session, firstMessage) {
-        if (session.sessionName !== undefined || session.messages.length !== 0 || session.isStreaming || session.isCompacting)
+        if (session.sessionName !== undefined ||
+            session.messages.length !== 0 ||
+            session.isStreaming ||
+            session.isCompacting)
             return;
         const deterministicName = deterministicSessionName(firstMessage);
         if (deterministicName !== undefined) {
@@ -2485,9 +2885,11 @@ export class PiSessionService {
         const model = session.model;
         if (model === undefined)
             return;
-        void generateShortSessionName(session.agent.streamFunction, model, firstMessage).then((name) => {
+        void generateShortSessionName(session.agent.streamFunction, model, firstMessage)
+            .then((name) => {
             this.applyGeneratedSessionName(session, name ?? fallbackSessionName(firstMessage));
-        }).catch(() => {
+        })
+            .catch(() => {
             this.applyGeneratedSessionName(session, fallbackSessionName(firstMessage));
         });
     }
@@ -2509,7 +2911,10 @@ export class PiSessionService {
                 this.applyGeneratedSessionName(session, generatedName);
             }
             catch (error) {
-                this.logger.info({ sessionId: session.sessionId, error: error instanceof Error ? error.message : String(error) }, "failed to apply deferred session name");
+                this.logger.info({
+                    sessionId: session.sessionId,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "failed to apply deferred session name");
             }
         }
         const notifications = this.deferredSubsessionNotifications.get(session) ?? [];
@@ -2544,7 +2949,9 @@ export class PiSessionService {
             this.authLossWarnings.delete(warningKey);
             return;
         }
-        if (removedProviderId === undefined || model.provider !== removedProviderId || this.authLossWarnings.has(warningKey))
+        if (removedProviderId === undefined ||
+            model.provider !== removedProviderId ||
+            this.authLossWarnings.has(warningKey))
             return;
         this.authLossWarnings.add(warningKey);
         this.events.publish(session.sessionId, {
@@ -2563,7 +2970,11 @@ export class PiSessionService {
     publishSessionName(session) {
         const event = session.sessionName === undefined
             ? { type: "session.name", sessionId: session.sessionId }
-            : { type: "session.name", sessionId: session.sessionId, name: session.sessionName };
+            : {
+                type: "session.name",
+                sessionId: session.sessionId,
+                name: session.sessionName,
+            };
         this.events.publish(session.sessionId, event);
         this.events.publishGlobal(event);
     }
@@ -2603,17 +3014,20 @@ export class PiSessionService {
         return "active";
     }
     hasActiveWork(session) {
-        return this.treeNavigations.has(session)
-            || this.isSessionEntryMutationActive(session)
-            || this.isTreeExclusiveOperationActive(session)
-            || sessionHasActiveWork(session, this.compactionQueuedMessages(session.sessionId).length);
+        return (this.treeNavigations.has(session) ||
+            this.isSessionEntryMutationActive(session) ||
+            this.isTreeExclusiveOperationActive(session) ||
+            sessionHasActiveWork(session, this.compactionQueuedMessages(session.sessionId).length));
     }
     async runTreeExclusiveOperation(targets, activeError, operation) {
         const sessionIds = new Set();
         const runtimes = new Set();
         const sessions = new Set();
         for (const target of targets) {
-            const runtime = target.runtime ?? (target.session === undefined ? undefined : this.activeRuntimeForSession(target.session));
+            const runtime = target.runtime ??
+                (target.session === undefined
+                    ? undefined
+                    : this.activeRuntimeForSession(target.session));
             const session = target.session ?? runtime?.session;
             if (session !== undefined && this.hasActiveWork(session))
                 throw new Error(activeError);
@@ -2652,7 +3066,8 @@ export class PiSessionService {
         if (this.isTreeExclusiveSessionIdentityActive(session.sessionId))
             return true;
         const runtime = this.activeRuntimeForSession(session);
-        return runtime !== undefined && (this.treeExclusiveRuntimeOperationCounts.get(runtime) ?? 0) > 0;
+        return (runtime !== undefined &&
+            (this.treeExclusiveRuntimeOperationCounts.get(runtime) ?? 0) > 0);
     }
     activeRuntimeForSession(session) {
         for (const active of new Set(this.active.values())) {
@@ -2744,11 +3159,18 @@ export class PiSessionService {
     }
     publishActivity(session, label, phase, detail) {
         const at = new Date().toISOString();
-        const stored = detail === undefined ? { phase, label, at } : { phase, label, detail, at };
+        const stored = detail === undefined
+            ? { phase, label, at }
+            : { phase, label, detail, at };
         this.activities.set(session.sessionId, stored);
-        const activity = detail === undefined ? { sessionId: session.sessionId, phase, label, at } : { sessionId: session.sessionId, phase, label, detail, at };
+        const activity = detail === undefined
+            ? { sessionId: session.sessionId, phase, label, at }
+            : { sessionId: session.sessionId, phase, label, detail, at };
         this.workspaceActivity?.applySessionActivity(session.sessionManager.getCwd(), activity);
-        this.events.publish(session.sessionId, { type: "activity.update", activity });
+        this.events.publish(session.sessionId, {
+            type: "activity.update",
+            activity,
+        });
         this.events.publishGlobal({ type: "activity.update", activity });
         this.observeUnreadActivityState(session);
     }
@@ -2768,19 +3190,49 @@ export class PiSessionService {
         const stored = { phase: "idle", label: "idle", at };
         this.activities.set(session.sessionId, stored);
         const activity = { sessionId: session.sessionId, ...stored };
-        this.events.publish(session.sessionId, { type: "activity.update", activity });
+        this.events.publish(session.sessionId, {
+            type: "activity.update",
+            activity,
+        });
         this.events.publishGlobal({ type: "activity.update", activity });
     }
+    /**
+     * Read-only capability view for `get_model_policy`, built from the session's
+     * own cached inspection so it cannot disagree with what the HTTP route reports.
+     */
+    modelPolicyCapability(sessionId) {
+        // The tool only ever asks about its own session, which is live by definition
+        // while a tool call is executing. A miss means the runtime was torn down
+        // mid-call, which is a terminal read failure rather than a policy answer.
+        const session = this.active.get(sessionId)?.runtime.session;
+        if (session === undefined)
+            throw new Error(`Session ${sessionId} is not active`);
+        const inspection = this.inspectAndCacheSessionModelPolicy(session);
+        return buildModelPolicyCapability({
+            policy: inspection.kind === "invalid" ? undefined : inspection.policy,
+            currentRuntime: this.exactSelectionFromSession(session),
+            ladder: this.modelTierRegistry.validate(),
+            resolveTier: (tier) => {
+                const resolved = this.modelTierRegistry.resolve(tier);
+                return {
+                    model: { provider: resolved.model.provider, id: resolved.model.id },
+                    thinkingLevel: resolved.thinkingLevel,
+                };
+            },
+            blockedReason: this.modelPolicyBlockedReason(session),
+        });
+    }
     exactSelectionFromSession(session) {
         const model = session.model;
-        if (model === undefined
-            || typeof model.provider !== "string"
-            || model.provider.trim() === ""
-            || typeof model.id !== "string"
-            || model.id.trim() === "") {
+        if (model === undefined ||
+            typeof model.provider !== "string" ||
+            model.provider.trim() === "" ||
+            typeof model.id !== "string" ||
+            model.id.trim() === "") {
             throw new Error("Session model policy requires a resolved runtime model provider and id");
         }
-        if (typeof session.thinkingLevel !== "string" || session.thinkingLevel.trim() === "") {
+        if (typeof session.thinkingLevel !== "string" ||
+            session.thinkingLevel.trim() === "") {
             throw new Error("Session model policy requires a resolved runtime thinking level");
         }
         return {
@@ -2789,7 +3241,8 @@ export class PiSessionService {
         };
     }
     policyEntries(session) {
-        return session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch();
+        return (session.sessionManager.getEntries?.() ??
+            session.sessionManager.getBranch());
     }
     inspectAndCacheSessionModelPolicy(session) {
         const inspection = inspectSessionModelPolicy(this.policyEntries(session), this.exactSelectionFromSession(session));
@@ -2804,7 +3257,8 @@ export class PiSessionService {
     }
     /** Effective block: an unproven runtime restoration outranks an entry defect. */
     modelPolicyBlockedReason(session) {
-        return this.modelPolicyRuntimeBlocks.get(session.sessionId) ?? this.modelPolicyEntryReasons.get(session);
+        return (this.modelPolicyRuntimeBlocks.get(session.sessionId) ??
+            this.modelPolicyEntryReasons.get(session));
     }
     /**
      * Root-session policy initialization. `true` records the runtime's own tuple;
@@ -2812,7 +3266,10 @@ export class PiSessionService {
      * of `start()` sees the session, so no prompt can precede the policy.
      */
     async initializeSessionModelPolicy(session, initializer) {
-        const current = { mode: "exact", exact: this.exactSelectionFromSession(session) };
+        const current = {
+            mode: "exact",
+            exact: this.exactSelectionFromSession(session),
+        };
         if (initializer === true) {
             this.appendSessionModelPolicy(session, current);
             this.inspectAndCacheSessionModelPolicy(session);
@@ -2820,7 +3277,9 @@ export class PiSessionService {
         }
         // Root creation reports failure through its own abort/dispose cleanup rather
         // than publishing a failed transition for a session no client has seen.
-        await this.applySessionModelPolicy(session, current, initializer, { action: "initialize the session model policy" });
+        await this.applySessionModelPolicy(session, current, initializer, {
+            action: "initialize the session model policy",
+        });
     }
     /**
      * The single policy transition path. Validates the complete target before any
@@ -2831,7 +3290,10 @@ export class PiSessionService {
     async applySessionModelPolicy(session, current, update, options) {
         const plan = planSessionModelPolicyUpdate(current, update, (tier) => {
             const resolved = this.modelTierRegistry.resolve(tier);
-            return { model: { provider: resolved.model.provider, id: resolved.model.id }, thinkingLevel: resolved.thinkingLevel };
+            return {
+                model: { provider: resolved.model.provider, id: resolved.model.id },
+                thinkingLevel: resolved.thinkingLevel,
+            };
         });
         // Validation happens before the mutation opens, so a rejected target leaves
         // the runtime and the persisted policy untouched.
@@ -2849,7 +3311,7 @@ export class PiSessionService {
             }
             catch (error) {
                 const reason = error instanceof Error ? error.message : String(error);
-                if (!await this.restoreExactSelection(session, previous)) {
+                if (!(await this.restoreExactSelection(session, previous))) {
                     this.modelPolicyRuntimeBlocks.set(session.sessionId, `MODEL_POLICY_BLOCKED: ${reason}; the previous model and thinking pair could not be restored`);
                 }
                 this.inspectAndCacheSessionModelPolicy(session);
@@ -2956,14 +3418,16 @@ export class PiSessionService {
                 const policy = {
                     mode: "exact",
                     exact: this.exactSelectionFromSession(session),
-                    ...(currentPolicy.tier === undefined ? {} : { tier: currentPolicy.tier }),
+                    ...(currentPolicy.tier === undefined
+                        ? {}
+                        : { tier: currentPolicy.tier }),
                 };
                 try {
                     this.appendSessionModelPolicy(session, policy);
                 }
                 catch (error) {
                     const reason = error instanceof Error ? error.message : String(error);
-                    if (!await this.restoreExactSelection(session, previous)) {
+                    if (!(await this.restoreExactSelection(session, previous))) {
                         this.modelPolicyRuntimeBlocks.set(session.sessionId, `MODEL_POLICY_BLOCKED: ${reason}; the previous model and thinking pair could not be restored`);
                     }
                     this.inspectAndCacheSessionModelPolicy(session);
@@ -3009,7 +3473,8 @@ export class PiSessionService {
         const candidates = session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
             : session.modelRuntime.getAvailableSnapshot();
-        const model = candidates.find((candidate) => candidate.provider === selection.model.provider && candidate.id === selection.model.id);
+        const model = candidates.find((candidate) => candidate.provider === selection.model.provider &&
+            candidate.id === selection.model.id);
         const described = `${selection.model.provider}/${selection.model.id}`;
         if (model === undefined)
             throw new Error(`Model not found: ${described}`);
@@ -3019,7 +3484,13 @@ export class PiSessionService {
         if (!runtimeThinkingLevels(model).includes(selection.thinkingLevel)) {
             throw new Error(`Thinking level ${selection.thinkingLevel} is unsupported by ${described}`);
         }
-        return { model, selection: { model: { provider: model.provider, id: model.id }, thinkingLevel: selection.thinkingLevel } };
+        return {
+            model,
+            selection: {
+                model: { provider: model.provider, id: model.id },
+                thinkingLevel: selection.thinkingLevel,
+            },
+        };
     }
     /**
      * Model first, then thinking: `setThinkingLevel` clamps against the currently
@@ -3034,11 +3505,11 @@ export class PiSessionService {
         await session.setModel(target.model);
         session.setThinkingLevel(level);
         const effective = this.exactSelectionFromSession(session);
-        if (effective.model.provider !== target.selection.model.provider
-            || effective.model.id !== target.selection.model.id
-            || effective.thinkingLevel !== level) {
-            throw new Error(`Session model policy could not activate ${target.selection.model.provider}/${target.selection.model.id} at thinking level ${level}`
-                + `; the runtime reports ${effective.model.provider}/${effective.model.id} at thinking level ${effective.thinkingLevel}`);
+        if (effective.model.provider !== target.selection.model.provider ||
+            effective.model.id !== target.selection.model.id ||
+            effective.thinkingLevel !== level) {
+            throw new Error(`Session model policy could not activate ${target.selection.model.provider}/${target.selection.model.id} at thinking level ${level}` +
+                `; the runtime reports ${effective.model.provider}/${effective.model.id} at thinking level ${effective.thinkingLevel}`);
         }
     }
     /**
@@ -3049,9 +3520,9 @@ export class PiSessionService {
     async restoreExactSelection(session, previous) {
         try {
             const current = this.exactSelectionFromSession(session);
-            if (current.model.provider === previous.model.provider
-                && current.model.id === previous.model.id
-                && current.thinkingLevel === previous.thinkingLevel) {
+            if (current.model.provider === previous.model.provider &&
+                current.model.id === previous.model.id &&
+                current.thinkingLevel === previous.thinkingLevel) {
                 return true;
             }
             const target = await this.resolveAvailableExactSelection(session, previous);
@@ -3093,7 +3564,9 @@ export class PiSessionService {
         }
         return {
             mode: inspection.policy.mode,
-            ...(inspection.policy.tier === undefined ? {} : { tier: inspection.policy.tier }),
+            ...(inspection.policy.tier === undefined
+                ? {}
+                : { tier: inspection.policy.tier }),
             resolved,
             ladderValid: ladderValidation.valid,
             ...(blockedReason === undefined ? {} : { blockedReason }),
@@ -3101,7 +3574,9 @@ export class PiSessionService {
     }
     statusFromSession(session) {
         const stats = session.getSessionStats();
-        const model = session.model === undefined ? undefined : modelToClientModel(session.model);
+        const model = session.model === undefined
+            ? undefined
+            : modelToClientModel(session.model);
         const generation = this.generationForStatus(session);
         const contextUsage = session.getContextUsage();
         const warnings = this.warningsForSession(session);
@@ -3139,7 +3614,8 @@ export class PiSessionService {
         return warnings;
     }
     pendingMessageCount(session) {
-        return session.pendingMessageCount + this.compactionQueuedMessages(session.sessionId).length;
+        return (session.pendingMessageCount +
+            this.compactionQueuedMessages(session.sessionId).length);
     }
     compactionQueuedMessages(sessionId) {
         return this.compactionPromptQueues.get(sessionId) ?? [];
@@ -3154,7 +3630,9 @@ function previewResponseFromPlan(plan) {
         thresholds: plan.thresholds,
         projects: plan.projects,
         totals: plan.totals,
-        ...(plan.skippedBusySessionIds.length === 0 ? {} : { skippedBusySessionIds: plan.skippedBusySessionIds }),
+        ...(plan.skippedBusySessionIds.length === 0
+            ? {}
+            : { skippedBusySessionIds: plan.skippedBusySessionIds }),
     };
 }
 function uniqueBulkSessionRefs(refs) {
@@ -3173,15 +3651,19 @@ function bulkRefToLookup(ref) {
     return ref.cwd === undefined ? ref.id : { 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) => (ref.cwd === undefined || 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 context.allSessions === undefined
+        ? undefined
+        : findSessionByIdOrPrefix(context.allSessions, ref.id);
 }
 function findSessionByIdOrPrefix(sessions, sessionId) {
-    return sessions.find((session) => session.id === sessionId) ?? sessions.find((session) => session.id.startsWith(sessionId));
+    return (sessions.find((session) => session.id === sessionId) ??
+        sessions.find((session) => session.id.startsWith(sessionId)));
 }
 function uniqueStrings(values) {
     return [...new Set(values)];
@@ -3219,7 +3701,9 @@ function clientSessionFromListEntry(session) {
         modified: session.modified.toISOString(),
         messageCount: session.messageCount,
         firstMessage: session.firstMessage,
-        ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
+        ...(session.parentSessionPath === undefined
+            ? {}
+            : { parentSessionPath: session.parentSessionPath }),
     };
 }
 function archiveInputFromListEntry(session) {
@@ -3232,7 +3716,9 @@ function archiveInputFromListEntry(session) {
         messageCount: session.messageCount,
         firstMessage: session.firstMessage,
         ...(session.name === undefined ? {} : { name: session.name }),
-        ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
+        ...(session.parentSessionPath === undefined
+            ? {}
+            : { parentSessionPath: session.parentSessionPath }),
     };
 }
 function archiveInputFromActiveSession(session) {
@@ -3259,7 +3745,9 @@ function archiveCandidateFromListEntry(session) {
         cwd: session.cwd,
         archived: false,
         listEntry: session,
-        ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
+        ...(session.parentSessionPath === undefined
+            ? {}
+            : { parentSessionPath: session.parentSessionPath }),
     };
 }
 function archiveCandidateFromArchivedRecord(record, fallback) {
@@ -3298,7 +3786,10 @@ function archiveInputFromCandidate(candidate) {
     throw new Error(`Session is not available for archiving: ${candidate.id}`);
 }
 function sessionHasActiveWork(session, extraQueuedMessageCount = 0) {
-    return session.isStreaming || session.isCompacting || session.isBashRunning || session.pendingMessageCount + extraQueuedMessageCount > 0;
+    return (session.isStreaming ||
+        session.isCompacting ||
+        session.isBashRunning ||
+        session.pendingMessageCount + extraQueuedMessageCount > 0);
 }
 function sessionDisplayName(session) {
     return session.sessionName ?? session.sessionId;
@@ -3309,7 +3800,11 @@ function clientSessionFromArchivedRecord(record, fallback) {
     const modified = record.modified ?? fallback?.modified.toISOString();
     const messageCount = record.messageCount ?? fallback?.messageCount;
     const firstMessage = record.firstMessage ?? fallback?.firstMessage;
-    if (path === undefined || created === undefined || modified === undefined || messageCount === undefined || firstMessage === undefined)
+    if (path === undefined ||
+        created === undefined ||
+        modified === undefined ||
+        messageCount === undefined ||
+        firstMessage === undefined)
         return undefined;
     const name = record.name ?? fallback?.name;
     const parentSessionPath = record.parentSessionPath ?? fallback?.parentSessionPath;
@@ -3409,9 +3904,11 @@ function findReciprocalParentSubsessionLink(managers, parentSessionFile, parentS
         const link = parsePersistedParentSubsessionLink(entry);
         if (link === undefined)
             continue;
-        if (link.spawnedBySessionId !== parentSessionId || link.spawnedSessionId !== childSessionId)
+        if (link.spawnedBySessionId !== parentSessionId ||
+            link.spawnedSessionId !== childSessionId)
             continue;
-        if (link.spawnedSessionFile === undefined || !sessionPathsEqual(link.spawnedSessionFile, childSessionFile))
+        if (link.spawnedSessionFile === undefined ||
+            !sessionPathsEqual(link.spawnedSessionFile, childSessionFile))
             continue;
         return link;
     }
@@ -3421,7 +3918,9 @@ function trackedSubsessionLinkFromParentLink(parentSessionId, link, parentSessio
     return {
         parentSessionId,
         childSessionId: link.spawnedSessionId,
-        ...(link.spawnedSessionFile === undefined ? {} : { childSessionFile: link.spawnedSessionFile }),
+        ...(link.spawnedSessionFile === undefined
+            ? {}
+            : { childSessionFile: link.spawnedSessionFile }),
         parentSessionFile,
         ...(link.cwd === undefined ? {} : { cwd: link.cwd }),
     };
@@ -3431,7 +3930,9 @@ function persistedParentSubsessionLinkData(link) {
         version: 1,
         spawnedBySessionId: link.parentSessionId,
         spawnedSessionId: link.childSessionId,
-        ...(link.childSessionFile === undefined ? {} : { spawnedSessionFile: link.childSessionFile }),
+        ...(link.childSessionFile === undefined
+            ? {}
+            : { spawnedSessionFile: link.childSessionFile }),
         ...(link.cwd === undefined ? {} : { cwd: link.cwd }),
     };
 }
@@ -3443,33 +3944,45 @@ function persistedChildSubsessionLinkData(parentSessionId, childSessionId) {
     };
 }
 function parsePersistedParentSubsessionLink(entry) {
-    if (!isRecord(entry) || entry["type"] !== "custom" || entry["customType"] !== SUBSESSION_LINK_CUSTOM_TYPE)
+    if (!isRecord(entry) ||
+        entry["type"] !== "custom" ||
+        entry["customType"] !== SUBSESSION_LINK_CUSTOM_TYPE)
         return undefined;
     const data = entry["data"];
     if (!isRecord(data))
         return undefined;
     const spawnedBySessionId = getString(data, "spawnedBySessionId");
     const spawnedSessionId = getString(data, "spawnedSessionId");
-    if (spawnedBySessionId === undefined || spawnedBySessionId === "" || spawnedSessionId === undefined || spawnedSessionId === "")
+    if (spawnedBySessionId === undefined ||
+        spawnedBySessionId === "" ||
+        spawnedSessionId === undefined ||
+        spawnedSessionId === "")
         return undefined;
     const spawnedSessionFile = getString(data, "spawnedSessionFile");
     const cwd = getString(data, "cwd");
     return {
         spawnedBySessionId,
         spawnedSessionId,
-        ...(spawnedSessionFile === undefined || spawnedSessionFile === "" ? {} : { spawnedSessionFile }),
+        ...(spawnedSessionFile === undefined || spawnedSessionFile === ""
+            ? {}
+            : { spawnedSessionFile }),
         ...(cwd === undefined || cwd === "" ? {} : { cwd }),
     };
 }
 function parsePersistedChildSubsessionLink(entry) {
-    if (!isRecord(entry) || entry["type"] !== "custom" || entry["customType"] !== SUBSESSION_CHILD_LINK_CUSTOM_TYPE)
+    if (!isRecord(entry) ||
+        entry["type"] !== "custom" ||
+        entry["customType"] !== SUBSESSION_CHILD_LINK_CUSTOM_TYPE)
         return undefined;
     const data = entry["data"];
     if (!isRecord(data))
         return undefined;
     const spawnedBySessionId = getString(data, "spawnedBySessionId");
     const spawnedSessionId = getString(data, "spawnedSessionId");
-    if (spawnedBySessionId === undefined || spawnedBySessionId === "" || spawnedSessionId === undefined || spawnedSessionId === "")
+    if (spawnedBySessionId === undefined ||
+        spawnedBySessionId === "" ||
+        spawnedSessionId === undefined ||
+        spawnedSessionId === "")
         return undefined;
     return { spawnedBySessionId, spawnedSessionId };
 }
@@ -3494,13 +4007,16 @@ function sessionFileExists(sessionFile) {
 }
 function sessionFileMatches(session, expectedSessionFile) {
     const sessionFile = nonEmptyString(session.sessionFile);
-    return sessionFile !== undefined && expectedSessionFile !== undefined && sessionPathsEqual(sessionFile, expectedSessionFile);
+    return (sessionFile !== undefined &&
+        expectedSessionFile !== undefined &&
+        sessionPathsEqual(sessionFile, expectedSessionFile));
 }
 function activeSessionFileMatches(active, expectedSessionFile) {
     return sessionFileMatches(active.runtime.session, expectedSessionFile);
 }
 function trackedLinkParentFileMatches(link, parentSessionFile) {
-    return link.parentSessionFile !== undefined && sessionPathsEqual(link.parentSessionFile, parentSessionFile);
+    return (link.parentSessionFile !== undefined &&
+        sessionPathsEqual(link.parentSessionFile, parentSessionFile));
 }
 async function readSessionHeaderSummary(sessionFile) {
     let file;
@@ -3512,10 +4028,15 @@ async function readSessionHeaderSummary(sessionFile) {
         if (firstLine === undefined || firstLine === "")
             return undefined;
         const header = JSON.parse(firstLine);
-        if (!isRecord(header) || header["type"] !== "session" || typeof header["id"] !== "string")
+        if (!isRecord(header) ||
+            header["type"] !== "session" ||
+            typeof header["id"] !== "string")
             return undefined;
         const parentSession = getString(header, "parentSession");
-        return { id: header["id"], ...(parentSession === undefined ? {} : { parentSession }) };
+        return {
+            id: header["id"],
+            ...(parentSession === undefined ? {} : { parentSession }),
+        };
     }
     catch {
         return undefined;
@@ -3530,7 +4051,8 @@ async function sessionFileHeaderMatches(sessionFile, expected) {
         return false;
     if (expected.parentSessionFile === undefined)
         return true;
-    return header.parentSession !== undefined && sessionPathsEqual(header.parentSession, expected.parentSessionFile);
+    return (header.parentSession !== undefined &&
+        sessionPathsEqual(header.parentSession, expected.parentSessionFile));
 }
 async function clearParentSession(sessionFile) {
     const content = await readFile(sessionFile, "utf8");
@@ -3555,8 +4077,12 @@ function clearSessionQueue(session) {
 }
 function queuedMessagesFromSession(session, extraQueuedMessages = []) {
     return [
-        ...session.getSteeringMessages().map((text) => ({ kind: "steer", text })),
-        ...session.getFollowUpMessages().map((text) => ({ kind: "followUp", text })),
+        ...session
+            .getSteeringMessages()
+            .map((text) => ({ kind: "steer", text })),
+        ...session
+            .getFollowUpMessages()
+            .map((text) => ({ kind: "followUp", text })),
         ...extraQueuedMessages,
     ];
 }
@@ -3608,7 +4134,8 @@ function historyMessages(session) {
                 messages.push({
                     ...historyMessage,
                     entryId,
-                    ...(previousMessage?.role === "assistant" && previousMessage.entryId !== undefined
+                    ...(previousMessage?.role === "assistant" &&
+                        previousMessage.entryId !== undefined
                         ? { previousAssistantEntryId: previousMessage.entryId }
                         : {}),
                     ...(messages.length > 0 ? { canFork: true } : {}),
@@ -3621,17 +4148,30 @@ function historyMessages(session) {
             continue;
         }
         if (entry["type"] === "custom_message" && entry["display"] === true) {
-            messages.push({ role: "custom", content: entry["content"], customType: entry["customType"], details: entry["details"] });
+            messages.push({
+                role: "custom",
+                content: entry["content"],
+                customType: entry["customType"],
+                details: entry["details"],
+            });
             previousMessage = { role: "custom", entryId: undefined };
             continue;
         }
         if (entry["type"] === "compaction") {
-            messages.push({ role: "system", source: "compaction", content: `Compacted history:\n\n${stringValue(entry["summary"])}` });
+            messages.push({
+                role: "system",
+                source: "compaction",
+                content: `Compacted history:\n\n${stringValue(entry["summary"])}`,
+            });
             previousMessage = { role: "system", entryId: undefined };
             continue;
         }
         if (entry["type"] === "branch_summary") {
-            messages.push({ role: "system", source: "branch_summary", content: `Branch summary:\n\n${stringValue(entry["summary"])}` });
+            messages.push({
+                role: "system",
+                source: "branch_summary",
+                content: `Branch summary:\n\n${stringValue(entry["summary"])}`,
+            });
             previousMessage = { role: "system", entryId: undefined };
         }
     }
@@ -3664,7 +4204,9 @@ function finalAssistantText(messages) {
             continue;
         const texts = [];
         for (const part of content) {
-            if (isRecord(part) && part["type"] === "text" && typeof part["text"] === "string")
+            if (isRecord(part) &&
+                part["type"] === "text" &&
+                typeof part["text"] === "string")
                 texts.push(part["text"]);
         }
         if (texts.length > 0)
@@ -3675,23 +4217,52 @@ function finalAssistantText(messages) {
 function toClientEvent(event) {
     const eventType = getString(event, "type");
     const assistantMessageEvent = getProperty(event, "assistantMessageEvent");
-    if (eventType === "message_update" && getString(assistantMessageEvent, "type") === "text_delta") {
-        return { type: "assistant.delta", text: getString(assistantMessageEvent, "delta") ?? "" };
+    if (eventType === "message_update" &&
+        getString(assistantMessageEvent, "type") === "text_delta") {
+        return {
+            type: "assistant.delta",
+            text: getString(assistantMessageEvent, "delta") ?? "",
+        };
     }
-    if (eventType === "message_update" && getString(assistantMessageEvent, "type") === "thinking_delta") {
-        return { type: "assistant.thinking.delta", text: getString(assistantMessageEvent, "delta") ?? "" };
+    if (eventType === "message_update" &&
+        getString(assistantMessageEvent, "type") === "thinking_delta") {
+        return {
+            type: "assistant.thinking.delta",
+            text: getString(assistantMessageEvent, "delta") ?? "",
+        };
     }
     if (eventType === "tool_execution_start") {
         const args = getProperty(event, "args");
-        return { type: "tool.start", toolName: getString(event, "toolName") ?? "", toolCallId: getString(event, "toolCallId") ?? "", summary: summarizeToolArgs(args), args };
+        return {
+            type: "tool.start",
+            toolName: getString(event, "toolName") ?? "",
+            toolCallId: getString(event, "toolCallId") ?? "",
+            summary: summarizeToolArgs(args),
+            args,
+        };
     }
     if (eventType === "tool_execution_update") {
         const partialResult = getProperty(event, "partialResult");
-        return { type: "tool.update", toolName: getString(event, "toolName") ?? "", toolCallId: getString(event, "toolCallId") ?? "", text: stringifyToolResult(partialResult), content: toolResultContent(partialResult), details: toolResultDetails(partialResult) };
+        return {
+            type: "tool.update",
+            toolName: getString(event, "toolName") ?? "",
+            toolCallId: getString(event, "toolCallId") ?? "",
+            text: stringifyToolResult(partialResult),
+            content: toolResultContent(partialResult),
+            details: toolResultDetails(partialResult),
+        };
     }
     if (eventType === "tool_execution_end") {
         const result = getProperty(event, "result");
-        return { type: "tool.end", toolName: getString(event, "toolName") ?? "", toolCallId: getString(event, "toolCallId") ?? "", text: stringifyToolResult(result), content: toolResultContent(result), details: toolResultDetails(result), isError: getBoolean(event, "isError") === true };
+        return {
+            type: "tool.end",
+            toolName: getString(event, "toolName") ?? "",
+            toolCallId: getString(event, "toolCallId") ?? "",
+            text: stringifyToolResult(result),
+            content: toolResultContent(result),
+            details: toolResultDetails(result),
+            isError: getBoolean(event, "isError") === true,
+        };
     }
     if (eventType === "agent_start")
         return { type: "agent.start" };
@@ -3699,7 +4270,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 };
+        return message === undefined
+            ? { type: "message.end" }
+            : { type: "message.end", message };
     }
     return { type: "pi.event", eventType: eventType ?? "unknown" };
 }
@@ -3712,13 +4285,18 @@ function summarizeToolArgs(args) {
     const path = getString(args, "path");
     if (path !== undefined)
         return path;
-    if (typeof args["oldText"] === "string" && typeof args["newText"] === "string")
+    if (typeof args["oldText"] === "string" &&
+        typeof args["newText"] === "string")
         return "edit text replacement";
     const edits = args["edits"];
     if (Array.isArray(edits))
         return `${String(edits.length)} edit${edits.length === 1 ? "" : "s"}`;
-    const entries = Object.entries(args).filter(([, value]) => value != null).slice(0, 3);
-    return entries.map(([key, value]) => `${key}: ${shortToolValue(value)}`).join(" · ");
+    const entries = Object.entries(args)
+        .filter(([, value]) => value != null)
+        .slice(0, 3);
+    return entries
+        .map(([key, value]) => `${key}: ${shortToolValue(value)}`)
+        .join(" · ");
 }
 function shortToolValue(value) {
     if (typeof value === "string")
@@ -3751,11 +4329,16 @@ function stringifyToolResult(result) {
     if (typeof result === "string")
         return result;
     if (Array.isArray(result))
-        return result.map(stringifyToolResult).filter((text) => text !== "").join("\n");
+        return result
+            .map(stringifyToolResult)
+            .filter((text) => text !== "")
+            .join("\n");
     if (isRecord(result)) {
         if (getString(result, "type") === "image")
             return "[image]";
-        const text = getString(result, "text") ?? getString(result, "content") ?? getString(result, "output");
+        const text = getString(result, "text") ??
+            getString(result, "content") ??
+            getString(result, "output");
         if (text !== undefined)
             return text;
         const content = getProperty(result, "content");
@@ -3781,7 +4364,9 @@ function getBoolean(value, key) {
 }
 function providerOutputTokens(message) {
     const output = getProperty(getProperty(message, "usage"), "output");
-    return typeof output === "number" && Number.isFinite(output) && output > 0 ? output : undefined;
+    return typeof output === "number" && Number.isFinite(output) && output > 0
+        ? output
+        : undefined;
 }
 /** Match Pi Web's 4-characters-per-token live approximation. */
 function estimatedOutputTokens(message) {
@@ -3816,7 +4401,9 @@ function stringifyPrimitive(value) {
         return "";
     if (typeof value === "string")
         return value;
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+    if (typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint")
         return String(value);
     return "";
 }