@progmruansilva/omp-web 1.202608.0

package/dist/server/sessions/piSessionService.js

@@ -0,0 +1,2401 @@
+import { statSync } from "node:fs";
+import { open, readFile, writeFile } from "node:fs/promises";
+import { createAgentSession, getAgentDir, SessionManager, Settings, } from "@oh-my-pi/pi-coding-agent";
+import { EditTool } from "@oh-my-pi/pi-coding-agent/edit";
+import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
+import { BUILTIN_COMMANDS } from "./builtinCommands.js";
+import { SessionCommandService } from "./sessionCommandService.js";
+import { SessionArchiveStore } from "./sessionArchiveStore.js";
+import { findArchiveCandidateByIdOrPrefix, planSessionArchiveTree } from "./sessionArchiveTree.js";
+import { fallbackSessionName, generateShortSessionName } from "./sessionNameGenerator.js";
+import { computeEditPreview } from "./editPreview.js";
+import { createPiSessionManagerGateway } from "./piSessionManagerGateway.js";
+import { attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachmentService.js";
+import { parsePromptAttachments } from "../../shared/promptAttachments.js";
+import { isKnownThinkingLevel } from "../../shared/thinkingLevels.js";
+import { cwdPathsEqual } from "../workingDirectory.js";
+import { errorMessage, isRecord } from "../utils.js";
+import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
+import { createSubsessionToolDefinitions } from "./spawnSubsessionTool.js";
+import { buildTranscriptView } from "./subsessionTranscript.js";
+import { planSessionCleanup, summarizeSessionCleanupExecution } from "./sessionCleanup.js";
+import { SchedulePromptService } from "./schedulePrompt/schedulePromptService.js";
+import { createSchedulePromptToolDefinition } from "./schedulePrompt/tool.js";
+const noopLogger = { info() { } };
+function noop() {
+    // Intentionally empty default unsubscribe callback.
+}
+function spawnTargetError(decision) {
+    if (decision.reason === "not-registered")
+        return new Error("Spawning session is not in a registered project");
+    return new Error(`cwd must be a workspace of this project. Allowed: ${decision.allowedCwds.join(", ")}`);
+}
+function authLossWarningKey(sessionId, provider, modelId) {
+    return `${sessionId}:${provider}/${modelId}`;
+}
+function sessionIdFromLookup(ref) {
+    return typeof ref === "string" ? ref : ref.id;
+}
+function isPiSessionRef(ref) {
+    return typeof ref !== "string";
+}
+function lookupMatchesActiveSession(ref, active) {
+    return !isPiSessionRef(ref) || cwdPathsEqual(active.runtime.cwd, ref.cwd);
+}
+function requirePromptText(value) {
+    if (typeof value !== "string")
+        throw new Error("Prompt text is required");
+    return value;
+}
+function parsePromptStreamingBehavior(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "steer" || value === "followUp")
+        return value;
+    throw new Error('Prompt streamingBehavior must be "steer" or "followUp"');
+}
+class DefaultPiAgentSession {
+    constructor(ompSession, piSessionManager) {
+        this.ompSession = ompSession;
+        this.piSessionManager = piSessionManager;
+        this._isBashRunning = false;
+    }
+    get modelRegistry() { return this.ompSession.modelRegistry; }
+    get sessionManager() { return this.piSessionManager; }
+    get scopedModels() {
+        /* eslint-disable @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unnecessary-type-assertion */
+        return this.ompSession.scopedModels;
+        /* eslint-enable @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unnecessary-type-assertion */
+    }
+    get sessionId() { return this.ompSession.sessionId; }
+    get sessionFile() { return this.ompSession.sessionFile; }
+    get sessionName() { return this.ompSession.sessionName; }
+    get messages() { return this.ompSession.messages; }
+    get model() { return this.ompSession.model; }
+    get thinkingLevel() {
+        const configured = this.ompSession.configuredThinkingLevel();
+        return configured !== undefined && isKnownThinkingLevel(configured) ? configured : "off";
+    }
+    get isStreaming() { return this.ompSession.isStreaming; }
+    get isCompacting() { return this.ompSession.isCompacting; }
+    get isBashRunning() { return this._isBashRunning; }
+    get pendingMessageCount() { return this.ompSession.queuedMessageCount; }
+    get extensionRunner() {
+        const runner = this.ompSession.extensionRunner;
+        return { getRegisteredCommands: () => runner?.getRegisteredCommands() ?? [] };
+    }
+    get promptTemplates() { return this.ompSession.promptTemplates; }
+    get resourceLoader() {
+        return {
+            getSkills: () => ({
+                skills: this.ompSession.skills.map((s) => ({ name: s.name, description: s.description })),
+            }),
+        };
+    }
+    getPlanModeState() {
+        const fn = Reflect.get(this.ompSession, "getPlanModeState");
+        if (typeof fn !== "function")
+            return undefined;
+        const res = fn.call(this.ompSession);
+        return isRecord(res) && typeof res.enabled === "boolean" && typeof res.planFilePath === "string"
+            ? { enabled: res.enabled, planFilePath: res.planFilePath }
+            : undefined;
+    }
+    setPlanModeState(state) {
+        const fn = Reflect.get(this.ompSession, "setPlanModeState");
+        if (typeof fn === "function")
+            fn.call(this.ompSession, state);
+    }
+    toggleAdvisorEnabled() {
+        const fn = Reflect.get(this.ompSession, "toggleAdvisorEnabled");
+        if (typeof fn !== "function")
+            return false;
+        const res = fn.call(this.ompSession);
+        return typeof res === "boolean" ? res : false;
+    }
+    setAdvisorEnabled(enabled) {
+        const fn = Reflect.get(this.ompSession, "setAdvisorEnabled");
+        if (typeof fn !== "function")
+            return false;
+        const res = fn.call(this.ompSession, enabled);
+        return typeof res === "boolean" ? res : false;
+    }
+    get agent() {
+        return { streamFn: this.ompSession.agent.streamFn };
+    }
+    subscribe(listener) {
+        return this.ompSession.subscribe(listener);
+    }
+    bindExtensions() {
+        // Handled via onExtensionError in createAgentSession options
+        return Promise.resolve();
+    }
+    async compact(instructions) {
+        const result = await this.ompSession.compact(instructions);
+        return { summary: result.summary, tokensBefore: 0 };
+    }
+    getUserMessagesForForking() {
+        return this.ompSession.getUserMessagesForBranching();
+    }
+    getSessionStats() {
+        const stats = this.ompSession.getSessionStats();
+        return {
+            sessionId: stats.sessionId,
+            totalMessages: stats.totalMessages,
+            userMessages: stats.userMessages,
+            assistantMessages: stats.assistantMessages,
+            toolCalls: stats.toolCalls,
+            tokens: stats.tokens,
+            cost: stats.cost,
+        };
+    }
+    async reload() {
+        // omp sessions manage persistence internally
+    }
+    getContextUsage() {
+        return undefined;
+    }
+    async prompt(text, options) {
+        await this.ompSession.prompt(text, options);
+    }
+    async sendCustomMessage(message, options) {
+        await this.ompSession.sendCustomMessage(message, options);
+    }
+    async executeBash(command, onChunk, options) {
+        this._isBashRunning = true;
+        try {
+            const result = await this.ompSession.executeBash(command, onChunk, options);
+            return {
+                output: result.output,
+                exitCode: result.exitCode,
+                cancelled: result.cancelled,
+                truncated: result.truncated,
+            };
+        }
+        finally {
+            this._isBashRunning = false;
+        }
+    }
+    async abort() {
+        await this.ompSession.abort();
+    }
+    clearQueue() {
+        const result = this.ompSession.clearQueue();
+        const extractText = (m) => {
+            if (typeof m === "string")
+                return m;
+            if (isRecord(m) && typeof m["text"] === "string")
+                return m["text"];
+            return "";
+        };
+        return {
+            steering: result.steering.map(extractText),
+            followUp: result.followUp.map(extractText),
+        };
+    }
+    getSteeringMessages() {
+        return this.ompSession.getQueuedMessages().steering;
+    }
+    getFollowUpMessages() {
+        return this.ompSession.getQueuedMessages().followUp;
+    }
+    async setModel(model) {
+        await this.ompSession.setModel(model);
+    }
+    setThinkingLevel(level) {
+        const setLevel = Reflect.get(this.ompSession, "setThinkingLevel");
+        if (typeof setLevel === "function") {
+            Reflect.apply(setLevel, this.ompSession, [level === "off" ? undefined : level]);
+        }
+    }
+    async cycleModel(direction) {
+        const result = await this.ompSession.cycleModel(direction);
+        if (result === undefined)
+            return undefined;
+        return { model: result.model };
+    }
+    getAvailableThinkingLevels() {
+        const efforts = this.ompSession.getAvailableThinkingLevels();
+        const levels = ["off"];
+        for (const effort of efforts) {
+            if (isKnownThinkingLevel(effort))
+                levels.push(effort);
+        }
+        return levels;
+    }
+    cycleThinkingLevel() {
+        const levels = this.ompSession.getAvailableThinkingLevels();
+        const fullCycle = ["off"];
+        for (const level of levels) {
+            if (isKnownThinkingLevel(level))
+                fullCycle.push(level);
+        }
+        const current = this.ompSession.configuredThinkingLevel();
+        if (current !== undefined && !isKnownThinkingLevel(current))
+            return undefined;
+        const currentLevel = current !== undefined && isKnownThinkingLevel(current) ? current : "off";
+        const currentIndex = fullCycle.indexOf(currentLevel);
+        if (currentIndex === -1)
+            return undefined;
+        const nextIndex = (currentIndex + 1) % fullCycle.length;
+        const next = fullCycle[nextIndex];
+        if (next === undefined)
+            return undefined;
+        this.setThinkingLevel(next);
+        return next;
+    }
+    setSessionName(name) {
+        void this.ompSession.setSessionName(name);
+    }
+}
+class DefaultPiSessionRuntime {
+    constructor(session, cwd, result) {
+        this.result = result;
+        this.rebindSessionCallback = undefined;
+        this.session = session;
+        this.cwd = cwd;
+        this.ompSession = result.session;
+    }
+    setRebindSession(rebindSession) {
+        this.rebindSessionCallback = rebindSession;
+    }
+    async fork(entryId) {
+        return this.ompSession.branch(entryId);
+    }
+    async dispose() {
+        await this.ompSession.dispose();
+    }
+}
+function defaultCreateAgentRuntime(createRuntime, options) {
+    if (createRuntime === undefined)
+        throw new Error("Runtime factory is required");
+    return createRuntime(options);
+}
+function createDefaultRuntimeFactory(authStorage, modelRegistry, schedulePromptService, spawn, subsessions) {
+    return async ({ cwd, agentDir, sessionManager, initialModel }) => {
+        if (!(sessionManager instanceof SessionManager))
+            throw new Error("Default runtime creation requires an SDK SessionManager");
+        const model = initialModel;
+        const sessionId = sessionManager.getSessionId();
+        // Deferred refs — populated after piSession is created. The getters are
+        // only called at tool-execution time, long after these are assigned.
+        const scheduleStorageRef = {};
+        const scheduleSchedulerRef = {};
+        const scheduleStorage = () => {
+            if (scheduleStorageRef.storage === undefined)
+                throw new Error("Schedule storage uninitialized");
+            return scheduleStorageRef.storage;
+        };
+        const scheduleScheduler = () => {
+            if (scheduleSchedulerRef.scheduler === undefined)
+                throw new Error("Schedule scheduler uninitialized");
+            return scheduleSchedulerRef.scheduler;
+        };
+        const customTools = [
+            createSchedulePromptToolDefinition(sessionId, scheduleStorage, scheduleScheduler),
+            createOmpWebEditToolDefinition(cwd),
+            ...(spawn === undefined ? [] : [createSpawnSessionToolDefinition(cwd, { spawn })]),
+            ...(subsessions === undefined ? [] : createSubsessionToolDefinitions(cwd, subsessions)),
+        ];
+        const result = await createAgentSession({
+            cwd,
+            agentDir,
+            authStorage,
+            modelRegistry,
+            sessionManager,
+            hasUI: true,
+            customTools,
+            ...(model === undefined ? {} : { model }),
+        });
+        const piSession = new DefaultPiAgentSession(result.session, sessionManager);
+        const started = schedulePromptService.startForSession(sessionId, cwd, (text) => piSession.prompt(text, { streamingBehavior: "followUp" }));
+        scheduleStorageRef.storage = started.storage;
+        scheduleSchedulerRef.scheduler = started.scheduler;
+        return new DefaultPiSessionRuntime(piSession, cwd, result);
+    };
+}
+function isEditReplacement(x) {
+    return isRecord(x);
+}
+function isEditParams(params) {
+    return isRecord(params) && typeof params["path"] === "string" && Array.isArray(params["edits"]);
+}
+function createOmpWebEditToolDefinition(cwd) {
+    const editTool = new EditTool({
+        cwd,
+        hasUI: true,
+        getSessionFile: () => null,
+        getSessionSpawns: () => null,
+        settings: Settings.isolated({}),
+    });
+    const def = {
+        name: editTool.name,
+        label: editTool.label,
+        description: editTool.description,
+        parameters: editTool.parameters,
+        async execute(toolCallId, params, signal, onUpdate) {
+            if (isRecord(params) && typeof params["path"] === "string" && params["path"].length > 0) {
+                const path = params["path"];
+                const rawEdits = Array.isArray(params["edits"]) ? params["edits"] : [];
+                const edits = [];
+                for (const item of rawEdits) {
+                    if (isEditReplacement(item))
+                        edits.push(item);
+                }
+                const preview = await computeEditPreview(path, edits, cwd);
+                if (signal?.aborted !== true) {
+                    onUpdate?.({ content: [{ type: "text", text: "Edit preview computed." }], details: { preview } });
+                }
+            }
+            const execute = Reflect.get(editTool, "execute");
+            const executeParams = isEditParams(params) ? params : { path: "", edits: [] };
+            const res = execute.call(editTool, toolCallId, executeParams, signal, onUpdate);
+            return res;
+        },
+    };
+    return def;
+}
+export class PiSessionService {
+    constructor(events, deps = {}) {
+        this.events = events;
+        this.active = new Map();
+        this.activities = new Map();
+        this.compactionPromptQueues = new Map();
+        this.schedulePromptService = new SchedulePromptService();
+        this.compactionDrainTimers = new Map();
+        this.authLossWarnings = new Set();
+        /** Tracked subsession id -> the parent session id that spawned it. */
+        this.subsessionParents = new Map();
+        /** Parent session id -> the set of tracked subsession ids it spawned. */
+        this.subsessionChildren = new Map();
+        /** Tracked subsession id -> persisted recovery details for the child. */
+        this.subsessionLinks = new Map();
+        /** Parent id/file identities whose persisted links have already been loaded. */
+        this.subsessionHydratedParents = new Set();
+        /**
+         * Tracked subsession id -> whether a completion notification is armed.
+         * Armed when the child starts working; firing on completion disarms it so a
+         * child that works again (and stops again) notifies the parent each time.
+         */
+        this.subsessionNotifyArmed = new Map();
+        /** Session ids for which we've already sent a "work complete" push notification. */
+        this.notifiedWorkComplete = new Set();
+        this.archiveStore = deps.archiveStore ?? new SessionArchiveStore();
+        this.agentDir = deps.agentDir ?? getAgentDir();
+        this.sessionManager = deps.sessionManager ?? createPiSessionManagerGateway({ agentDir: this.agentDir });
+        this.modelRegistry = deps.modelRegistry;
+        this.spawnTargets = deps.spawnTargets;
+        this.logger = deps.logger ?? noopLogger;
+        this.now = deps.now ?? (() => new Date());
+        this.pushService = deps.pushService;
+        // 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
+            ?? (this.modelRegistry !== undefined
+                ? createDefaultRuntimeFactory(this.modelRegistry.authStorage, this.modelRegistry, this.schedulePromptService, 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),
+                })
+                : undefined);
+        this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
+        this.workspaceActivity = deps.workspaceActivity;
+        this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
+        this.commandService = new SessionCommandService((sessionId) => this.getActive(sessionId), (sessionId, text) => this.prompt(sessionId, text, undefined, undefined, { echoUserMessage: false }), events, {
+            onCompactionStart: (session) => {
+                this.publishActivity(session, "compacting", "active");
+                this.publishStatus(session);
+            },
+            onCompactionEnd: (session, result, detail) => {
+                this.publishActivity(session, result === "success" ? "compaction complete" : "compaction failed", result === "success" ? "idle" : "error", detail);
+                this.publishStatus(session);
+            },
+            reloadSession: (session) => this.reloadSessionRuntime(session),
+        }, { listSessionNames: (cwd) => this.listSessionNames(cwd) });
+    }
+    activeCount() {
+        return this.active.size;
+    }
+    async cleanupPreview(request) {
+        return previewResponseFromPlan(await this.cleanupPlan(request));
+    }
+    async cleanup(request) {
+        const plan = await this.cleanupPlan(request);
+        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 = [];
+        const deleteRecords = [];
+        const readyDeleteRecords = [];
+        const skippedBusySessionIds = new Set(plan.skippedBusySessionIds);
+        for (const input of plan.archiveInputs) {
+            if (this.activeSessionHasWork(input.sessionId)) {
+                skippedBusySessionIds.add(input.sessionId);
+                continue;
+            }
+            await this.closeActive(input.sessionId);
+            readyArchiveInputs.push(input);
+        }
+        await this.archiveStoreArchiveMany(readyArchiveInputs);
+        archiveInputs.push(...readyArchiveInputs);
+        for (const record of plan.deleteRecords) {
+            if (this.activeSessionHasWork(record.sessionId)) {
+                skippedBusySessionIds.add(record.sessionId);
+                continue;
+            }
+            await this.closeActive(record.sessionId);
+            readyDeleteRecords.push(record);
+        }
+        await this.ensureArchivedRecordsMoved(readyDeleteRecords);
+        const deletedSessionIds = new Set(await this.archiveStoreDeleteArchivedMany(readyDeleteRecords.map((record) => record.sessionId)));
+        deleteRecords.push(...readyDeleteRecords.filter((record) => deletedSessionIds.has(record.sessionId)));
+        return summarizeSessionCleanupExecution({
+            archiveInputs,
+            deleteRecords,
+            thresholds: plan.thresholds,
+            generatedAt: plan.generatedAt,
+            skippedBusySessionIds: [...skippedBusySessionIds],
+        });
+    }
+    async dispose() {
+        this.schedulePromptService.dispose();
+        clearInterval(this.heartbeat);
+        this.clearCompactionDrainTimers();
+        const activeSessions = Array.from(new Set(this.active.values()));
+        this.active.clear();
+        this.activities.clear();
+        this.compactionPromptQueues.clear();
+        this.authLossWarnings.clear();
+        this.subsessionParents.clear();
+        this.subsessionChildren.clear();
+        this.subsessionLinks.clear();
+        this.subsessionHydratedParents.clear();
+        this.subsessionNotifyArmed.clear();
+        await Promise.all(activeSessions.map(async (active) => {
+            active.unsubscribe();
+            this.workspaceActivity?.removeSession(active.runtime.session.sessionId, active.runtime.session.sessionManager.getCwd());
+            await active.runtime.session.abort();
+            await active.runtime.dispose();
+        }));
+    }
+    async list(cwd) {
+        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.list(cwd), this.archiveStore.list()]);
+        const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+        const archivedForCwd = await Promise.all(archivedRecords
+            .filter((record) => record.cwd === cwd)
+            .map((record) => this.ensureArchivedSessionMoved(record, sessionsById.get(record.sessionId))));
+        const archivedById = new Map(archivedForCwd.map((record) => [record.sessionId, record]));
+        const unarchivedSessions = sessions.filter((session) => !archivedById.has(session.id)).map(clientSessionFromListEntry);
+        this.workspaceActivity?.reconcileSessionActivity(cwd, this.reconcilableSessionIds(cwd, unarchivedSessions.map((session) => session.id), archivedById));
+        const archivedSessions = archivedForCwd
+            .sort(compareArchivedRecords)
+            .map((record) => clientSessionFromArchivedRecord(record, sessionsById.get(record.sessionId)))
+            .filter(isDefined);
+        return [...unarchivedSessions, ...archivedSessions];
+    }
+    async start(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 });
+        const { session } = active.runtime;
+        const created = {
+            id: session.sessionId,
+            path: session.sessionFile ?? "",
+            cwd,
+            persisted: sessionFileExists(session.sessionFile),
+            created: new Date().toISOString(),
+            modified: new Date().toISOString(),
+            messageCount: session.messages.length,
+            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 }),
+        };
+        // Broadcast so other clients (and the spawning agent's UI) can add the new
+        // session to their list without a manual reload.
+        this.events.publishGlobal({ type: "session.created", session: created });
+        return created;
+    }
+    /**
+     * Start a new session on behalf of a LLM and deliver an initial prompt to it.
+     * The target cwd is constrained to a workspace of the same registered project
+     * as the spawning session so the new session is visible in the web UI.
+     */
+    async spawnSession(input) {
+        if (this.spawnTargets === undefined)
+            throw new Error("Spawning sessions is disabled");
+        const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
+        if (!decision.allowed)
+            throw spawnTargetError(decision);
+        const created = await this.start(decision.cwd, input.model === undefined ? {} : { initialModel: input.model });
+        await this.prompt(created.id, input.prompt);
+        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 };
+    }
+    /**
+     * Start a *tracked* child session on behalf of a LLM. Identical to
+     * {@link spawnSession} in how the target cwd is resolved, but the child
+     * records its parent (so it shows in the session tree) and is registered so
+     * the parent is notified when it stops working and can inspect it later.
+     */
+    async spawnSubsession(input) {
+        if (this.spawnTargets === undefined)
+            throw new Error("Spawning sessions is disabled");
+        const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
+        if (!decision.allowed)
+            throw spawnTargetError(decision);
+        const created = await this.start(decision.cwd, {
+            ...(input.parentSessionFile === undefined ? {} : { parentSession: input.parentSessionFile }),
+            ...(input.model === undefined ? {} : { initialModel: input.model }),
+        });
+        const parentSessionFile = nonEmptyString(input.parentSessionFile);
+        const link = {
+            parentSessionId: input.parentSessionId,
+            childSessionId: created.id,
+            ...(created.path === "" ? {} : { childSessionFile: created.path }),
+            ...(parentSessionFile === undefined ? {} : { parentSessionFile }),
+            cwd: decision.cwd,
+        };
+        this.registerVerifiedSubsession(link);
+        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");
+        return { sessionId: created.id, cwd: decision.cwd };
+    }
+    /** Summaries of the tracked subsessions spawned by `parentSessionId`. */
+    async listSubsessions(parentSessionId, parentSessionFile) {
+        const parentFile = nonEmptyString(parentSessionFile);
+        await this.hydrateSubsessionsForParent(parentSessionId, parentFile);
+        const childIds = this.subsessionChildren.get(parentSessionId);
+        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)) })));
+    }
+    /** Status and final result of a subsession, scoped to the caller's children. */
+    async checkSubsession(parentSessionId, sessionId, parentSessionFile) {
+        const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile);
+        const messages = historyMessages(session);
+        return {
+            sessionId,
+            cwd: session.sessionManager.getCwd(),
+            status: this.subsessionStatus(session),
+            finalText: finalAssistantText(messages),
+            messageCount: messages.length,
+        };
+    }
+    /** Filtered, paginated transcript of a subsession, scoped to the caller's children. */
+    async readSubsession(parentSessionId, sessionId, query, parentSessionFile) {
+        const session = await this.openSubsession(parentSessionId, sessionId, parentSessionFile);
+        const view = buildTranscriptView(historyMessages(session), query);
+        return {
+            sessionId,
+            cwd: session.sessionManager.getCwd(),
+            status: this.subsessionStatus(session),
+            ...view,
+        };
+    }
+    /** Open a session after verifying it is one of the caller's tracked children. */
+    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)) {
+            throw new Error(`Session ${sessionId} is not one of your subsessions`);
+        }
+        return this.getOrOpenTrackedSubsession(sessionId);
+    }
+    subsessionLinkBelongsToParent(parentSessionId, parentSessionFile, childSessionId) {
+        const link = this.subsessionLinks.get(childSessionId);
+        if (link?.parentSessionId !== parentSessionId)
+            return false;
+        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;
+    }
+    activeParentForSubsessionLink(link) {
+        const active = this.active.get(link.parentSessionId);
+        if (active === undefined)
+            return undefined;
+        return activeSessionFileMatches(active, link.parentSessionFile) ? active : undefined;
+    }
+    subsessionLinkForActiveChild(session) {
+        const childId = session.sessionId;
+        const parentId = this.subsessionParents.get(childId);
+        const link = this.subsessionLinks.get(childId);
+        if (parentId === undefined || link?.parentSessionId !== parentId)
+            return undefined;
+        return sessionFileMatches(session, link.childSessionFile) ? link : undefined;
+    }
+    registerVerifiedSubsession(link) {
+        const { childSessionId, parentSessionId } = link;
+        const previousParentId = this.subsessionParents.get(childSessionId);
+        if (previousParentId !== undefined && previousParentId !== parentSessionId) {
+            const previousChildren = this.subsessionChildren.get(previousParentId);
+            previousChildren?.delete(childSessionId);
+            if (previousChildren?.size === 0)
+                this.subsessionChildren.delete(previousParentId);
+        }
+        this.subsessionParents.set(childSessionId, parentSessionId);
+        const children = this.subsessionChildren.get(parentSessionId) ?? new Set();
+        children.add(childSessionId);
+        this.subsessionChildren.set(parentSessionId, children);
+        this.subsessionLinks.set(childSessionId, link);
+        if (!this.subsessionNotifyArmed.has(childSessionId))
+            this.subsessionNotifyArmed.set(childSessionId, false);
+    }
+    unregisterSubsession(childSessionId) {
+        const parentSessionId = this.subsessionParents.get(childSessionId);
+        this.subsessionParents.delete(childSessionId);
+        this.subsessionLinks.delete(childSessionId);
+        this.subsessionNotifyArmed.delete(childSessionId);
+        if (parentSessionId === undefined)
+            return;
+        const children = this.subsessionChildren.get(parentSessionId);
+        children?.delete(childSessionId);
+        if (children?.size === 0)
+            this.subsessionChildren.delete(parentSessionId);
+    }
+    persistSubsessionLink(link) {
+        const parent = this.activeParentForSubsessionLink(link)?.runtime.session;
+        if (parent === undefined)
+            return;
+        if (parent.sessionManager.appendCustomEntry === undefined)
+            return;
+        try {
+            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");
+        }
+    }
+    persistSubsessionChildMarker(parentSessionId, childSessionId) {
+        const child = this.active.get(childSessionId)?.runtime.session;
+        if (child === undefined)
+            return;
+        if (child.sessionManager.appendCustomEntry === undefined)
+            return;
+        try {
+            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");
+        }
+    }
+    async hydrateSubsessionsForParent(parentSessionId, parentSessionFile) {
+        const hydrationKey = subsessionHydratedParentKey(parentSessionId, parentSessionFile);
+        if (this.subsessionHydratedParents.has(hydrationKey))
+            return;
+        const activeParent = this.active.get(parentSessionId);
+        if (activeParent !== undefined && (parentSessionFile === undefined || activeSessionFileMatches(activeParent, parentSessionFile))) {
+            const activeParentFile = nonEmptyString(activeParent.runtime.session.sessionFile);
+            await this.registerPersistedSubsessionLinks(parentSessionId, activeParent.runtime.session.sessionManager, activeParentFile);
+            this.subsessionHydratedParents.add(hydrationKey);
+            return;
+        }
+        if (parentSessionFile === undefined)
+            return;
+        if ((await readSessionHeaderSummary(parentSessionFile))?.id !== parentSessionId) {
+            this.subsessionHydratedParents.add(hydrationKey);
+            return;
+        }
+        let parentManager;
+        try {
+            parentManager = await this.sessionManager.open(parentSessionFile);
+        }
+        catch {
+            this.subsessionHydratedParents.add(hydrationKey);
+            return;
+        }
+        await this.registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile);
+        this.subsessionHydratedParents.add(hydrationKey);
+    }
+    async registerPersistedSubsessionLinks(parentSessionId, parentManager, parentSessionFile) {
+        // Parent custom links are the authoritative recovery record: verify the
+        // exact live child file/header before tracking.
+        const entries = parentManager.getEntries?.() ?? parentManager.getBranch();
+        for (const entry of entries) {
+            const link = parsePersistedParentSubsessionLink(entry);
+            if (link === undefined)
+                continue;
+            const verified = await this.verifiedSubsessionLinkFromParentLink(parentSessionId, parentSessionFile, link);
+            if (verified === undefined)
+                continue;
+            this.registerVerifiedSubsession(verified);
+        }
+    }
+    async verifiedSubsessionLinkFromParentLink(parentSessionId, parentSessionFile, link) {
+        if (parentSessionFile === undefined)
+            return undefined;
+        if (link.spawnedBySessionId !== parentSessionId)
+            return undefined;
+        if (!(await this.parentLinkHasValidChildTarget(parentSessionFile, link)))
+            return undefined;
+        return trackedSubsessionLinkFromParentLink(parentSessionId, link, parentSessionFile);
+    }
+    async parentLinkHasValidChildTarget(parentSessionFile, link) {
+        return link.spawnedSessionFile !== undefined
+            && await sessionFileHeaderMatches(link.spawnedSessionFile, { sessionId: link.spawnedSessionId, parentSessionFile });
+    }
+    async recoverSubsessionTrackingForOpenedSession(session) {
+        const link = await this.verifiedSubsessionLinkFromOpenedChild(session);
+        if (link === undefined)
+            return;
+        this.registerVerifiedSubsession(link);
+    }
+    async verifiedSubsessionLinkFromOpenedChild(session) {
+        // Child markers are only hints; the current child header and reciprocal
+        // parent custom link must agree on the exact ids and files before relinking.
+        const entries = session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch();
+        let marker;
+        for (const entry of entries) {
+            const parsed = parsePersistedChildSubsessionLink(entry);
+            if (parsed?.spawnedSessionId === session.sessionId)
+                marker = parsed;
+        }
+        if (marker === undefined)
+            return undefined;
+        const childSessionFile = nonEmptyString(session.sessionFile);
+        if (childSessionFile === undefined)
+            return undefined;
+        const childHeader = await readSessionHeaderSummary(childSessionFile);
+        if (childHeader?.id !== session.sessionId)
+            return undefined;
+        const parentSessionFile = nonEmptyString(childHeader.parentSession);
+        if (parentSessionFile === undefined)
+            return undefined;
+        const parentHeader = await readSessionHeaderSummary(parentSessionFile);
+        if (parentHeader?.id !== marker.spawnedBySessionId)
+            return undefined;
+        const parentLink = await this.findReciprocalParentSubsessionLink(parentSessionFile, marker.spawnedBySessionId, session.sessionId, childSessionFile);
+        if (parentLink === undefined)
+            return undefined;
+        return {
+            parentSessionId: marker.spawnedBySessionId,
+            childSessionId: session.sessionId,
+            childSessionFile,
+            parentSessionFile,
+            cwd: parentLink.cwd ?? session.sessionManager.getCwd(),
+        };
+    }
+    async findReciprocalParentSubsessionLink(parentSessionFile, parentSessionId, childSessionId, childSessionFile) {
+        let parentManager;
+        try {
+            parentManager = await this.sessionManager.open(parentSessionFile);
+        }
+        catch {
+            return undefined;
+        }
+        const entries = parentManager.getEntries?.() ?? parentManager.getBranch();
+        for (const entry of entries) {
+            const link = parsePersistedParentSubsessionLink(entry);
+            if (link === undefined)
+                continue;
+            if (link.spawnedBySessionId !== parentSessionId || link.spawnedSessionId !== childSessionId)
+                continue;
+            if (link.spawnedSessionFile === undefined || !sessionPathsEqual(link.spawnedSessionFile, childSessionFile))
+                continue;
+            return link;
+        }
+        return undefined;
+    }
+    async getOrOpenTrackedSubsession(sessionId) {
+        const link = this.subsessionLinks.get(sessionId);
+        if (link === undefined)
+            throw new Error("Session not found");
+        const active = this.activeChildForSubsessionLink(link);
+        if (active !== undefined)
+            return active.runtime.session;
+        if (link.childSessionFile !== undefined) {
+            if (!(await sessionFileHeaderMatches(link.childSessionFile, { sessionId, parentSessionFile: link.parentSessionFile })))
+                throw new Error("Session not found");
+            const sessionManager = await this.sessionManager.open(link.childSessionFile);
+            return (await this.create(sessionManager, link.cwd ?? sessionManager.getCwd())).runtime.session;
+        }
+        throw new Error("Session not found");
+    }
+    async subsessionSummaryFields(childSessionId) {
+        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) };
+        }
+        if (link?.childSessionFile !== undefined && (await sessionFileHeaderMatches(link.childSessionFile, { sessionId: childSessionId, parentSessionFile: link.parentSessionFile }))) {
+            return { cwd: link.cwd ?? "", status: "idle" };
+        }
+        if (link?.cwd !== undefined)
+            return { cwd: link.cwd, status: "unknown" };
+        return { cwd: "", status: "unknown" };
+    }
+    subsessionStatus(session) {
+        if (this.hasActiveWork(session))
+            return "working";
+        if (this.activities.get(session.sessionId)?.phase === "error")
+            return "error";
+        return "idle";
+    }
+    /**
+     * Drive parent notifications from a tracked child's status. Arms a pending
+     * notification while the child is working, and when it stops fires a single
+     * follow-up message to the parent via {@link prompt} (which queues if the
+     * parent is busy and delivers immediately when it is idle).
+     */
+    updateSubsessionTracking(session) {
+        const link = this.subsessionLinkForActiveChild(session);
+        if (link === undefined)
+            return;
+        const childId = link.childSessionId;
+        if (this.hasActiveWork(session)) {
+            this.subsessionNotifyArmed.set(childId, true);
+            return;
+        }
+        if (this.subsessionNotifyArmed.get(childId) !== true)
+            return;
+        this.subsessionNotifyArmed.set(childId, false);
+        const status = this.activities.get(childId)?.phase === "error" ? "error" : "idle";
+        const finalText = finalAssistantText(historyMessages(session));
+        const preview = finalText === "" ? "(no output)" : truncateForNotification(finalText);
+        const text = `Subsession ${childId} stopped working (status: ${status}). Latest output:\n\n${preview}\n\nUse check_subsession with sessionId "${childId}" for its status and latest output, or read_subsession to look through its full transcript.`;
+        void this.notifyParentOfSubsession(link.parentSessionId, childId, text);
+    }
+    async getOrOpenParentForSubsession(parentSessionId, childSessionId) {
+        const link = this.subsessionLinks.get(childSessionId);
+        if (link?.parentSessionId !== parentSessionId)
+            throw new Error(`Parent session ${parentSessionId} is not available for subsession notification`);
+        const active = this.activeParentForSubsessionLink(link);
+        if (active !== undefined)
+            return active.runtime.session;
+        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) {
+            throw new Error(`Parent session ${parentSessionId} is not available for subsession notification`);
+        }
+        const sessionManager = await this.sessionManager.open(parentSessionFile);
+        return (await this.create(sessionManager, sessionManager.getCwd())).runtime.session;
+    }
+    /**
+     * Deliver a subsession-completion notice to the parent as a system-authored
+     * custom message rather than a user message, so it is not attributed to the
+     * human in the transcript. It still wakes an idle parent (`triggerTurn`) and
+     * queues behind in-flight work (`deliverAs: "followUp"`), preserving the
+     * established "queue if busy, send and act if idle" behavior.
+     */
+    async notifyParentOfSubsession(parentId, childId, text) {
+        try {
+            const session = await this.getOrOpenParentForSubsession(parentId, childId);
+            await session.sendCustomMessage({ customType: SUBSESSION_NOTIFICATION_CUSTOM_TYPE, content: text, display: true, details: { sessionId: childId } }, { triggerTurn: true, deliverAs: "followUp" });
+            this.publishStatus(session);
+        }
+        catch (error) {
+            this.logger.info({ parentSessionId: parentId, sessionId: childId, error: error instanceof Error ? error.message : String(error) }, "failed to notify parent of subsession completion");
+        }
+    }
+    async messages(ref, page) {
+        const session = await this.getOrOpen(ref);
+        return pageMessagesAtSafeBoundary(historyMessages(session), page);
+    }
+    async status(ref) {
+        return this.statusFromSession(await this.getOrOpen(ref));
+    }
+    async availableModels(ref) {
+        const session = await this.getOrOpen(ref);
+        await session.modelRegistry.refresh();
+        const models = session.scopedModels.length > 0
+            ? session.scopedModels.map((scoped) => scoped.model)
+            : session.modelRegistry.getAvailable();
+        return models.map(modelToClientModel);
+    }
+    async setModel(ref, provider, modelId) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        await session.modelRegistry.refresh();
+        const candidates = session.scopedModels.length > 0
+            ? session.scopedModels.map((scoped) => scoped.model)
+            : session.modelRegistry.getAvailable();
+        const model = candidates.find((candidate) => candidate.provider === provider && candidate.id === modelId)
+            ?? session.modelRegistry.find(provider, modelId);
+        if (model === undefined)
+            throw new Error(`Model not found: ${provider}/${modelId}`);
+        await session.setModel(model);
+        this.publishActivity(session, `model: ${model.id}`, "idle", model.provider);
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    async cycleModel(ref, direction) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        const result = await session.cycleModel(direction);
+        if (result === undefined)
+            throw new Error(session.scopedModels.length > 0 ? "Only one model in scope" : "Only one model available");
+        this.publishActivity(session, `model: ${result.model.id}`, "idle", result.model.provider);
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    async availableThinkingLevels(ref) {
+        const session = await this.getOrOpen(ref);
+        return session.getAvailableThinkingLevels();
+    }
+    async setThinkingLevel(ref, level) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        // pi owns the valid set; validate against the session's live levels rather
+        // than a hardcoded union so this stays correct if pi changes the set.
+        const available = session.getAvailableThinkingLevels();
+        const match = available.find((candidate) => candidate === level);
+        if (match === undefined)
+            throw new Error(`Invalid thinking level: ${level}`);
+        session.setThinkingLevel(match);
+        this.publishActivity(session, `thinking: ${session.thinkingLevel}`, "idle");
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    async cycleThinkingLevel(ref) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        const level = session.cycleThinkingLevel();
+        if (level === undefined)
+            throw new Error("Current model does not support thinking");
+        this.publishActivity(session, `thinking: ${level}`, "idle");
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    async commands(ref) {
+        const session = await this.getOrOpen(ref);
+        const commands = [...BUILTIN_COMMANDS];
+        for (const command of session.extensionRunner.getRegisteredCommands()) {
+            commands.push({ name: command.name, ...(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" });
+        }
+        for (const skill of session.resourceLoader.getSkills().skills) {
+            commands.push({ name: `skill:${skill.name}`, ...(skill.description === undefined ? {} : { description: skill.description }), source: "skill" });
+        }
+        return commands.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async prompt(ref, text, streamingBehavior, attachments, options) {
+        const promptText = requirePromptText(text);
+        // Command-forwarded prompts (e.g. /skill:*) are expanded by the agent, which
+        // streams the canonical message back. The client doesn't render the raw
+        // command text, so the server must not echo it either, or it would show up
+        // as a transient line that vanishes on reload.
+        const echoUserMessage = options?.echoUserMessage !== false;
+        const requestedBehavior = parsePromptStreamingBehavior(streamingBehavior);
+        const parsedAttachments = parsePromptAttachments(attachments, { enforceInlineSizeLimit: false });
+        const images = attachmentsToInlineImages(parsedAttachments).map((entry) => entry.image);
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        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)) {
+            this.publishActivity(session, "duplicate queued message ignored", "active");
+            this.publishStatus(session);
+            return;
+        }
+        if (session.isCompacting) {
+            this.enqueuePromptDuringCompaction(session, promptText, behavior ?? "followUp", images, echoUserMessage);
+            return;
+        }
+        void this.submitPrompt(session, promptText, behavior, images, echoUserMessage);
+    }
+    submitPrompt(session, text, behavior, images = [], echoUserMessage = true) {
+        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) });
+        const promptOptions = buildPromptOptions(behavior, images);
+        const promptPromise = 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 });
+        });
+        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 }) });
+        this.compactionPromptQueues.set(session.sessionId, queue);
+        this.publishActivity(session, "message queued during compaction", "active");
+        this.publishStatus(session);
+    }
+    async saveAttachments(ref, attachments, folder) {
+        const parsed = parsePromptAttachments(attachments, { enforceInlineSizeLimit: false, allowFileAttachments: true });
+        if (parsed.length === 0)
+            return [];
+        await this.assertWritable(ref);
+        const active = await this.getActive(ref);
+        return saveAttachmentsToWorkspace(active.runtime.cwd, parsed, folder === undefined ? {} : { folder });
+    }
+    async shell(ref, text) {
+        await this.assertWritable(ref);
+        const active = await this.getActive(ref);
+        const { session } = active.runtime;
+        const isExcluded = text.startsWith("!!");
+        const command = (isExcluded ? text.slice(2) : text.slice(1)).trim();
+        if (!command)
+            throw new Error("Usage: !<shell command>");
+        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 });
+        void session.executeBash(command, (chunk) => {
+            this.events.publish(session.sessionId, { type: "shell.chunk", chunk });
+            this.publishActivity(session, "running bash", "active", command);
+            this.publishStatus(session);
+        }, { excludeFromContext: isExcluded }).then((result) => {
+            this.events.publish(session.sessionId, {
+                type: "shell.end",
+                output: result.output,
+                ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+                cancelled: result.cancelled,
+                truncated: result.truncated,
+            });
+            this.publishActivity(session, "bash complete", result.exitCode === 0 ? "idle" : "error", command);
+            this.publishStatus(session);
+        }).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.publishActivity(session, "bash failed", "error", message);
+            this.publishStatus(session);
+        });
+    }
+    async runCommand(ref, text) {
+        await this.assertWritable(ref);
+        const active = await this.getActive(ref);
+        return this.commandService.run(active.runtime.session.sessionId, text);
+    }
+    async respondToCommand(ref, requestId, value) {
+        await this.assertWritable(ref);
+        const active = await this.getActive(ref);
+        return this.commandService.respond(active.runtime.session.sessionId, requestId, value);
+    }
+    async reloadSessionRuntime(session) {
+        if (this.hasActiveWork(session))
+            throw new Error("Stop current session activity before reloading");
+        this.publishActivity(session, "reloading resources", "active");
+        try {
+            await session.reload();
+            this.publishActivity(session, "resources reloaded", "idle");
+            this.publishStatus(session);
+        }
+        catch (error) {
+            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.publishStatus(session);
+            throw error;
+        }
+    }
+    async archive(ref) {
+        const session = await this.getOrOpen(ref);
+        await this.gracefulStopAndClose(session);
+        const archiveInput = await this.archiveInputForSession(session);
+        await this.archiveStore.archive(archiveInput);
+    }
+    async archiveMany(refs) {
+        const uniqueRefs = uniqueBulkSessionRefs(refs);
+        const [archivedRecords, sessionContext] = await Promise.all([
+            this.archiveStore.list(),
+            this.bulkSessionLookupContext(uniqueRefs),
+        ]);
+        const failures = [];
+        const alreadyArchivedSessionIds = [];
+        const planItems = [];
+        for (const ref of uniqueRefs) {
+            const archived = findArchivedRecordForBulkRef(archivedRecords, ref);
+            if (archived !== undefined) {
+                alreadyArchivedSessionIds.push(archived.sessionId);
+                continue;
+            }
+            const active = this.activeForLookup(bulkRefToLookup(ref));
+            const listed = findListedSessionForBulkRef(sessionContext, ref);
+            const resolvedSessionId = active?.runtime.session.sessionId ?? listed?.id ?? ref.id;
+            try {
+                if (listed !== undefined) {
+                    planItems.push({ input: archiveInputFromListEntry(listed) });
+                }
+                else if (active !== undefined) {
+                    planItems.push({ input: archiveInputFromActiveSession(active.runtime.session), activeSession: active.runtime.session });
+                }
+                else {
+                    failures.push({ sessionId: ref.id, error: "Session not found" });
+                }
+            }
+            catch (error) {
+                failures.push({ sessionId: resolvedSessionId, error: errorMessage(error) });
+            }
+        }
+        const readyInputs = [];
+        for (const item of planItems) {
+            try {
+                if (item.activeSession) {
+                    await this.gracefulStopAndClose(item.activeSession);
+                }
+                readyInputs.push(item.input);
+            }
+            catch (error) {
+                failures.push({ sessionId: item.input.sessionId, error: errorMessage(error) });
+            }
+        }
+        const archivedSessionIds = [...alreadyArchivedSessionIds];
+        try {
+            const archived = await this.archiveStoreArchiveMany(readyInputs);
+            archivedSessionIds.push(...archived.map((record) => record.sessionId));
+        }
+        catch (error) {
+            for (const input of readyInputs)
+                failures.push({ sessionId: input.sessionId, error: errorMessage(error) });
+        }
+        return {
+            archived: true,
+            archivedSessionIds,
+            failures,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    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 plan = planSessionArchiveTree(root, catalog);
+        const archiveInputs = plan.unarchivedTargets.map((target) => archiveInputFromCandidate(target));
+        for (const target of plan.unarchivedTargets) {
+            if (target.activeSession) {
+                await this.gracefulStopAndClose(target.activeSession);
+            }
+            else {
+                await this.closeActive(target.id);
+            }
+        }
+        await this.archiveStoreArchiveMany(archiveInputs);
+        return {
+            archived: true,
+            sessionIds: archiveInputs.map((input) => input.sessionId),
+            archivedCount: archiveInputs.length,
+            skippedAlreadyArchivedCount: plan.skippedAlreadyArchivedCount,
+        };
+    }
+    async restore(ref) {
+        const archived = await this.getArchived(ref);
+        if (archived === undefined)
+            throw new Error("Session not found");
+        await this.closeActive(archived.sessionId);
+        await this.archiveStore.restore(archived.sessionId);
+    }
+    async deleteArchived(ref) {
+        const record = await this.getArchived(ref);
+        if (record === undefined)
+            throw new Error("Archived session not found");
+        if (this.archiveStore.deleteArchived === undefined)
+            throw new Error("Archive store does not support deletion");
+        await this.closeActive(record.sessionId);
+        if (record.archivePath === undefined)
+            await this.ensureArchivedRecordMoved(record);
+        await this.archiveStore.deleteArchived(record.sessionId);
+    }
+    async deleteArchivedMany(refs) {
+        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();
+        const failures = [];
+        const planItems = [];
+        for (const ref of uniqueRefs) {
+            const record = findArchivedRecordForBulkRef(archivedRecords, ref);
+            if (record === undefined) {
+                failures.push({ sessionId: ref.id, error: "Archived session not found" });
+                continue;
+            }
+            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" });
+                continue;
+            }
+            planItems.push({ record });
+        }
+        const readyRecords = [];
+        for (const item of planItems) {
+            try {
+                await this.closeActive(item.record.sessionId);
+                readyRecords.push(item.record);
+            }
+            catch (error) {
+                failures.push({ sessionId: item.record.sessionId, error: errorMessage(error) });
+            }
+        }
+        const moveFailures = await this.moveLegacyArchivedRecordsForDelete(readyRecords);
+        failures.push(...moveFailures);
+        const moveFailureIds = new Set(moveFailures.map((failure) => failure.sessionId));
+        const deleteIds = readyRecords
+            .map((record) => record.sessionId)
+            .filter((sessionId) => !moveFailureIds.has(sessionId));
+        let deletedSessionIds = [];
+        try {
+            deletedSessionIds = await this.archiveStoreDeleteArchivedMany(deleteIds);
+        }
+        catch (error) {
+            for (const sessionId of deleteIds)
+                failures.push({ sessionId, error: errorMessage(error) });
+        }
+        return {
+            deleted: true,
+            deletedSessionIds,
+            failures,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    async reload(ref) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        if (this.hasActiveWork(session))
+            throw new Error("Stop current session activity before reloading");
+        await this.closeActive(session.sessionId);
+        const reopened = await this.getActive(ref);
+        this.publishStatus(reopened.runtime.session);
+    }
+    async detachParent(ref) {
+        const session = await this.getOrOpen(ref);
+        const sessionFile = session.sessionFile;
+        if (sessionFile === undefined || sessionFile === "")
+            throw new Error("Session is not persisted");
+        await clearParentSession(sessionFile);
+        clearParentSessionHeader(session.sessionManager);
+        this.unregisterSubsession(session.sessionId);
+    }
+    async abort(ref) {
+        const active = this.activeForLookup(ref);
+        if (active === undefined)
+            return;
+        const sessionId = active.runtime.session.sessionId;
+        this.clearCompactionPromptQueue(sessionId);
+        clearSessionQueue(active.runtime.session);
+        await active.runtime.session.abort();
+        this.publishActivity(active.runtime.session, "stopped", "idle");
+        this.publishStatus(active.runtime.session);
+    }
+    stop(ref) {
+        const active = this.activeForLookup(ref);
+        if (active === undefined)
+            return;
+        void this.closeActive(active.runtime.session.sessionId).catch(() => {
+            // Best-effort shutdown; callers that need errors await closeActive directly.
+        });
+    }
+    async bulkSessionLookupContext(refs) {
+        const cwdSet = new Set();
+        let needsAllSessions = false;
+        for (const ref of refs) {
+            if (ref.cwd === undefined)
+                needsAllSessions = true;
+            else
+                cwdSet.add(ref.cwd);
+        }
+        const [sessionsByCwd, allSessions] = await Promise.all([
+            this.listSessionsByCwd([...cwdSet]),
+            needsAllSessions ? this.sessionManager.listAll?.() ?? Promise.resolve([]) : Promise.resolve(undefined),
+        ]);
+        return allSessions === undefined ? { sessionsByCwd } : { sessionsByCwd, allSessions };
+    }
+    async listSessionsByCwd(cwds) {
+        const uniqueCwds = uniqueStrings(cwds);
+        const entries = await Promise.all(uniqueCwds.map(async (cwd) => [cwd, await this.sessionManager.list(cwd)]));
+        return new Map(entries);
+    }
+    async archiveStoreArchiveMany(inputs) {
+        if (inputs.length === 0)
+            return [];
+        if (this.archiveStore.archiveMany !== undefined)
+            return this.archiveStore.archiveMany(inputs);
+        const records = [];
+        for (const input of inputs)
+            records.push(await this.archiveStore.archive(input));
+        return records;
+    }
+    async archiveStoreDeleteArchivedMany(sessionIds) {
+        if (sessionIds.length === 0)
+            return [];
+        if (this.archiveStore.deleteArchivedMany !== undefined)
+            return this.archiveStore.deleteArchivedMany(sessionIds);
+        if (this.archiveStore.deleteArchived === undefined)
+            throw new Error("Archive store does not support deletion");
+        for (const sessionId of sessionIds)
+            await this.archiveStore.deleteArchived(sessionId);
+        return [...sessionIds];
+    }
+    async moveLegacyArchivedRecordsForDelete(records) {
+        const legacyRecords = records.filter((record) => record.archivePath === undefined);
+        if (legacyRecords.length === 0)
+            return [];
+        let sessionsByCwd;
+        try {
+            sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
+        }
+        catch (error) {
+            return legacyRecords.map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
+        }
+        const moveInputs = legacyRecords
+            .map((record) => findSessionByIdOrPrefix(sessionsByCwd.get(record.cwd) ?? [], record.sessionId))
+            .filter(isDefined)
+            .map(archiveInputFromListEntry);
+        if (moveInputs.length === 0)
+            return [];
+        try {
+            await this.archiveStoreArchiveMany(moveInputs);
+            return [];
+        }
+        catch (error) {
+            const failedIds = new Set(moveInputs.map((input) => input.sessionId));
+            return legacyRecords
+                .filter((record) => failedIds.has(record.sessionId))
+                .map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
+        }
+    }
+    async cleanupPlan(request) {
+        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.listAll?.() ?? [], this.archiveStore.list()]);
+        return planSessionCleanup({
+            sessions,
+            archivedRecords,
+            activeSessions: this.cleanupActiveSessionStatuses(),
+            thresholds: request.thresholds,
+            ...(request.projectCwds === undefined ? {} : { projectCwds: request.projectCwds }),
+            now: this.now(),
+        });
+    }
+    cleanupActiveSessionStatuses() {
+        return [...new Set(this.active.values())].map((active) => ({
+            sessionId: active.runtime.session.sessionId,
+            hasActiveWork: this.hasActiveWork(active.runtime.session),
+        }));
+    }
+    activeSessionHasWork(sessionId) {
+        const active = this.active.get(sessionId);
+        return active !== undefined && this.hasActiveWork(active.runtime.session);
+    }
+    reconcilableSessionIds(cwd, listedSessionIds, archivedById) {
+        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))
+                sessionIds.add(session.sessionId);
+        }
+        return [...sessionIds];
+    }
+    async ensureArchivedSessionMoved(record, session) {
+        if (session === undefined || this.active.has(record.sessionId))
+            return record;
+        try {
+            return await this.archiveStore.archive(archiveInputFromListEntry(session));
+        }
+        catch {
+            return record;
+        }
+    }
+    async ensureArchivedRecordMoved(record) {
+        const session = (await this.sessionManager.list(record.cwd)).find((candidate) => candidate.id === record.sessionId);
+        if (session === undefined)
+            return record;
+        const [moved] = await this.archiveStoreArchiveMany([archiveInputFromListEntry(session)]);
+        return moved ?? record;
+    }
+    async ensureArchivedRecordsMoved(records) {
+        const legacyRecords = records.filter((record) => record.archivePath === undefined);
+        if (legacyRecords.length === 0)
+            return;
+        const sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
+        const moveInputs = legacyRecords
+            .map((record) => sessionsByCwd.get(record.cwd)?.find((candidate) => candidate.id === record.sessionId))
+            .filter(isDefined)
+            .map(archiveInputFromListEntry);
+        await this.archiveStoreArchiveMany(moveInputs);
+    }
+    async archiveInputForSession(session) {
+        const cwd = session.sessionManager.getCwd();
+        const sessionFile = session.sessionFile;
+        if (sessionFile === undefined || sessionFile === "")
+            throw new Error("Session is not persisted");
+        const listed = (await this.sessionManager.list(cwd)).find((candidate) => candidate.id === session.sessionId);
+        if (listed !== undefined)
+            return archiveInputFromListEntry(listed);
+        return archiveInputFromActiveSession(session);
+    }
+    async workspaceArchiveCandidates(cwd) {
+        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) {
+            if (record.cwd === cwd)
+                archivedById.set(record.sessionId, record);
+        }
+        for (const session of sessions) {
+            const archived = archivedById.get(session.id);
+            if (archived === undefined)
+                candidates.set(session.id, archiveCandidateFromListEntry(session));
+            else {
+                const candidate = archiveCandidateFromArchivedRecord(archived, session);
+                if (candidate !== undefined)
+                    candidates.set(candidate.id, candidate);
+            }
+        }
+        for (const record of archivedById.values()) {
+            if (candidates.has(record.sessionId))
+                continue;
+            const candidate = archiveCandidateFromArchivedRecord(record, undefined);
+            if (candidate !== undefined)
+                candidates.set(candidate.id, candidate);
+        }
+        for (const active of new Set(this.active.values())) {
+            const session = active.runtime.session;
+            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 });
+        }
+        return [...candidates.values()];
+    }
+    async listSessionNames(cwd) {
+        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);
+        for (const record of archivedRecords) {
+            if (record.cwd === cwd)
+                addSessionName(names, record.name);
+        }
+        for (const active of new Set(this.active.values())) {
+            const session = active.runtime.session;
+            if (session.sessionManager.getCwd() === cwd)
+                addSessionName(names, session.sessionName);
+        }
+        return [...names];
+    }
+    async closeActive(sessionId) {
+        const active = this.active.get(sessionId);
+        if (!active)
+            return;
+        this.active.delete(sessionId);
+        this.schedulePromptService.stopForSession(sessionId);
+        this.activities.delete(sessionId);
+        this.workspaceActivity?.removeSession(sessionId, active.runtime.session.sessionManager.getCwd());
+        this.clearAuthLossWarningsForSession(sessionId);
+        this.clearCompactionPromptQueue(sessionId);
+        // Disarm subsession notification before teardown so the abort below cannot
+        // emit a "stopped working" event that notifies the parent (e.g. on archive).
+        // The parent/children link is kept so the parent can still see the child.
+        if (this.subsessionLinkForActiveChild(active.runtime.session) !== undefined)
+            this.subsessionNotifyArmed.delete(sessionId);
+        clearSessionQueue(active.runtime.session);
+        active.unsubscribe();
+        try {
+            await active.runtime.session.abort();
+        }
+        finally {
+            await active.runtime.dispose();
+        }
+    }
+    async gracefulStopAndClose(session, timeoutMs = 5000) {
+        if (this.hasActiveWork(session)) {
+            this.logger.info({ sessionId: session.sessionId }, "Session has active work, requesting abort for graceful shutdown...");
+            // Signal an abort to stop the stream/work
+            await session.abort().catch(() => undefined);
+            // Wait for the session to settle and fire its hooks
+            const start = Date.now();
+            while (this.hasActiveWork(session)) {
+                if (Date.now() - start > timeoutMs) {
+                    this.logger.info({ sessionId: session.sessionId, timeoutMs }, "Session did not settle within timeout, forcing hard kill.");
+                    break;
+                }
+                // Small delay to yield the event loop
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+        }
+        // Give any fire-and-forget hooks (like ai-memory's stop.sh) a brief window to read the file before we move it
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        await this.closeActive(session.sessionId);
+    }
+    async assertWritable(ref) {
+        if (await this.getArchived(ref) !== undefined)
+            throw new Error("Archived sessions are read-only. Restore the session to continue.");
+    }
+    async getOrOpen(ref) {
+        return (await this.getActive(ref)).runtime.session;
+    }
+    async getActive(ref) {
+        const active = this.activeForLookup(ref);
+        if (active !== undefined)
+            return active;
+        const archived = await this.getArchived(ref);
+        if (archived?.archivePath !== undefined)
+            return this.create(await this.sessionManager.open(archived.archivePath), archived.cwd);
+        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));
+        if (!match)
+            throw new Error("Session not found");
+        return this.create(await this.sessionManager.open(match.path), match.cwd);
+    }
+    async getArchived(ref) {
+        const archived = await this.archiveStore.get(sessionIdFromLookup(ref));
+        if (archived === undefined)
+            return undefined;
+        if (isPiSessionRef(ref) && archived.cwd !== ref.cwd)
+            return undefined;
+        return archived;
+    }
+    activeForLookup(ref) {
+        const sessionId = sessionIdFromLookup(ref);
+        const exact = this.active.get(sessionId);
+        if (exact !== undefined && lookupMatchesActiveSession(ref, exact))
+            return exact;
+        for (const [candidateId, active] of this.active.entries()) {
+            if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active))
+                return active;
+        }
+        return undefined;
+    }
+    async create(sessionManager, cwd, options = {}) {
+        const runtime = await this.createAgentRuntime(this.createRuntime, {
+            cwd,
+            agentDir: this.agentDir,
+            sessionManager,
+            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+        });
+        const active = { runtime, unsubscribe: noop };
+        await this.bindSessionExtensions(runtime.session);
+        this.bindRuntime(active);
+        runtime.setRebindSession(async (session) => {
+            await this.bindSessionExtensions(session);
+            this.bindRuntime(active);
+            await this.recoverSubsessionTrackingForOpenedSession(session);
+        });
+        this.active.set(runtime.session.sessionId, active);
+        await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
+        this.publishStatus(runtime.session);
+        return active;
+    }
+    async bindSessionExtensions(session) {
+        await session.bindExtensions({
+            onError: (error) => {
+                const message = `${error.extensionPath}: ${error.error}`;
+                this.publishActivity(session, "extension error", "error", message);
+                this.events.publish(session.sessionId, { type: "session.error", message });
+            },
+        });
+    }
+    bindRuntime(active) {
+        active.unsubscribe();
+        const { session } = active.runtime;
+        for (const [sessionId, candidate] of this.active.entries()) {
+            if (candidate === active) {
+                this.active.delete(sessionId);
+                if (sessionId !== session.sessionId)
+                    this.clearCompactionPromptQueue(sessionId);
+            }
+        }
+        active.unsubscribe = session.subscribe((event) => {
+            this.events.publish(session.sessionId, toClientEvent(event));
+            this.publishActivityForEvent(session, event);
+            const eventType = getString(event, "type");
+            if (eventType === "compaction_end")
+                this.scheduleCompactionQueueDrain(session.sessionId);
+            if (eventType === "agent_start" || eventType === "agent_end")
+                this.scheduleCompactionQueueDrain(session.sessionId);
+            this.publishStatus(session);
+            this.updateSubsessionTracking(session);
+        });
+        this.active.set(session.sessionId, active);
+    }
+    scheduleCompactionQueueDrain(sessionId, delayMs = 0) {
+        if (!this.compactionPromptQueues.has(sessionId) || this.compactionDrainTimers.has(sessionId))
+            return;
+        const timer = setTimeout(() => {
+            this.compactionDrainTimers.delete(sessionId);
+            this.drainCompactionPromptQueue(sessionId);
+        }, delayMs);
+        this.compactionDrainTimers.set(sessionId, timer);
+    }
+    drainCompactionPromptQueue(sessionId) {
+        const active = this.active.get(sessionId);
+        if (active === undefined)
+            return;
+        const { session } = active.runtime;
+        if (session.isCompacting) {
+            this.scheduleCompactionQueueDrain(sessionId, 100);
+            return;
+        }
+        if (session.isStreaming) {
+            const queued = this.takeCompactionPromptQueue(sessionId);
+            if (queued.length === 0)
+                return;
+            this.publishStatus(session);
+            for (const prompt of queued)
+                void this.submitPrompt(session, prompt.text, prompt.kind, prompt.images, prompt.echoUserMessage ?? true);
+            return;
+        }
+        const prompt = this.shiftCompactionPrompt(sessionId);
+        if (prompt === undefined)
+            return;
+        this.publishStatus(session);
+        const submitted = this.submitPrompt(session, prompt.text, undefined, prompt.images, prompt.echoUserMessage ?? true);
+        void submitted.finally(() => { this.scheduleCompactionQueueDrain(sessionId); });
+    }
+    takeCompactionPromptQueue(sessionId) {
+        const queued = this.compactionPromptQueues.get(sessionId) ?? [];
+        this.compactionPromptQueues.delete(sessionId);
+        return queued;
+    }
+    shiftCompactionPrompt(sessionId) {
+        const queue = this.compactionPromptQueues.get(sessionId);
+        const prompt = queue?.shift();
+        if (queue === undefined || queue.length === 0)
+            this.compactionPromptQueues.delete(sessionId);
+        return prompt;
+    }
+    clearCompactionPromptQueue(sessionId) {
+        this.compactionPromptQueues.delete(sessionId);
+        const timer = this.compactionDrainTimers.get(sessionId);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.compactionDrainTimers.delete(sessionId);
+        }
+    }
+    clearCompactionDrainTimers() {
+        for (const timer of this.compactionDrainTimers.values())
+            clearTimeout(timer);
+        this.compactionDrainTimers.clear();
+    }
+    maybeGenerateSessionName(session, firstMessage) {
+        if (session.sessionName !== undefined || session.messages.length !== 0 || session.isStreaming || session.isCompacting)
+            return;
+        const model = session.model;
+        if (model === undefined)
+            return;
+        void generateShortSessionName(session.agent.streamFn, model, firstMessage).then((name) => {
+            this.applyGeneratedSessionName(session, name ?? fallbackSessionName(firstMessage));
+        }).catch(() => {
+            this.applyGeneratedSessionName(session, fallbackSessionName(firstMessage));
+        });
+    }
+    applyGeneratedSessionName(session, name) {
+        if (name === undefined || session.sessionName !== undefined)
+            return;
+        session.setSessionName(name);
+        this.publishSessionName(session);
+    }
+    applyAuthChange(change = {}) {
+        void this.modelRegistry?.refresh();
+        for (const active of this.active.values()) {
+            const { session } = active.runtime;
+            void session.modelRegistry.refresh();
+            this.syncCurrentModelAuthWarning(session, change.removedProviderId);
+            this.publishStatus(session);
+        }
+    }
+    syncCurrentModelAuthWarning(session, removedProviderId) {
+        const model = session.model;
+        if (model === undefined)
+            return;
+        if (model.provider === "unknown" && model.id === "unknown")
+            return;
+        const warningKey = authLossWarningKey(session.sessionId, model.provider, model.id);
+        const registered = session.modelRegistry.find(model.provider, model.id);
+        if (registered === undefined)
+            return;
+        if (session.modelRegistry.hasConfiguredAuth(registered)) {
+            this.authLossWarnings.delete(warningKey);
+            return;
+        }
+        if (removedProviderId === undefined || model.provider !== removedProviderId || this.authLossWarnings.has(warningKey))
+            return;
+        this.authLossWarnings.add(warningKey);
+        this.events.publish(session.sessionId, {
+            type: "command.output",
+            level: "error",
+            message: `Authentication for ${model.provider}/${model.id} was removed. Use /model to select another model.`,
+        });
+    }
+    clearAuthLossWarningsForSession(sessionId) {
+        const prefix = `${sessionId}:`;
+        for (const key of this.authLossWarnings) {
+            if (key.startsWith(prefix))
+                this.authLossWarnings.delete(key);
+        }
+    }
+    publishSessionName(session) {
+        const event = session.sessionName === undefined
+            ? { type: "session.name", sessionId: session.sessionId }
+            : { type: "session.name", sessionId: session.sessionId, name: session.sessionName };
+        this.events.publish(session.sessionId, event);
+        this.events.publishGlobal(event);
+    }
+    publishHeartbeats() {
+        for (const active of this.active.values()) {
+            const { session } = active.runtime;
+            // Re-evaluate subsession completion here too: agent_end can arrive while
+            // the session still reports active work transiently, so the event-driven
+            // latch may not fire. The heartbeat re-checks once the session settles.
+            this.updateSubsessionTracking(session);
+            const activity = this.activities.get(session.sessionId);
+            if (!this.hasActiveWork(session)) {
+                if (activity?.phase === "active")
+                    this.publishStatus(session);
+                continue;
+            }
+            this.publishStatus(session);
+            if (activity?.phase === "active")
+                this.publishActivity(session, activity.label, "active", activity.detail);
+            else
+                this.publishActivity(session, this.activityLabelFromStatus(session), "active");
+        }
+    }
+    activityLabelFromStatus(session) {
+        if (session.isCompacting)
+            return "compacting";
+        if (session.isBashRunning)
+            return "running bash";
+        if (session.isStreaming)
+            return "agent running";
+        if (this.pendingMessageCount(session) > 0)
+            return "queued";
+        return "active";
+    }
+    hasActiveWork(session) {
+        return sessionHasActiveWork(session, this.compactionQueuedMessages(session.sessionId).length);
+    }
+    publishActivityForEvent(session, event) {
+        const eventType = getString(event, "type");
+        if (eventType === undefined)
+            return;
+        if (eventType === "agent_start") {
+            this.publishActivity(session, "agent running", "active");
+            this.notifiedWorkComplete.delete(session.sessionId);
+            return;
+        }
+        if (eventType === "agent_end") {
+            this.publishActivity(session, "idle", "idle");
+            setTimeout(() => {
+                this.publishActivity(session, "idle", "idle");
+                this.publishStatus(session);
+                if (this.pushService !== undefined && !this.notifiedWorkComplete.has(session.sessionId) && !sessionHasActiveWork(session)) {
+                    this.notifiedWorkComplete.add(session.sessionId);
+                    const messages = session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch();
+                    void this.pushService.notifySessionComplete(session.sessionId, session.sessionName, messages);
+                }
+            }, 250);
+            return;
+        }
+        if (eventType === "turn_end") {
+            this.publishActivity(session, "turn complete", "idle");
+            return;
+        }
+        if (eventType === "message_start") {
+            this.publishActivity(session, "message started", "active");
+            return;
+        }
+        if (eventType === "message_end") {
+            this.publishActivity(session, "message complete", "idle");
+            return;
+        }
+        if (eventType === "message_update") {
+            this.publishActivity(session, "receiving response", "active");
+            return;
+        }
+        if (eventType === "tool_execution_start") {
+            this.publishActivity(session, "running tool", "active", getString(event, "toolName"));
+            return;
+        }
+        if (eventType === "tool_execution_end") {
+            const isError = getBoolean(event, "isError") === true;
+            this.publishActivity(session, isError ? "tool failed" : "tool complete", isError ? "error" : "idle", getString(event, "toolName"));
+            return;
+        }
+        if (eventType === "bash_execution_start") {
+            this.publishActivity(session, "running bash", "active");
+            return;
+        }
+        if (eventType === "bash_execution_end") {
+            this.publishActivity(session, "bash complete", "idle");
+            return;
+        }
+        if (this.hasActiveWork(session))
+            this.publishActivity(session, eventType.replaceAll("_", " "), "active");
+    }
+    publishActivity(session, label, phase, detail) {
+        const at = new Date().toISOString();
+        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 };
+        this.workspaceActivity?.applySessionActivity(session.sessionManager.getCwd(), activity);
+        this.events.publish(session.sessionId, { type: "activity.update", activity });
+        this.events.publishGlobal({ type: "activity.update", activity });
+    }
+    publishStatus(session) {
+        const status = this.statusFromSession(session);
+        this.clearStaleActiveActivity(session);
+        this.workspaceActivity?.applySessionStatus(session.sessionManager.getCwd(), status);
+        this.events.publish(session.sessionId, { type: "status.update", status });
+        this.events.publishGlobal({ type: "status.update", status });
+    }
+    clearStaleActiveActivity(session) {
+        const current = this.activities.get(session.sessionId);
+        if (current?.phase !== "active" || this.hasActiveWork(session))
+            return;
+        const at = new Date().toISOString();
+        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.publishGlobal({ type: "activity.update", activity });
+    }
+    statusFromSession(session) {
+        const stats = session.getSessionStats();
+        const model = session.model === undefined ? undefined : modelToClientModel(session.model);
+        const contextUsage = session.getContextUsage();
+        return {
+            sessionId: session.sessionId,
+            persisted: sessionFileExists(session.sessionFile),
+            ...(model === undefined ? {} : { model }),
+            thinkingLevel: session.thinkingLevel,
+            isStreaming: session.isStreaming,
+            isCompacting: session.isCompacting,
+            isBashRunning: session.isBashRunning,
+            pendingMessageCount: this.pendingMessageCount(session),
+            queuedMessages: queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)),
+            messageCount: session.messages.length,
+            tokens: stats.tokens,
+            cost: stats.cost,
+            ...(contextUsage === undefined ? {} : { contextUsage }),
+        };
+    }
+    pendingMessageCount(session) {
+        return session.pendingMessageCount + this.compactionQueuedMessages(session.sessionId).length;
+    }
+    compactionQueuedMessages(sessionId) {
+        return this.compactionPromptQueues.get(sessionId) ?? [];
+    }
+    hasQueuedMessageText(session, text) {
+        return queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)).some((message) => message.text === text);
+    }
+}
+function previewResponseFromPlan(plan) {
+    return {
+        generatedAt: plan.generatedAt,
+        thresholds: plan.thresholds,
+        projects: plan.projects,
+        totals: plan.totals,
+        ...(plan.skippedBusySessionIds.length === 0 ? {} : { skippedBusySessionIds: plan.skippedBusySessionIds }),
+    };
+}
+function uniqueBulkSessionRefs(refs) {
+    const seen = new Set();
+    const unique = [];
+    for (const ref of refs) {
+        const key = `${ref.cwd ?? ""}\0${ref.id}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(ref);
+    }
+    return unique;
+}
+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)));
+}
+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);
+}
+function findSessionByIdOrPrefix(sessions, sessionId) {
+    return sessions.find((session) => session.id === sessionId) ?? sessions.find((session) => session.id.startsWith(sessionId));
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function modelToClientModel(model) {
+    if (model === undefined)
+        return {};
+    const name = getString(model, "name");
+    const reasoning = getProperty(model, "reasoning");
+    return {
+        provider: model.provider,
+        id: model.id,
+        ...(name === undefined ? {} : { name }),
+        ...(model.contextWindow === null ? {} : { contextWindow: model.contextWindow }),
+        ...(reasoning === undefined ? {} : { reasoning }),
+    };
+}
+function clientSessionFromListEntry(session) {
+    return {
+        id: session.id,
+        path: session.path,
+        cwd: session.cwd,
+        persisted: true,
+        ...(session.name === undefined ? {} : { name: session.name }),
+        created: session.created.toISOString(),
+        modified: session.modified.toISOString(),
+        messageCount: session.messageCount,
+        firstMessage: session.firstMessage,
+        ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
+    };
+}
+function archiveInputFromListEntry(session) {
+    return {
+        sessionId: session.id,
+        cwd: session.cwd,
+        path: session.path,
+        created: session.created.toISOString(),
+        modified: session.modified.toISOString(),
+        messageCount: session.messageCount,
+        firstMessage: session.firstMessage,
+        ...(session.name === undefined ? {} : { name: session.name }),
+        ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
+    };
+}
+function archiveInputFromActiveSession(session) {
+    const sessionFile = session.sessionFile;
+    if (sessionFile === undefined || sessionFile === "")
+        throw new Error("Session is not persisted");
+    const parentSessionPath = session.sessionManager.getHeader?.()?.parentSession;
+    return {
+        sessionId: session.sessionId,
+        cwd: session.sessionManager.getCwd(),
+        path: sessionFile,
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+        messageCount: session.messages.length,
+        firstMessage: "",
+        ...(session.sessionName === undefined ? {} : { name: session.sessionName }),
+        ...(parentSessionPath === undefined ? {} : { parentSessionPath }),
+    };
+}
+function archiveCandidateFromListEntry(session) {
+    return {
+        id: session.id,
+        path: session.path,
+        cwd: session.cwd,
+        archived: false,
+        listEntry: session,
+        ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
+    };
+}
+function archiveCandidateFromArchivedRecord(record, fallback) {
+    const path = record.originalPath ?? fallback?.path;
+    if (path === undefined)
+        return undefined;
+    const parentSessionPath = record.parentSessionPath ?? fallback?.parentSessionPath;
+    return {
+        id: record.sessionId,
+        path,
+        cwd: record.cwd,
+        archived: true,
+        ...(fallback === undefined ? {} : { listEntry: fallback }),
+        ...(parentSessionPath === undefined ? {} : { parentSessionPath }),
+    };
+}
+function archiveCandidateFromActiveSession(session, archived) {
+    const sessionFile = session.sessionFile;
+    if (sessionFile === undefined || sessionFile === "")
+        throw new Error("Session is not persisted");
+    const parentSessionPath = session.sessionManager.getHeader?.()?.parentSession;
+    return {
+        id: session.sessionId,
+        path: sessionFile,
+        cwd: session.sessionManager.getCwd(),
+        archived,
+        activeSession: session,
+        ...(parentSessionPath === undefined ? {} : { parentSessionPath }),
+    };
+}
+function archiveInputFromCandidate(candidate) {
+    if (candidate.listEntry !== undefined)
+        return archiveInputFromListEntry(candidate.listEntry);
+    if (candidate.activeSession !== undefined)
+        return archiveInputFromActiveSession(candidate.activeSession);
+    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;
+}
+function clientSessionFromArchivedRecord(record, fallback) {
+    const path = record.originalPath ?? fallback?.path;
+    const created = record.created ?? fallback?.created.toISOString();
+    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)
+        return undefined;
+    const name = record.name ?? fallback?.name;
+    const parentSessionPath = record.parentSessionPath ?? fallback?.parentSessionPath;
+    return {
+        id: record.sessionId,
+        path,
+        cwd: record.cwd,
+        ...(name === undefined ? {} : { name }),
+        created,
+        modified,
+        messageCount,
+        firstMessage,
+        ...(parentSessionPath === undefined ? {} : { parentSessionPath }),
+        archived: true,
+        archivedAt: record.archivedAt,
+    };
+}
+function addSessionName(names, name) {
+    const trimmed = name?.replace(/\s+/g, " ").trim();
+    if (trimmed !== undefined && trimmed !== "")
+        names.add(trimmed);
+}
+function compareArchivedRecords(a, b) {
+    return archivedTimestamp(b) - archivedTimestamp(a);
+}
+function archivedTimestamp(record) {
+    const time = Date.parse(record.archivedAt);
+    return Number.isNaN(time) ? 0 : time;
+}
+function isDefined(value) {
+    return value !== undefined;
+}
+function trackedSubsessionLinkFromParentLink(parentSessionId, link, parentSessionFile) {
+    return {
+        parentSessionId,
+        childSessionId: link.spawnedSessionId,
+        ...(link.spawnedSessionFile === undefined ? {} : { childSessionFile: link.spawnedSessionFile }),
+        parentSessionFile,
+        ...(link.cwd === undefined ? {} : { cwd: link.cwd }),
+    };
+}
+function persistedParentSubsessionLinkData(link) {
+    return {
+        version: 1,
+        spawnedBySessionId: link.parentSessionId,
+        spawnedSessionId: link.childSessionId,
+        ...(link.childSessionFile === undefined ? {} : { spawnedSessionFile: link.childSessionFile }),
+        ...(link.cwd === undefined ? {} : { cwd: link.cwd }),
+    };
+}
+function persistedChildSubsessionLinkData(parentSessionId, childSessionId) {
+    return {
+        version: 1,
+        spawnedBySessionId: parentSessionId,
+        spawnedSessionId: childSessionId,
+    };
+}
+function parsePersistedParentSubsessionLink(entry) {
+    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 === "")
+        return undefined;
+    const spawnedSessionFile = getString(data, "spawnedSessionFile");
+    const cwd = getString(data, "cwd");
+    return {
+        spawnedBySessionId,
+        spawnedSessionId,
+        ...(spawnedSessionFile === undefined || spawnedSessionFile === "" ? {} : { spawnedSessionFile }),
+        ...(cwd === undefined || cwd === "" ? {} : { cwd }),
+    };
+}
+function parsePersistedChildSubsessionLink(entry) {
+    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 === "")
+        return undefined;
+    return { spawnedBySessionId, spawnedSessionId };
+}
+function nonEmptyString(value) {
+    return value === undefined || value === "" ? undefined : value;
+}
+function subsessionHydratedParentKey(parentSessionId, parentSessionFile) {
+    return `${parentSessionId}\0${parentSessionFile ?? ""}`;
+}
+function sessionPathsEqual(a, b) {
+    return cwdPathsEqual(a, b);
+}
+function sessionFileExists(sessionFile) {
+    if (sessionFile === undefined || sessionFile === "")
+        return false;
+    try {
+        return statSync(sessionFile).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function sessionFileMatches(session, expectedSessionFile) {
+    const sessionFile = nonEmptyString(session.sessionFile);
+    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);
+}
+async function readSessionHeaderSummary(sessionFile) {
+    let file;
+    try {
+        file = await open(sessionFile, "r");
+        const buffer = Buffer.alloc(4096);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+        const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n", 1)[0];
+        if (firstLine === undefined || firstLine === "")
+            return undefined;
+        const header = JSON.parse(firstLine);
+        if (!isRecord(header) || header["type"] !== "session" || typeof header["id"] !== "string")
+            return undefined;
+        const parentSession = getString(header, "parentSession");
+        return { id: header["id"], ...(parentSession === undefined ? {} : { parentSession }) };
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await file?.close().catch(() => undefined);
+    }
+}
+async function sessionFileHeaderMatches(sessionFile, expected) {
+    const header = await readSessionHeaderSummary(sessionFile);
+    if (header?.id !== expected.sessionId)
+        return false;
+    if (expected.parentSessionFile === undefined)
+        return true;
+    return header.parentSession !== undefined && sessionPathsEqual(header.parentSession, expected.parentSessionFile);
+}
+async function clearParentSession(sessionFile) {
+    const content = await readFile(sessionFile, "utf8");
+    const newlineIndex = content.indexOf("\n");
+    const firstLine = newlineIndex === -1 ? content : content.slice(0, newlineIndex);
+    const rest = newlineIndex === -1 ? "" : content.slice(newlineIndex);
+    const header = JSON.parse(firstLine);
+    if (!isRecord(header) || header["type"] !== "session")
+        throw new Error("Invalid session file header");
+    if (header["parentSession"] === undefined)
+        return;
+    delete header["parentSession"];
+    await writeFile(sessionFile, `${JSON.stringify(header)}${rest}`, "utf8");
+}
+function clearParentSessionHeader(sessionManager) {
+    const header = sessionManager.getHeader?.();
+    if (header !== undefined && header !== null)
+        delete header.parentSession;
+}
+function clearSessionQueue(session) {
+    session.clearQueue();
+}
+function queuedMessagesFromSession(session, extraQueuedMessages = []) {
+    return [
+        ...session.getSteeringMessages().map((text) => ({ kind: "steer", text })),
+        ...session.getFollowUpMessages().map((text) => ({ kind: "followUp", text })),
+        ...extraQueuedMessages,
+    ];
+}
+function userTextMessage(text) {
+    return { role: "user", content: text };
+}
+/**
+ * Build the optimistic user message echoed to clients. When images are present
+ * we mirror pi's content-array shape (`[{type:"text"}, {type:"image"}, ...]`) so
+ * the local echo matches what pi persists in the session branch.
+ */
+function userMessage(text, images) {
+    if (images.length === 0)
+        return userTextMessage(text);
+    const content = [];
+    if (text !== "")
+        content.push({ type: "text", text });
+    content.push(...images);
+    return { role: "user", content };
+}
+function buildPromptOptions(behavior, images) {
+    const options = {};
+    if (behavior !== undefined)
+        options.streamingBehavior = behavior;
+    if (images.length > 0)
+        options.images = images;
+    return Object.keys(options).length > 0 ? options : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function historyMessages(session) {
+    const messages = [];
+    for (const entry of session.sessionManager.getBranch()) {
+        if (!isRecord(entry))
+            continue;
+        if (entry["type"] === "message")
+            messages.push(entry["message"]);
+        else if (entry["type"] === "custom_message" && entry["display"] === true)
+            messages.push({ role: "custom", content: entry["content"], customType: entry["customType"], details: entry["details"] });
+        else if (entry["type"] === "compaction")
+            messages.push({ role: "system", source: "compaction", content: `Compacted history:\n\n${stringValue(entry["summary"])}` });
+        else if (entry["type"] === "branch_summary")
+            messages.push({ role: "system", source: "branch_summary", content: `Branch summary:\n\n${stringValue(entry["summary"])}` });
+    }
+    return messages;
+}
+/** custom entry type used to persist parent -> child subsession links outside LLM context. */
+const SUBSESSION_LINK_CUSTOM_TYPE = "omp-web.subsession.link";
+/** custom entry type used to mark a child as created by spawn_subsession. */
+const SUBSESSION_CHILD_LINK_CUSTOM_TYPE = "omp-web.subsession.spawned";
+/** customType marking a parent-facing subsession-completion notice. */
+const SUBSESSION_NOTIFICATION_CUSTOM_TYPE = "subsession.completion";
+const SUBSESSION_NOTIFICATION_PREVIEW_CHARS = 2000;
+function truncateForNotification(text) {
+    if (text.length <= SUBSESSION_NOTIFICATION_PREVIEW_CHARS)
+        return text;
+    return `${text.slice(0, SUBSESSION_NOTIFICATION_PREVIEW_CHARS)}…`;
+}
+/** Most recent assistant text from a history message list, or "" if none. */
+function finalAssistantText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (!isRecord(message) || message["role"] !== "assistant")
+            continue;
+        const content = message["content"];
+        if (typeof content === "string")
+            return content;
+        if (!Array.isArray(content))
+            continue;
+        const texts = [];
+        for (const part of content) {
+            if (isRecord(part) && part["type"] === "text" && typeof part["text"] === "string")
+                texts.push(part["text"]);
+        }
+        if (texts.length > 0)
+            return texts.join("\n").trim();
+    }
+    return "";
+}
+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") === "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 };
+    }
+    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) };
+    }
+    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 };
+    }
+    if (eventType === "agent_start")
+        return { type: "agent.start" };
+    if (eventType === "agent_end")
+        return { type: "agent.end" };
+    if (eventType === "message_end") {
+        const message = getProperty(event, "message");
+        return message === undefined ? { type: "message.end" } : { type: "message.end", message };
+    }
+    return { type: "pi.event", eventType: eventType ?? "unknown" };
+}
+function summarizeToolArgs(args) {
+    if (!isRecord(args))
+        return stringifyPrimitive(args);
+    const command = getString(args, "command");
+    if (command !== undefined)
+        return command;
+    const path = getString(args, "path");
+    if (path !== undefined)
+        return path;
+    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(" · ");
+}
+function shortToolValue(value) {
+    if (typeof value === "string")
+        return value.length > 80 ? `${value.slice(0, 77)}…` : value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (Array.isArray(value))
+        return `${String(value.length)} item${value.length === 1 ? "" : "s"}`;
+    if (typeof value === "object" && value !== null)
+        return "object";
+    return "";
+}
+function toolResultContent(result) {
+    if (isRecord(result)) {
+        const content = getProperty(result, "content");
+        if (content !== undefined)
+            return content;
+        const text = getString(result, "text") ?? getString(result, "output");
+        if (text !== undefined)
+            return [{ type: "text", text }];
+    }
+    if (typeof result === "string")
+        return [{ type: "text", text: result }];
+    return result;
+}
+function toolResultDetails(result) {
+    return isRecord(result) ? getProperty(result, "details") : undefined;
+}
+function stringifyToolResult(result) {
+    if (typeof result === "string")
+        return result;
+    if (Array.isArray(result))
+        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");
+        if (text !== undefined)
+            return text;
+        const content = getProperty(result, "content");
+        if (Array.isArray(content))
+            return stringifyToolResult(content);
+        return JSON.stringify(result, null, 2);
+    }
+    return stringifyPrimitive(result);
+}
+function getProperty(value, key) {
+    return isRecord(value) ? value[key] : undefined;
+}
+function getString(value, key) {
+    const property = getProperty(value, key);
+    return typeof property === "string" ? property : undefined;
+}
+function getBoolean(value, key) {
+    const property = getProperty(value, key);
+    return typeof property === "boolean" ? property : undefined;
+}
+function stringifyPrimitive(value) {
+    if (value == null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+        return String(value);
+    return "";
+}
+//# sourceMappingURL=piSessionService.js.map