@jmfederico/pi-web 1.202607.3 → 1.202608.0

package/dist/server/sessions/piSessionService.js

@@ -1,6 +1,6 @@
 import { statSync } from "node:fs";
 import { join } from "node:path";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, stat, writeFile } from "node:fs/promises";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, defineTool, readStoredCredential, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { projectBrowserMessage } from "../browserMessageProjection.js";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
@@ -56,20 +56,36 @@ function spawnTargetError(decision) {
         return new Error("Spawning session is not in a registered project");
     return new Error(`cwd must be a workspace of this project. Allowed: ${decision.allowedCwds.join(", ")}`);
 }
-function authLossWarningKey(sessionId, provider, modelId) {
-    return `${sessionId}:${provider}/${modelId}`;
+function modelSpecOf(model) {
+    return `${model.provider}/${model.id}`;
 }
-function sessionIdFromLookup(ref) {
-    return typeof ref === "string" ? ref : ref.id;
+/**
+ * Parse a strict `provider/model-id` spec: split on the first `/` (model ids
+ * may themselves contain `/`) and require both parts to be non-empty.
+ */
+function parseModelSpec(spec) {
+    const slash = spec.indexOf("/");
+    if (slash <= 0 || slash === spec.length - 1)
+        return undefined;
+    return { provider: spec.slice(0, slash), modelId: spec.slice(slash + 1) };
 }
-function isPiSessionRef(ref) {
-    return typeof ref !== "string";
+/**
+ * Error for a spawn-tool model spec that matched nothing. States the facts —
+ * the bad spec and the required format — with deliberately no model list
+ * (a list would invite guesses). The agent loop turns the throw into an
+ * error tool result; how to recover is the agent's call.
+ */
+function unknownSpawnModelError(modelSpec) {
+    return new Error(`Unknown model "${modelSpec}". Pass an exact "provider/model-id".`);
 }
-function lookupMatchesActiveSession(ref, active) {
-    return !isPiSessionRef(ref) || cwdPathsEqual(active.runtime.cwd, ref.cwd);
+function authLossWarningKey(sessionId, provider, modelId) {
+    return `${sessionId}:${provider}/${modelId}`;
 }
-function lookupMatchesStartupSession(ref, session) {
-    return !isPiSessionRef(ref) || cwdPathsEqual(session.sessionManager.getCwd(), ref.cwd);
+function refMatchesActiveSession(ref, active) {
+    return cwdPathsEqual(active.runtime.cwd, ref.cwd);
+}
+function refMatchesStartupSession(ref, session) {
+    return cwdPathsEqual(session.sessionManager.getCwd(), ref.cwd);
 }
 function sessionTreeNavigationOptions(request) {
     switch (request.summary.mode) {
@@ -220,26 +236,31 @@ export function dismissSessionWarning(session, dismissId) {
 function defaultCreateAgentRuntime(createRuntime, options) {
     if (!(options.sessionManager instanceof SessionManager))
         throw new Error("Default runtime creation requires an SDK SessionManager");
-    const runtimeFactory = createRuntimeWithOneShotSessionOptions(createRuntime, options.initialModel, options.delegationToolsEnabled);
+    const runtimeFactory = createRuntimeWithOneShotSessionOptions(createRuntime, options.initialModel, options.initialThinkingLevel, options.delegationToolsEnabled);
     return createAgentSessionRuntime(runtimeFactory, {
         cwd: options.cwd,
         agentDir: options.agentDir,
         sessionManager: options.sessionManager,
     });
 }
-function createRuntimeWithOneShotSessionOptions(createRuntime, initialModel, delegationToolsEnabled) {
+function createRuntimeWithOneShotSessionOptions(createRuntime, initialModel, initialThinkingLevel, delegationToolsEnabled) {
     // These inputs belong only to the session being opened. A later runtime
-    // replacement resolves its own model and delegation capability.
+    // replacement resolves its own model and delegation capability, and restores
+    // the thinking level from the existing session file.
     let pendingInitialModel = initialModel;
+    let pendingInitialThinkingLevel = initialThinkingLevel;
     let pendingDelegationToolsEnabled = delegationToolsEnabled;
     return async (options) => {
         const model = pendingInitialModel;
+        const thinkingLevel = pendingInitialThinkingLevel;
         const toolsEnabled = pendingDelegationToolsEnabled;
         pendingInitialModel = undefined;
+        pendingInitialThinkingLevel = undefined;
         pendingDelegationToolsEnabled = undefined;
         return createRuntime({
             ...options,
             ...(model === undefined ? {} : { initialModel: model }),
+            ...(thinkingLevel === undefined ? {} : { initialThinkingLevel: thinkingLevel }),
             ...(toolsEnabled === undefined ? {} : { delegationToolsEnabled: toolsEnabled }),
         });
     };
@@ -255,7 +276,7 @@ export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn,
     ];
 }
 function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subsessions, askUser) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, delegationToolsEnabled }) => {
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled }) => {
         const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime });
         const resolvedDelegationToolsEnabled = delegationToolsEnabled
             ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
@@ -266,6 +287,7 @@ function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subse
             customTools,
             ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
             ...(initialModel === undefined ? {} : { model: initialModel }),
+            ...(initialThinkingLevel === undefined ? {} : { thinkingLevel: initialThinkingLevel }),
         });
         return { ...result, services, diagnostics: services.diagnostics };
     };
@@ -325,8 +347,13 @@ export class PiSessionService {
         this.subsessionLinks = new Map();
         /** Parent id/file identities whose persisted links have already been loaded. */
         this.subsessionHydratedParents = new Set();
-        /** Session file path -> its parsed header. Headers are written once, so successful reads are cached. */
+        /**
+         * Session file path -> its parsed header and the file identity at read
+         * time. Headers are written once, so identity-verified reads are cached.
+         */
         this.sessionHeaderCache = new Map();
+        /** Session file path -> its in-flight header read, so concurrent scans share one read per file. */
+        this.pendingSessionHeaderReads = new Map();
         /**
          * Tracked subsession id -> whether a completion notification is armed.
          * Armed when the child starts working; firing on completion disarms it so a
@@ -340,18 +367,27 @@ export class PiSessionService {
         this.unreadPublicationFlushRequested = false;
         this.unreadPublicationStopped = false;
         /**
-         * Read a session file header, memoized per path. Pi writes the header once at
-         * session creation, so a successful read stays valid for the process lifetime;
-         * failures are not cached so a session file that appears later is picked up.
+         * Read a session file header, memoized per path, with one in-flight read
+         * per path: concurrent scans of a shared session directory share the read
+         * instead of each opening the file. Pi writes the header once at session
+         * creation, so a successful read stays valid as long as the path still
+         * holds the same file: every hit re-checks the file's identity (dev/ino),
+         * and a replacement landed at a cached path is re-read instead of serving
+         * the previous file's header — the summary scanner detects such
+         * replacements, so the listing and the header reads must agree. The one
+         * thing identity cannot detect is an in-place rewrite that keeps the
+         * inode; detach, the only such writer, deletes the entry itself. Failures
+         * are not cached so a session file that appears later is picked up.
          */
-        this.readCachedSessionHeader = async (sessionFile) => {
-            const cached = this.sessionHeaderCache.get(sessionFile);
-            if (cached !== undefined)
-                return cached;
-            const header = await readSessionHeaderSummary(sessionFile);
-            if (header !== undefined)
-                this.sessionHeaderCache.set(sessionFile, header);
-            return header;
+        this.readCachedSessionHeader = (sessionFile) => {
+            const pending = this.pendingSessionHeaderReads.get(sessionFile);
+            if (pending !== undefined)
+                return pending;
+            const read = this.loadSessionHeader(sessionFile).finally(() => {
+                this.pendingSessionHeaderReads.delete(sessionFile);
+            });
+            this.pendingSessionHeaderReads.set(sessionFile, read);
+            return read;
         };
         this.archiveStore = deps.archiveStore ?? new SessionArchiveStore();
         this.agentDir = deps.agentDir;
@@ -381,7 +417,7 @@ export class PiSessionService {
         this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
         this.workspaceActivity = deps.workspaceActivity;
         this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
-        this.commandService = new SessionCommandService((sessionId) => this.getActive(sessionId), (sessionId, text) => this.prompt(sessionId, text, undefined, undefined, { echoUserMessage: false }), events, {
+        this.commandService = new SessionCommandService((sessionId) => this.getActive(this.activeSessionRef(sessionId)), (sessionId, text) => this.prompt(this.activeSessionRef(sessionId), text, undefined, undefined, { echoUserMessage: false }), events, {
             onCompactionStart: (session) => {
                 this.beginSessionEntryMutation(session, "compact the session");
                 this.publishActivity(session, "compacting", "active");
@@ -465,7 +501,6 @@ export class PiSessionService {
             await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
             readyDeleteRecords.push(record);
         }
-        await this.ensureArchivedRecordsMoved(readyDeleteRecords);
         const deletedSessionIds = new Set(await this.archiveStoreDeleteArchivedMany(readyDeleteRecords.map((record) => record.sessionId)));
         deleteRecords.push(...readyDeleteRecords.filter((record) => deletedSessionIds.has(record.sessionId)));
         await this.forgetUnreadSessions(deleteRecords);
@@ -507,6 +542,7 @@ export class PiSessionService {
         this.subsessionHydratedParents.clear();
         this.subsessionNotifyArmed.clear();
         this.sessionHeaderCache.clear();
+        this.pendingSessionHeaderReads.clear();
         this.notificationStore.clearAll("service-dispose");
         await Promise.all(activeSessions.map(async (active) => {
             active.unsubscribe();
@@ -524,9 +560,7 @@ export class PiSessionService {
     async list(cwd) {
         const [sessions, archivedRecords] = await Promise.all([this.sessionManager.list(cwd), this.archiveStore.list()]);
         const sessionsById = new Map(sessions.map((session) => [session.id, session]));
-        const archivedForCwd = await Promise.all(archivedRecords
-            .filter((record) => record.cwd === cwd)
-            .map((record) => this.ensureArchivedSessionMoved(record, sessionsById.get(record.sessionId))));
+        const archivedForCwd = archivedRecords.filter((record) => record.cwd === cwd);
         const archivedById = new Map(archivedForCwd.map((record) => [record.sessionId, record]));
         for (const record of archivedForCwd) {
             this.publishNotificationMutations(this.notificationStore.clearSession(record.sessionId, "archive-reconcile"));
@@ -576,8 +610,10 @@ export class PiSessionService {
      *
      * Only sibling workspaces are scanned: agents may only spawn into workspaces
      * of the spawning session's own project, so that bounds where a child can be.
-     * Listing is skipped entirely when no project-workspace locator is configured
-     * or the cwd belongs to no registered project.
+     * Each sibling scan reads only the header line of every session file (the
+     * only place `parentSessionPath` is recorded), never the transcripts. Listing
+     * is skipped entirely when no project-workspace locator is configured or the
+     * cwd belongs to no registered project.
      */
     async countChildrenInSiblingWorkspaces(sessions, cwd) {
         if (this.projectWorkspaces === undefined || sessions.length === 0)
@@ -586,10 +622,7 @@ export class PiSessionService {
             const siblingCwds = await siblingWorkspaceCwds(this.projectWorkspaces, cwd);
             if (siblingCwds.length === 0)
                 return new Map();
-            const listings = await Promise.all(siblingCwds.map(async (siblingCwd) => {
-                const entries = await this.sessionManager.list(siblingCwd);
-                return entries.flatMap((entry) => entry.parentSessionPath === undefined ? [] : [entry.parentSessionPath]);
-            }));
+            const listings = await Promise.all(siblingCwds.map((siblingCwd) => this.sessionManager.listParentSessionPaths(siblingCwd, this.readCachedSessionHeader)));
             return countOutOfListingChildren(sessions, listings.flat());
         }
         catch (error) {
@@ -597,6 +630,27 @@ export class PiSessionService {
             return new Map();
         }
     }
+    async loadSessionHeader(sessionFile) {
+        let stats;
+        try {
+            stats = await stat(sessionFile);
+        }
+        catch {
+            // Gone or unreadable: report no header and forget any cached entry.
+            this.sessionHeaderCache.delete(sessionFile);
+            return undefined;
+        }
+        const cached = this.sessionHeaderCache.get(sessionFile);
+        if (cached?.dev === stats.dev && cached.ino === stats.ino)
+            return cached.header;
+        const header = await readSessionHeaderSummary(sessionFile);
+        if (header === undefined) {
+            this.sessionHeaderCache.delete(sessionFile);
+            return undefined;
+        }
+        this.sessionHeaderCache.set(sessionFile, { header, dev: stats.dev, ino: stats.ino });
+        return header;
+    }
     async start(cwd, options = {}) {
         return this.startSession(cwd, options);
     }
@@ -605,6 +659,7 @@ export class PiSessionService {
             startupIntent: "create",
             ...(options.startupToken === undefined ? {} : { startupToken: options.startupToken }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
             ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
         });
         const { session } = active.runtime;
@@ -637,10 +692,23 @@ export class PiSessionService {
         const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
         if (!decision.allowed)
             throw spawnTargetError(decision);
-        const created = await this.start(decision.cwd, input.model === undefined ? {} : { initialModel: input.model });
-        await this.prompt(created.id, input.prompt);
+        // A model spec overrides the inherited model. Only a spec resolves
+        // against the spawning session; the default path must not depend on it.
+        const model = input.modelSpec === undefined
+            ? input.model
+            : await this.resolveSpawnModel({ id: input.spawningSessionId, cwd: input.spawningCwd }, input.modelSpec);
+        const created = await this.start(decision.cwd, {
+            ...(model === undefined ? {} : { initialModel: model }),
+            ...(input.thinkingLevel === undefined ? {} : { initialThinkingLevel: input.thinkingLevel }),
+        });
+        const modelUsed = this.active.get(created.id)?.runtime.session.model;
+        await this.prompt(created, input.prompt);
         this.logger.info({ spawningCwd: input.spawningCwd, sessionId: created.id, cwd: decision.cwd, promptLength: input.prompt.length }, "spawn_session started a new session");
-        return { sessionId: created.id, cwd: decision.cwd };
+        return {
+            sessionId: created.id,
+            cwd: decision.cwd,
+            ...(modelUsed === undefined ? {} : { model: modelSpecOf(modelUsed) }),
+        };
     }
     /**
      * Start a *tracked* child session on behalf of a LLM. Identical to
@@ -654,11 +722,18 @@ export class PiSessionService {
         const decision = await this.spawnTargets.resolveSpawnTarget(input.spawningCwd, input.cwd);
         if (!decision.allowed)
             throw spawnTargetError(decision);
+        // A model spec overrides the inherited model and is resolved against the
+        // parent's model runtime; only a spec resolves against the parent.
+        const model = input.modelSpec === undefined
+            ? input.model
+            : await this.resolveSpawnModel({ id: input.parentSessionId, cwd: input.spawningCwd }, input.modelSpec);
         const created = await this.startSession(decision.cwd, {
             ...(input.parentSessionFile === undefined ? {} : { parentSession: input.parentSessionFile }),
-            ...(input.model === undefined ? {} : { initialModel: input.model }),
+            ...(model === undefined ? {} : { initialModel: model }),
+            ...(input.thinkingLevel === undefined ? {} : { initialThinkingLevel: input.thinkingLevel }),
             creationProvenance: "tracked-subsession",
         });
+        const modelUsed = this.active.get(created.id)?.runtime.session.model;
         const parentSessionFile = nonEmptyString(input.parentSessionFile);
         const link = {
             parentSessionId: input.parentSessionId,
@@ -670,9 +745,43 @@ export class PiSessionService {
         await this.registerVerifiedSubsession(link);
         this.persistSubsessionLink(link);
         this.persistSubsessionChildMarker(input.parentSessionId, created.id);
-        await this.prompt(created.id, input.prompt);
+        await this.prompt(created, input.prompt);
         this.logger.info({ parentSessionId: input.parentSessionId, sessionId: created.id, cwd: decision.cwd, promptLength: input.prompt.length }, "spawn_subsession started a tracked child session");
-        return { sessionId: created.id, cwd: decision.cwd };
+        return {
+            sessionId: created.id,
+            cwd: decision.cwd,
+            ...(modelUsed === undefined ? {} : { model: modelSpecOf(modelUsed) }),
+        };
+    }
+    /**
+     * The models a session may pick from: its scoped set when model-scoped,
+     * otherwise the runtime's available snapshot. Refreshes the runtime catalog
+     * first so callers see newly configured providers and models.
+     */
+    async sessionModelCandidates(session) {
+        await session.modelRuntime.refresh();
+        return session.scopedModels.length > 0
+            ? session.scopedModels.map((scoped) => scoped.model)
+            : session.modelRuntime.getAvailableSnapshot();
+    }
+    /**
+     * Resolve a strict `provider/model-id` spec from a spawn tool against the
+     * *spawning* session's model runtime, using the same candidates
+     * {@link setModel} offers plus a direct runtime lookup as fallback. Unknown
+     * or malformed specs throw; the agent loop turns that into an error tool
+     * result the spawning agent can retry from.
+     */
+    async resolveSpawnModel(spawningRef, modelSpec) {
+        const session = await this.getOrOpen(spawningRef);
+        const parsed = parseModelSpec(modelSpec);
+        const candidates = await this.sessionModelCandidates(session);
+        const model = parsed === undefined
+            ? undefined
+            : candidates.find((candidate) => candidate.provider === parsed.provider && candidate.id === parsed.modelId)
+                ?? session.modelRuntime.getModel(parsed.provider, parsed.modelId);
+        if (model === undefined)
+            throw unknownSpawnModelError(modelSpec);
+        return model;
     }
     /**
      * Register the question set an agent wants the user to answer as the session's
@@ -1240,26 +1349,20 @@ export class PiSessionService {
         const streamingMessage = session.state.streamingMessage;
         const partial = streamingMessage === undefined || streamingMessage === null
             ? null
-            : projectBrowserMessage(streamingMessage);
+            : annotateAssistantThinkingLevel(projectBrowserMessage(streamingMessage), session.thinkingLevel);
         return { seq, partial };
     }
     async availableModels(ref) {
         const session = await this.getOrOpen(ref);
-        await session.modelRuntime.refresh();
-        const models = session.scopedModels.length > 0
-            ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRuntime.getAvailableSnapshot();
+        const models = await this.sessionModelCandidates(session);
         return models.map(modelToClientModel);
     }
     async setModel(ref, provider, modelId) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref);
         this.assertTreeNavigationInactive(session, "change models");
-        await session.modelRuntime.refresh();
+        const candidates = await this.sessionModelCandidates(session);
         this.assertTreeNavigationInactive(session, "change models");
-        const candidates = session.scopedModels.length > 0
-            ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRuntime.getAvailableSnapshot();
         const model = candidates.find((candidate) => candidate.provider === provider && candidate.id === modelId)
             ?? session.modelRuntime.getModel(provider, modelId);
         if (model === undefined)
@@ -1432,7 +1535,7 @@ export class PiSessionService {
     async navigateTree(ref, request) {
         if (request.targetId.trim() === "")
             throw new Error("Session tree target is required");
-        if (this.isTreeExclusiveSessionIdentityActive(sessionIdFromLookup(ref))) {
+        if (this.isTreeExclusiveSessionIdentityActive(ref.id)) {
             throw new Error("Stop current session activity before navigating the session tree");
         }
         await this.assertWritable(ref);
@@ -1531,7 +1634,7 @@ export class PiSessionService {
         const uniqueRefs = uniqueBulkSessionRefs(refs);
         const [archivedRecords, sessionContext] = await Promise.all([
             this.archiveStore.list(),
-            this.bulkSessionLookupContext(uniqueRefs),
+            this.bulkSessionRefContext(uniqueRefs),
         ]);
         const failures = [];
         const alreadyArchivedSessionIds = [];
@@ -1545,7 +1648,7 @@ export class PiSessionService {
                 unreadArchivedIdentities.push(archived);
                 continue;
             }
-            const active = this.activeForLookup(bulkRefToLookup(ref));
+            const active = this.activeForRef(bulkRefToSessionRef(ref));
             const listed = findListedSessionForBulkRef(sessionContext, ref);
             const resolvedSessionId = active?.runtime.session.sessionId ?? listed?.id ?? ref.id;
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
@@ -1569,7 +1672,7 @@ export class PiSessionService {
         }
         const readyPlanItems = [];
         for (const item of planItems) {
-            const active = this.activeForLookup({ id: item.input.sessionId, cwd: item.input.cwd });
+            const active = this.activeForRef({ id: item.input.sessionId, cwd: item.input.cwd });
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
                 failures.push({ sessionId: item.input.sessionId, error: "Stop current session activity before archiving" });
                 continue;
@@ -1646,18 +1749,6 @@ export class PiSessionService {
         await this.archiveStore.restore(archived.sessionId);
         await this.forgetUnreadSessions([archived]);
     }
-    async deleteArchived(ref) {
-        const record = await this.getArchived(ref);
-        if (record === undefined)
-            throw new Error("Archived session not found");
-        if (this.archiveStore.deleteArchived === undefined)
-            throw new Error("Archive store does not support deletion");
-        await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" });
-        if (record.archivePath === undefined)
-            await this.ensureArchivedRecordMoved(record);
-        await this.archiveStore.deleteArchived(record.sessionId);
-        await this.forgetUnreadSessions([record]);
-    }
     async deleteArchivedMany(refs) {
         if (this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
@@ -1671,7 +1762,7 @@ export class PiSessionService {
                 failures.push({ sessionId: ref.id, error: "Archived session not found" });
                 continue;
             }
-            const active = this.activeForLookup({ id: record.sessionId, cwd: record.cwd });
+            const active = this.activeForRef({ id: record.sessionId, cwd: record.cwd });
             if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
                 failures.push({ sessionId: record.sessionId, error: "Stop current session activity before deleting archived session" });
                 continue;
@@ -1688,12 +1779,7 @@ export class PiSessionService {
                 failures.push({ sessionId: item.record.sessionId, error: errorMessage(error) });
             }
         }
-        const moveFailures = await this.moveLegacyArchivedRecordsForDelete(readyRecords);
-        failures.push(...moveFailures);
-        const moveFailureIds = new Set(moveFailures.map((failure) => failure.sessionId));
-        const deleteIds = readyRecords
-            .map((record) => record.sessionId)
-            .filter((sessionId) => !moveFailureIds.has(sessionId));
+        const deleteIds = readyRecords.map((record) => record.sessionId);
         let deletedSessionIds = [];
         try {
             deletedSessionIds = await this.archiveStoreDeleteArchivedMany(deleteIds);
@@ -1746,6 +1832,14 @@ export class PiSessionService {
         if (sessionFile === undefined || sessionFile === "")
             throw new Error("Session is not persisted");
         await clearParentSession(sessionFile);
+        // The header cache memoizes the first successful read, and detach is the
+        // only flow that rewrites a header; drop the stale entry so sibling child
+        // counts and parent locations observe the cleared parent immediately.
+        this.sessionHeaderCache.delete(sessionFile);
+        // The same in-place rewrite is invisible to the gateway's summary memo
+        // (same inode, possibly grown file), which would otherwise keep listing
+        // the old parent link and a stale message count until restart.
+        this.sessionManager.invalidateSessionFile(sessionFile);
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
         await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }]);
@@ -1765,7 +1859,7 @@ export class PiSessionService {
         return this.statusFromSession(session);
     }
     async abort(ref) {
-        const active = this.activeForLookup(ref);
+        const active = this.activeForRef(ref);
         if (active === undefined)
             return;
         const sessionId = active.runtime.session.sessionId;
@@ -1791,31 +1885,26 @@ export class PiSessionService {
         }
     }
     async stop(ref) {
-        const active = this.activeForLookup(ref);
+        const active = this.activeForRef(ref);
         if (active !== undefined) {
             await this.closeActive(active.runtime.session.sessionId);
             return;
         }
-        if (isPiSessionRef(ref)) {
-            this.publishNotificationMutations(this.notificationStore.clearSessionIdentity(ref.id, canonicalizeStoredCwd(ref.cwd), "runtime-close"));
+        // A session whose open is parked (e.g. on a session_start dialog) is not
+        // active yet; close it through the same path so stopping cannot block
+        // behind the dialog timeout.
+        const startup = this.startupSessionForRef(ref);
+        if (startup !== undefined) {
+            await this.closeActive(startup.sessionId);
             return;
         }
-        await this.closeActive(ref);
+        this.publishNotificationMutations(this.notificationStore.clearSessionIdentity(ref.id, canonicalizeStoredCwd(ref.cwd), "runtime-close"));
     }
-    async bulkSessionLookupContext(refs) {
+    async bulkSessionRefContext(refs) {
         const cwdSet = new Set();
-        let needsAllSessions = false;
-        for (const ref of refs) {
-            if (ref.cwd === undefined)
-                needsAllSessions = true;
-            else
-                cwdSet.add(ref.cwd);
-        }
-        const [sessionsByCwd, allSessions] = await Promise.all([
-            this.listSessionsByCwd([...cwdSet]),
-            needsAllSessions ? this.sessionManager.listAll?.() ?? Promise.resolve([]) : Promise.resolve(undefined),
-        ]);
-        return allSessions === undefined ? { sessionsByCwd } : { sessionsByCwd, allSessions };
+        for (const ref of refs)
+            cwdSet.add(ref.cwd);
+        return { sessionsByCwd: await this.listSessionsByCwd([...cwdSet]) };
     }
     async listSessionsByCwd(cwds) {
         const uniqueCwds = uniqueStrings(cwds);
@@ -1843,36 +1932,8 @@ export class PiSessionService {
             await this.archiveStore.deleteArchived(sessionId);
         return [...sessionIds];
     }
-    async moveLegacyArchivedRecordsForDelete(records) {
-        const legacyRecords = records.filter((record) => record.archivePath === undefined);
-        if (legacyRecords.length === 0)
-            return [];
-        let sessionsByCwd;
-        try {
-            sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
-        }
-        catch (error) {
-            return legacyRecords.map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
-        }
-        const moveInputs = legacyRecords
-            .map((record) => findSessionByIdOrPrefix(sessionsByCwd.get(record.cwd) ?? [], record.sessionId))
-            .filter(isDefined)
-            .map(archiveInputFromListEntry);
-        if (moveInputs.length === 0)
-            return [];
-        try {
-            await this.archiveStoreArchiveMany(moveInputs);
-            return [];
-        }
-        catch (error) {
-            const failedIds = new Set(moveInputs.map((input) => input.sessionId));
-            return legacyRecords
-                .filter((record) => failedIds.has(record.sessionId))
-                .map((record) => ({ sessionId: record.sessionId, error: errorMessage(error) }));
-        }
-    }
     async cleanupPlan(request) {
-        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.listAll?.() ?? [], this.archiveStore.list()]);
+        const [sessions, archivedRecords] = await Promise.all([this.sessionManager.listAll(), this.archiveStore.list()]);
         return planSessionCleanup({
             sessions,
             archivedRecords,
@@ -1901,34 +1962,6 @@ export class PiSessionService {
         }
         return [...sessionIds];
     }
-    async ensureArchivedSessionMoved(record, session) {
-        if (session === undefined || this.active.has(record.sessionId))
-            return record;
-        try {
-            return await this.archiveStore.archive(archiveInputFromListEntry(session));
-        }
-        catch {
-            return record;
-        }
-    }
-    async ensureArchivedRecordMoved(record) {
-        const session = (await this.sessionManager.list(record.cwd)).find((candidate) => candidate.id === record.sessionId);
-        if (session === undefined)
-            return record;
-        const [moved] = await this.archiveStoreArchiveMany([archiveInputFromListEntry(session)]);
-        return moved ?? record;
-    }
-    async ensureArchivedRecordsMoved(records) {
-        const legacyRecords = records.filter((record) => record.archivePath === undefined);
-        if (legacyRecords.length === 0)
-            return;
-        const sessionsByCwd = await this.listSessionsByCwd(legacyRecords.map((record) => record.cwd));
-        const moveInputs = legacyRecords
-            .map((record) => sessionsByCwd.get(record.cwd)?.find((candidate) => candidate.id === record.sessionId))
-            .filter(isDefined)
-            .map(archiveInputFromListEntry);
-        await this.archiveStoreArchiveMany(moveInputs);
-    }
     async archiveInputForSession(session) {
         const cwd = session.sessionManager.getCwd();
         const sessionFile = session.sessionFile;
@@ -2065,7 +2098,7 @@ export class PiSessionService {
         return (await this.getActive(ref)).runtime.session;
     }
     async getActive(ref, options = {}) {
-        const active = this.activeForLookup(ref);
+        const active = this.activeForRef(ref);
         if (active !== undefined)
             return active;
         const archived = await this.getArchived(ref);
@@ -2073,15 +2106,15 @@ export class PiSessionService {
             const { archivePath } = archived;
             return this.openExistingSession(archived.sessionId, archived.cwd, () => this.sessionManager.open(archivePath), { notifications: "disabled" });
         }
-        const match = isPiSessionRef(ref)
-            ? (await this.sessionManager.list(ref.cwd)).find((s) => s.id === ref.id || s.id.startsWith(ref.id))
-            : (await this.sessionManager.listAll?.() ?? []).find((s) => s.id === ref || s.id.startsWith(ref));
+        // Resolve the session file directly by id: opening one inactive session
+        // must not pay for a full transcript listing of its whole workspace.
+        const match = await this.sessionManager.resolveSessionFile(ref.cwd, ref.id, this.readCachedSessionHeader);
         if (!match)
             throw new Error("Session not found");
         return this.openExistingSession(match.id, match.cwd, () => this.sessionManager.open(match.path), options);
     }
     openExistingSession(sessionId, cwd, openSessionManager, options = {}) {
-        const active = this.activeForLookup({ id: sessionId, cwd });
+        const active = this.activeForRef({ id: sessionId, cwd });
         if (active !== undefined)
             return Promise.resolve(active);
         const key = JSON.stringify([canonicalizeStoredCwd(cwd), sessionId]);
@@ -2105,34 +2138,45 @@ export class PiSessionService {
             .map((pending) => pending.promise);
     }
     async getArchived(ref) {
-        const archived = await this.archiveStore.get(sessionIdFromLookup(ref));
+        const archived = await this.archiveStore.get(ref.id);
         if (archived === undefined)
             return undefined;
-        if (isPiSessionRef(ref) && archived.cwd !== ref.cwd)
+        if (archived.cwd !== ref.cwd)
             return undefined;
         return archived;
     }
     isCurrentActiveSession(session) {
         return this.active.get(session.sessionId)?.runtime.session === session;
     }
-    activeForLookup(ref) {
-        const sessionId = sessionIdFromLookup(ref);
+    /**
+     * The command service tracks sessions by id alone; its callbacks only ever
+     * run against a session the caller just resolved as active, so the cwd
+     * needed for a full ref comes from that active runtime.
+     */
+    activeSessionRef(sessionId) {
+        const active = this.active.get(sessionId);
+        if (active === undefined)
+            throw new Error("Session not found");
+        return { id: sessionId, cwd: active.runtime.cwd };
+    }
+    activeForRef(ref) {
+        const sessionId = ref.id;
         const exact = this.active.get(sessionId);
-        if (exact !== undefined && lookupMatchesActiveSession(ref, exact))
+        if (exact !== undefined && refMatchesActiveSession(ref, exact))
             return exact;
         for (const [candidateId, active] of this.active.entries()) {
-            if (candidateId.startsWith(sessionId) && lookupMatchesActiveSession(ref, active))
+            if (candidateId.startsWith(sessionId) && refMatchesActiveSession(ref, active))
                 return active;
         }
         return undefined;
     }
-    startupSessionForLookup(ref) {
-        const sessionId = sessionIdFromLookup(ref);
+    startupSessionForRef(ref) {
+        const sessionId = ref.id;
         const exact = this.startupSessions.get(sessionId);
-        if (exact !== undefined && lookupMatchesStartupSession(ref, exact))
+        if (exact !== undefined && refMatchesStartupSession(ref, exact))
             return exact;
         for (const [candidateId, session] of this.startupSessions.entries()) {
-            if (candidateId.startsWith(sessionId) && lookupMatchesStartupSession(ref, session))
+            if (candidateId.startsWith(sessionId) && refMatchesStartupSession(ref, session))
                 return session;
         }
         return undefined;
@@ -2144,7 +2188,7 @@ export class PiSessionService {
      * its status projection).
      */
     async sessionForStatusOrDialogClose(ref) {
-        const reachable = this.activeForLookup(ref)?.runtime.session ?? this.startupSessionForLookup(ref);
+        const reachable = this.activeForRef(ref)?.runtime.session ?? this.startupSessionForRef(ref);
         if (reachable !== undefined)
             return reachable;
         return this.getOrOpen(ref);
@@ -2175,6 +2219,7 @@ export class PiSessionService {
             sessionManager,
             delegationToolsEnabled,
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.initialThinkingLevel === undefined ? {} : { initialThinkingLevel: options.initialThinkingLevel }),
         });
         const active = { runtime, unsubscribe: noop };
         let boundSession = runtime.session;
@@ -2322,14 +2367,6 @@ export class PiSessionService {
             }
             const added = this.notificationStore.addNotification(generation, message, type);
             this.publishNotificationMutations(added.mutations);
-            if (added.notification === undefined)
-                return;
-            this.events.publish(session.sessionId, {
-                type: "command.output",
-                level: type === "error" ? "error" : "info",
-                message,
-                notificationId: added.notification.id,
-            });
         };
         // PI WEB owns the browser-facing dialog, notification, and text-formatting
         // boundaries: the three dialog primitives park daemon-held Promises that
@@ -2476,7 +2513,7 @@ export class PiSessionService {
             }
         }
         active.unsubscribe = session.subscribe((event) => {
-            this.events.publish(session.sessionId, toClientEvent(event));
+            this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel));
             this.publishActivityForEvent(session, event);
             const eventType = getString(event, "type");
             if (eventType === "agent_end")
@@ -2957,7 +2994,7 @@ function uniqueBulkSessionRefs(refs) {
     const seen = new Set();
     const unique = [];
     for (const ref of refs) {
-        const key = `${ref.cwd ?? ""}\0${ref.id}`;
+        const key = `${ref.cwd}\0${ref.id}`;
         if (seen.has(key))
             continue;
         seen.add(key);
@@ -2965,16 +3002,14 @@ function uniqueBulkSessionRefs(refs) {
     }
     return unique;
 }
-function bulkRefToLookup(ref) {
-    return ref.cwd === undefined ? ref.id : { id: ref.id, cwd: ref.cwd };
+function bulkRefToSessionRef(ref) {
+    return { id: ref.id, cwd: ref.cwd };
 }
 function findArchivedRecordForBulkRef(records, ref) {
-    return records.find((record) => (ref.cwd === undefined || record.cwd === ref.cwd) && (record.sessionId === ref.id || record.sessionId.startsWith(ref.id)));
+    return records.find((record) => record.cwd === ref.cwd && (record.sessionId === ref.id || record.sessionId.startsWith(ref.id)));
 }
 function findListedSessionForBulkRef(context, ref) {
-    if (ref.cwd !== undefined)
-        return findSessionByIdOrPrefix(context.sessionsByCwd.get(ref.cwd) ?? [], ref.id);
-    return context.allSessions === undefined ? undefined : findSessionByIdOrPrefix(context.allSessions, ref.id);
+    return findSessionByIdOrPrefix(context.sessionsByCwd.get(ref.cwd) ?? [], ref.id);
 }
 function findSessionByIdOrPrefix(sessions, sessionId) {
     return sessions.find((session) => session.id === sessionId) ?? sessions.find((session) => session.id.startsWith(sessionId));
@@ -3357,13 +3392,34 @@ function buildPromptOptions(behavior, images) {
 function stringValue(value) {
     return typeof value === "string" ? value : "";
 }
+/**
+ * Attach the thinking level in effect when an assistant message was generated,
+ * so chat bubbles can show it next to the model. Non-assistant messages pass
+ * through by reference; assistant messages are copied only when a level is set.
+ * "off" is the absence of thinking, not a level worth labeling on every bubble.
+ */
+function annotateAssistantThinkingLevel(message, thinkingLevel) {
+    if (thinkingLevel === undefined || thinkingLevel === "" || thinkingLevel === "off")
+        return message;
+    if (!isRecord(message) || message["role"] !== "assistant")
+        return message;
+    return { ...message, thinkingLevel };
+}
 function historyMessages(session) {
     const messages = [];
+    // Pi records the initial level at session creation and every later change, so
+    // walking the branch yields the level in effect for each assistant message.
+    let thinkingLevel;
     for (const entry of session.sessionManager.getBranch()) {
         if (!isRecord(entry))
             continue;
         if (entry["type"] === "message")
-            messages.push(entry["message"]);
+            messages.push(annotateAssistantThinkingLevel(entry["message"], thinkingLevel));
+        else if (entry["type"] === "thinking_level_change") {
+            const level = getString(entry, "thinkingLevel");
+            if (level !== undefined)
+                thinkingLevel = level;
+        }
         else if (entry["type"] === "custom_message" && entry["display"] === true)
             messages.push({ role: "custom", content: entry["content"], customType: entry["customType"], details: entry["details"] });
         else if (entry["type"] === "compaction")
@@ -3408,7 +3464,7 @@ function finalAssistantText(messages) {
     }
     return "";
 }
-function toClientEvent(event) {
+function toClientEvent(event, thinkingLevel) {
     const eventType = getString(event, "type");
     const assistantMessageEvent = getProperty(event, "assistantMessageEvent");
     if (eventType === "message_update" && getString(assistantMessageEvent, "type") === "text_delta") {
@@ -3435,7 +3491,9 @@ function toClientEvent(event) {
         return { type: "agent.end" };
     if (eventType === "message_end") {
         const message = getProperty(event, "message");
-        return message === undefined ? { type: "message.end" } : { type: "message.end", message };
+        if (message === undefined)
+            return { type: "message.end" };
+        return { type: "message.end", message: annotateAssistantThinkingLevel(message, thinkingLevel) };
     }
     return { type: "pi.event", eventType: eventType ?? "unknown" };
 }