@jmfederico/pi-web 1.202606.7 → 1.202607.1

package/dist/server/sessions/piSessionService.js

@@ -1,16 +1,18 @@
+import { statSync } from "node:fs";
+import { join } from "node:path";
 import { open, readFile, writeFile } from "node:fs/promises";
-import { AuthStorage, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, defineTool, getAgentDir, ModelRegistry, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, defineTool, readStoredCredential, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { projectBrowserMessage } from "../browserMessageProjection.js";
 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 { deterministicSessionName, 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 { cwdPathsEqual } from "../workingDirectory.js";
+import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
 import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
 import { createSubsessionToolDefinitions } from "./spawnSubsessionTool.js";
 import { buildTranscriptView } from "./subsessionTranscript.js";
@@ -48,23 +50,154 @@ function parsePromptStreamingBehavior(value) {
         return value;
     throw new Error('Prompt streamingBehavior must be "steer" or "followUp"');
 }
+function resourceDiagnosticToWarning(diagnostic, source) {
+    return {
+        severity: diagnostic.type === "error" ? "error" : "warning",
+        message: diagnostic.message,
+        source,
+        ...(diagnostic.path === undefined ? {} : { path: diagnostic.path }),
+    };
+}
+function runtimeDiagnosticToWarning(diagnostic) {
+    return { severity: diagnostic.type, message: diagnostic.message, source: "runtime" };
+}
+/**
+ * Compute the live warnings for a runtime by re-reading its current resource
+ * loader diagnostics, extension load errors, and runtime setup diagnostics.
+ *
+ * This mimics the TUI recomputing warnings on every (re)bind: it reads the
+ * runtime's current state rather than a cached snapshot, so a rebuilt runtime
+ * yields fresh warnings. Runtimes without SDK services (e.g. test fakes)
+ * contribute no warnings.
+ */
+export function collectRuntimeWarnings(runtime) {
+    const warnings = [];
+    for (const diagnostic of runtime.diagnostics ?? [])
+        warnings.push(runtimeDiagnosticToWarning(diagnostic));
+    const resourceLoader = runtime.services?.resourceLoader;
+    if (resourceLoader !== undefined) {
+        for (const diagnostic of resourceLoader.getSkills().diagnostics)
+            warnings.push(resourceDiagnosticToWarning(diagnostic, "skill"));
+        for (const diagnostic of resourceLoader.getPrompts().diagnostics)
+            warnings.push(resourceDiagnosticToWarning(diagnostic, "prompt"));
+        for (const diagnostic of resourceLoader.getThemes().diagnostics)
+            warnings.push(resourceDiagnosticToWarning(diagnostic, "theme"));
+        for (const error of resourceLoader.getExtensions().errors) {
+            warnings.push({ severity: "error", message: `${error.path}: ${error.error}`, source: "extension", path: error.path });
+        }
+    }
+    return warnings;
+}
+/**
+ * Verbatim TUI wording for the Anthropic subscription-auth billing notice. Kept
+ * character-for-character in sync with `ANTHROPIC_SUBSCRIPTION_AUTH_WARNING` in
+ * the SDK's interactive mode so the browser shows the same message the TUI does.
+ */
+const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
+/** Mirror of the SDK TUI `isAnthropicSubscriptionAuthKey` (subscription API keys start with `sk-ant-oat`). */
+function isAnthropicSubscriptionAuthKey(apiKey) {
+    return typeof apiKey === "string" && apiKey.startsWith("sk-ant-oat");
+}
+/**
+ * Dismiss id for the Anthropic subscription-auth billing notice. This is `pi`'s
+ * own `WarningSettings` key verbatim (`anthropicExtraUsage`): we carry the
+ * coupling `pi` already defines rather than inventing a parallel vocabulary, and
+ * {@link dismissSessionWarning} maps it back to `setWarnings`.
+ */
+const ANTHROPIC_EXTRA_USAGE_DISMISS_ID = "anthropicExtraUsage";
+/**
+ * Port of the TUI `maybeWarnAboutAnthropicSubscriptionAuth` gate/trigger, computed
+ * live from the session's current model, stored Anthropic credential, and warning
+ * settings. Returns the billing warning when the active provider is `anthropic`
+ * and auth is a subscription credential (stored `oauth`, or an `sk-ant-oat` API
+ * key), unless suppressed via `getWarnings().anthropicExtraUsage === false`.
+ *
+ * The stored credential is read synchronously (matching the TUI's `oauth` branch
+ * and the documented `sk-ant-oat` key trigger) so warnings stay part of the
+ * synchronous live status computation.
+ */
+export function anthropicSubscriptionWarning(session, authPath) {
+    if (session.settingsManager.getWarnings().anthropicExtraUsage === false)
+        return undefined;
+    if (session.model?.provider !== "anthropic")
+        return undefined;
+    const credential = readStoredCredential("anthropic", authPath);
+    if (credential === undefined)
+        return undefined;
+    const isSubscriptionAuth = credential.type === "oauth"
+        ? true
+        : isAnthropicSubscriptionAuthKey(credential.key);
+    if (!isSubscriptionAuth)
+        return undefined;
+    return {
+        severity: "warning",
+        message: ANTHROPIC_SUBSCRIPTION_AUTH_WARNING,
+        source: "anthropic",
+        dismiss: { id: ANTHROPIC_EXTRA_USAGE_DISMISS_ID },
+    };
+}
+/**
+ * Durably suppress a dismissable session warning by mapping its opaque dismiss
+ * id back to the concrete `pi` suppression it represents. Only known ids are
+ * honored; unknown ids throw so a stale/forged client cannot silently no-op.
+ *
+ * This is the single place provider-specific suppression lives: the wire type,
+ * parser, and UI stay agnostic. Adding a future dismissable warning is a
+ * server-only change here plus a `dismiss` id on its producer.
+ */
+export function dismissSessionWarning(session, dismissId) {
+    if (dismissId !== ANTHROPIC_EXTRA_USAGE_DISMISS_ID) {
+        throw new Error(`Unknown session warning dismiss id: ${dismissId}`);
+    }
+    session.settingsManager.setWarnings({ ...session.settingsManager.getWarnings(), anthropicExtraUsage: false });
+}
 function defaultCreateAgentRuntime(createRuntime, options) {
     if (!(options.sessionManager instanceof SessionManager))
         throw new Error("Default runtime creation requires an SDK SessionManager");
-    return createAgentSessionRuntime(createRuntime, { ...options, sessionManager: options.sessionManager });
-}
-function createDefaultRuntimeFactory(authStorage, modelRegistry, spawn, subsessions) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
-        const services = await createAgentSessionServices({ cwd, agentDir, authStorage, modelRegistry });
-        const customTools = [
-            createPiWebEditToolDefinition(cwd),
-            ...(spawn === undefined ? [] : [createSpawnSessionToolDefinition(cwd, { spawn })]),
-            ...(subsessions === undefined ? [] : createSubsessionToolDefinitions(cwd, subsessions)),
-        ];
-        const options = sessionStartEvent === undefined
-            ? { services, sessionManager, customTools }
-            : { services, sessionManager, sessionStartEvent, customTools };
-        const result = await createAgentSessionFromServices(options);
+    const runtimeFactory = createRuntimeWithOneShotSessionOptions(createRuntime, options.initialModel, options.delegationToolsEnabled);
+    return createAgentSessionRuntime(runtimeFactory, {
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+        sessionManager: options.sessionManager,
+    });
+}
+function createRuntimeWithOneShotSessionOptions(createRuntime, initialModel, delegationToolsEnabled) {
+    // These inputs belong only to the session being opened. A later runtime
+    // replacement resolves its own model and delegation capability.
+    let pendingInitialModel = initialModel;
+    let pendingDelegationToolsEnabled = delegationToolsEnabled;
+    return async (options) => {
+        const model = pendingInitialModel;
+        const toolsEnabled = pendingDelegationToolsEnabled;
+        pendingInitialModel = undefined;
+        pendingDelegationToolsEnabled = undefined;
+        return createRuntime({
+            ...options,
+            ...(model === undefined ? {} : { initialModel: model }),
+            ...(toolsEnabled === undefined ? {} : { delegationToolsEnabled: toolsEnabled }),
+        });
+    };
+}
+export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions) {
+    return [
+        createPiWebEditToolDefinition(cwd),
+        ...(delegationEnabled && spawn !== undefined ? [createSpawnSessionToolDefinition(cwd, { spawn })] : []),
+        ...(delegationEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions) : []),
+    ];
+}
+function createDefaultRuntimeFactory(modelRuntime, sessionManagers, spawn, subsessions) {
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, delegationToolsEnabled }) => {
+        const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime });
+        const resolvedDelegationToolsEnabled = delegationToolsEnabled
+            ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
+        const customTools = createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions);
+        const result = await createAgentSessionFromServices({
+            services,
+            sessionManager,
+            customTools,
+            ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
+            ...(initialModel === undefined ? {} : { model: initialModel }),
+        });
         return { ...result, services, diagnostics: services.diagnostics };
     };
 }
@@ -90,9 +223,10 @@ function createPiWebEditToolDefinition(cwd) {
     });
 }
 export class PiSessionService {
-    constructor(events, deps = {}) {
+    constructor(events, deps) {
         this.events = events;
         this.active = new Map();
+        this.pendingSessionOpens = new Map();
         this.activities = new Map();
         this.compactionPromptQueues = new Map();
         this.compactionDrainTimers = new Map();
@@ -112,16 +246,16 @@ export class PiSessionService {
          */
         this.subsessionNotifyArmed = new Map();
         this.archiveStore = deps.archiveStore ?? new SessionArchiveStore();
-        this.agentDir = deps.agentDir ?? getAgentDir();
-        this.sessionManager = deps.sessionManager ?? createPiSessionManagerGateway({ agentDir: this.agentDir });
-        this.modelRegistry = deps.modelRegistry ?? ModelRegistry.create(AuthStorage.create());
+        this.agentDir = deps.agentDir;
+        this.sessionManager = deps.sessionManager;
+        this.modelRuntime = deps.modelRuntime;
         this.spawnTargets = deps.spawnTargets;
         this.logger = deps.logger ?? noopLogger;
         this.now = deps.now ?? (() => new Date());
         // Subsessions are a beta capability gated behind their own flag, and they
         // also require the spawn capability (they share its project-scope resolver).
         const subsessionsActive = this.spawnTargets !== undefined && deps.subsessionsEnabled === true;
-        this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.modelRegistry.authStorage, this.modelRegistry, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
+        this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.modelRuntime, this.sessionManager, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
             spawn: (input) => this.spawnSubsession(input),
             list: (parentSessionId, parentSessionFile) => this.listSubsessions(parentSessionId, parentSessionFile),
             check: (parentSessionId, sessionId, parentSessionFile) => this.checkSubsession(parentSessionId, sessionId, parentSessionFile),
@@ -139,6 +273,7 @@ export class PiSessionService {
                 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() {
@@ -149,10 +284,12 @@ export class PiSessionService {
     }
     async cleanup(request) {
         const plan = await this.cleanupPlan(request);
-        if (plan.deleteRecords.length > 0 && this.archiveStore.deleteArchived === undefined)
+        if (plan.deleteRecords.length > 0 && this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
             throw new Error("Archive store does not support deletion");
         const archiveInputs = [];
+        const readyArchiveInputs = [];
         const deleteRecords = [];
+        const readyDeleteRecords = [];
         const skippedBusySessionIds = new Set(plan.skippedBusySessionIds);
         for (const input of plan.archiveInputs) {
             if (this.activeSessionHasWork(input.sessionId)) {
@@ -160,20 +297,21 @@ export class PiSessionService {
                 continue;
             }
             await this.closeActive(input.sessionId);
-            await this.archiveStore.archive(input);
-            archiveInputs.push(input);
+            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);
-            if (record.archivePath === undefined)
-                await this.ensureArchivedRecordMoved(record);
-            await this.archiveStore.deleteArchived?.(record.sessionId);
-            deleteRecords.push(record);
+            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,
@@ -185,8 +323,12 @@ export class PiSessionService {
     async dispose() {
         clearInterval(this.heartbeat);
         this.clearCompactionDrainTimers();
+        const pendingOpens = this.pendingSessionOpenPromises();
+        if (pendingOpens.length > 0)
+            await Promise.allSettled(pendingOpens);
         const activeSessions = Array.from(new Set(this.active.values()));
         this.active.clear();
+        this.pendingSessionOpens.clear();
         this.activities.clear();
         this.compactionPromptQueues.clear();
         this.authLossWarnings.clear();
@@ -198,8 +340,12 @@ export class PiSessionService {
         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();
+            try {
+                await active.runtime.session.abort();
+            }
+            finally {
+                await active.runtime.dispose();
+            }
         }));
     }
     async list(cwd) {
@@ -217,20 +363,27 @@ export class PiSessionService {
             .filter(isDefined);
         return [...unarchivedSessions, ...archivedSessions];
     }
-    async start(cwd, parentSession) {
-        const active = await this.create(this.sessionManager.create(cwd, parentSession === undefined ? undefined : { parentSession }), cwd);
+    async start(cwd, options = {}) {
+        return this.startSession(cwd, options);
+    }
+    async startSession(cwd, options) {
+        const active = await this.create(this.sessionManager.create(cwd, options.parentSession === undefined ? undefined : { parentSession: options.parentSession }), cwd, {
+            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
+        });
         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.
-            ...(parentSession === undefined ? {} : { parentSessionPath: parentSession }),
+            ...(options.parentSession === undefined ? {} : { parentSessionPath: options.parentSession }),
         };
         // Broadcast so other clients (and the spawning agent's UI) can add the new
         // session to their list without a manual reload.
@@ -248,7 +401,7 @@ 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);
+        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 };
@@ -265,7 +418,11 @@ 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.parentSessionFile);
+        const created = await this.startSession(decision.cwd, {
+            ...(input.parentSessionFile === undefined ? {} : { parentSession: input.parentSessionFile }),
+            ...(input.model === undefined ? {} : { initialModel: input.model }),
+            creationProvenance: "tracked-subsession",
+        });
         const parentSessionFile = nonEmptyString(input.parentSessionFile);
         const link = {
             parentSessionId: input.parentSessionId,
@@ -465,61 +622,13 @@ export class PiSessionService {
             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 = 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(),
-        };
-    }
-    findReciprocalParentSubsessionLink(parentSessionFile, parentSessionId, childSessionId, childSessionFile) {
-        let parentManager;
-        try {
-            parentManager = 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;
+    verifiedSubsessionLinkFromOpenedChild(session) {
+        return verifiedTrackedSubsessionLink(this.sessionManager, {
+            sessionId: session.sessionId,
+            sessionFile: session.sessionFile,
+            sessionManager: session.sessionManager,
+            cwd: session.sessionManager.getCwd(),
+        });
     }
     async getOrOpenTrackedSubsession(sessionId) {
         const link = this.subsessionLinks.get(sessionId);
@@ -556,6 +665,16 @@ export class PiSessionService {
             return "error";
         return "idle";
     }
+    workingSubsessionIds(parentSessionId) {
+        const childIds = this.subsessionChildren.get(parentSessionId);
+        if (childIds === undefined)
+            return [];
+        return [...childIds].filter((childId) => {
+            const link = this.subsessionLinks.get(childId);
+            const active = link === undefined ? undefined : this.activeChildForSubsessionLink(link);
+            return active !== undefined && this.hasActiveWork(active.runtime.session);
+        });
+    }
     /**
      * 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
@@ -576,8 +695,12 @@ export class PiSessionService {
         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.`;
+        const outputSection = formatSubsessionNotificationOutput(childId, finalText);
+        const workingIds = this.workingSubsessionIds(link.parentSessionId);
+        const next = workingIds.length === 0
+            ? "No other tracked subsessions are working."
+            : `Still working: ${workingIds.join(", ")}. Continue working, or call yield_to_subsessions alone and last at the next join point. Further completion notices arrive automatically; do not poll.`;
+        const text = `Subsession ${childId} stopped working (${status}).\n${next}\n\n${outputSection}`;
         void this.notifyParentOfSubsession(link.parentSessionId, childId, text);
     }
     async getOrOpenParentForSubsession(parentSessionId, childSessionId) {
@@ -620,23 +743,42 @@ export class PiSessionService {
     async status(ref) {
         return this.statusFromSession(await this.getOrOpen(ref));
     }
+    /**
+     * Join-time snapshot of the in-flight assistant stream. The `seq` watermark and
+     * the partial are read together in one synchronous tick (no await between the
+     * `currentSeq` read and the `state.streamingMessage` read) so a joining client
+     * can seed the partial and then apply only buffered live events with
+     * `seq > snapshot.seq`. The partial is browser-projected to strip thinking
+     * signatures; it is `null` when no assistant message is mid-stream.
+     */
+    async streamSnapshot(ref) {
+        const session = await this.getOrOpen(ref);
+        // Single consistent tick: capture the watermark and the partial together so
+        // the seq matches the partial the client seeds against.
+        const seq = this.events.currentSeq(session.sessionId);
+        const streamingMessage = session.state.streamingMessage;
+        const partial = streamingMessage === undefined || streamingMessage === null
+            ? null
+            : projectBrowserMessage(streamingMessage);
+        return { seq, partial };
+    }
     async availableModels(ref) {
         const session = await this.getOrOpen(ref);
-        session.modelRegistry.refresh();
+        await session.modelRuntime.reloadConfig();
         const models = session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRegistry.getAvailable();
+            : session.modelRuntime.getAvailableSnapshot();
         return models.map(modelToClientModel);
     }
     async setModel(ref, provider, modelId) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref);
-        session.modelRegistry.refresh();
+        await session.modelRuntime.reloadConfig();
         const candidates = session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRegistry.getAvailable();
+            : session.modelRuntime.getAvailableSnapshot();
         const model = candidates.find((candidate) => candidate.provider === provider && candidate.id === modelId)
-            ?? session.modelRegistry.find(provider, modelId);
+            ?? session.modelRuntime.getModel(provider, modelId);
         if (model === undefined)
             throw new Error(`Model not found: ${provider}/${modelId}`);
         await session.setModel(model);
@@ -795,6 +937,23 @@ export class PiSessionService {
         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);
         if (this.hasActiveWork(session))
@@ -803,6 +962,69 @@ export class PiSessionService {
         await this.closeActive(session.sessionId);
         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;
+            if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
+                failures.push({ sessionId: resolvedSessionId, error: "Stop current session activity before archiving" });
+                continue;
+            }
+            try {
+                if (listed !== undefined) {
+                    planItems.push({ input: archiveInputFromListEntry(listed) });
+                }
+                else if (active !== undefined) {
+                    planItems.push({ input: archiveInputFromActiveSession(active.runtime.session) });
+                }
+                else {
+                    failures.push({ sessionId: ref.id, error: "Session not found" });
+                }
+            }
+            catch (error) {
+                failures.push({ sessionId: resolvedSessionId, error: errorMessage(error) });
+            }
+        }
+        const readyInputs = [];
+        for (const item of planItems) {
+            try {
+                await this.closeActive(item.input.sessionId);
+                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: uniqueStrings(archivedSessionIds),
+            failures,
+            generatedAt: new Date().toISOString(),
+        };
+    }
     async archiveTree(ref) {
         const session = await this.getOrOpen(ref);
         const catalog = await this.workspaceArchiveCandidates(session.sessionManager.getCwd());
@@ -814,8 +1036,7 @@ export class PiSessionService {
         const archiveInputs = plan.unarchivedTargets.map((target) => archiveInputFromCandidate(target));
         for (const input of archiveInputs)
             await this.closeActive(input.sessionId);
-        for (const input of archiveInputs)
-            await this.archiveStore.archive(input);
+        await this.archiveStoreArchiveMany(archiveInputs);
         return {
             archived: true,
             sessionIds: archiveInputs.map((input) => input.sessionId),
@@ -841,6 +1062,57 @@ export class PiSessionService {
             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);
@@ -859,6 +1131,20 @@ export class PiSessionService {
         clearParentSessionHeader(session.sessionManager);
         this.unregisterSubsession(session.sessionId);
     }
+    async clearQueue(ref) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        this.clearCompactionPromptQueue(session.sessionId);
+        clearSessionQueue(session);
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    async dismissWarning(ref, dismissId) {
+        const session = await this.getOrOpen(ref);
+        dismissSessionWarning(session, dismissId);
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
     async abort(ref) {
         const active = this.activeForLookup(ref);
         if (active === undefined)
@@ -878,6 +1164,75 @@ export class PiSessionService {
             // 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({
@@ -922,7 +1277,19 @@ export class PiSessionService {
         const session = (await this.sessionManager.list(record.cwd)).find((candidate) => candidate.id === record.sessionId);
         if (session === undefined)
             return record;
-        return this.archiveStore.archive(archiveInputFromListEntry(session));
+        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();
@@ -985,6 +1352,9 @@ export class PiSessionService {
         return [...names];
     }
     async closeActive(sessionId) {
+        const pendingOpens = this.pendingSessionOpenPromises(sessionId);
+        if (pendingOpens.length > 0)
+            await Promise.allSettled(pendingOpens);
         const active = this.active.get(sessionId);
         if (!active)
             return;
@@ -1019,14 +1389,40 @@ export class PiSessionService {
         if (active !== undefined)
             return active;
         const archived = await this.getArchived(ref);
-        if (archived?.archivePath !== undefined)
-            return this.create(this.sessionManager.open(archived.archivePath), archived.cwd);
+        if (archived?.archivePath !== undefined) {
+            const { archivePath } = archived;
+            return this.openExistingSession(archived.sessionId, archived.cwd, () => this.sessionManager.open(archivePath));
+        }
         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(this.sessionManager.open(match.path), match.cwd);
+        return this.openExistingSession(match.id, match.cwd, () => this.sessionManager.open(match.path));
+    }
+    openExistingSession(sessionId, cwd, openSessionManager) {
+        const active = this.activeForLookup({ id: sessionId, cwd });
+        if (active !== undefined)
+            return Promise.resolve(active);
+        const key = JSON.stringify([canonicalizeStoredCwd(cwd), sessionId]);
+        const existing = this.pendingSessionOpens.get(key);
+        if (existing !== undefined)
+            return existing.promise;
+        const pending = {
+            sessionId,
+            promise: this.create(openSessionManager(), cwd),
+        };
+        pending.promise = pending.promise.finally(() => {
+            if (this.pendingSessionOpens.get(key) === pending)
+                this.pendingSessionOpens.delete(key);
+        });
+        this.pendingSessionOpens.set(key, pending);
+        return pending.promise;
+    }
+    pendingSessionOpenPromises(sessionId) {
+        return [...this.pendingSessionOpens.values()]
+            .filter((pending) => sessionId === undefined || pending.sessionId === sessionId)
+            .map((pending) => pending.promise);
     }
     async getArchived(ref) {
         const archived = await this.archiveStore.get(sessionIdFromLookup(ref));
@@ -1047,23 +1443,77 @@ export class PiSessionService {
         }
         return undefined;
     }
-    async create(sessionManager, cwd) {
-        const runtime = await this.createAgentRuntime(this.createRuntime, { cwd, agentDir: this.agentDir, sessionManager });
-        await this.bindSessionExtensions(runtime.session);
+    async create(sessionManager, cwd, options = {}) {
+        const delegationToolsEnabled = options.creationProvenance !== "tracked-subsession"
+            && await sessionAllowsDelegationTools(sessionManager, this.sessionManager);
+        const runtime = await this.createAgentRuntime(this.createRuntime, {
+            cwd,
+            agentDir: this.agentDir,
+            sessionManager,
+            delegationToolsEnabled,
+            ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+        });
         const active = { runtime, unsubscribe: noop };
-        this.bindRuntime(active);
-        runtime.setRebindSession(async (session) => {
-            await this.bindSessionExtensions(session);
+        try {
+            await this.bindSessionExtensions(runtime.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;
+            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;
+        }
+        catch (error) {
+            active.unsubscribe();
+            let removedActive = false;
+            for (const [sessionId, candidate] of this.active.entries()) {
+                if (candidate !== active)
+                    continue;
+                this.active.delete(sessionId);
+                this.activities.delete(sessionId);
+                this.clearAuthLossWarningsForSession(sessionId);
+                this.clearCompactionPromptQueue(sessionId);
+                removedActive = true;
+            }
+            if (removedActive) {
+                this.workspaceActivity?.removeSession(runtime.session.sessionId, runtime.session.sessionManager.getCwd());
+            }
+            try {
+                await runtime.session.abort();
+            }
+            finally {
+                await runtime.dispose();
+            }
+            throw error;
+        }
     }
     async bindSessionExtensions(session) {
+        const baseUiContext = session.extensionRunner.getUIContext();
+        const notify = (message, type) => {
+            this.events.publish(session.sessionId, {
+                type: "command.output",
+                level: type === "error" ? "error" : "info",
+                message,
+            });
+        };
+        // PI WEB is a remote UI host, but currently only extension notifications
+        // cross this boundary. Delegate every other UI method to Pi's headless
+        // defaults so unsupported dialogs cancel safely instead of hanging.
+        const uiContext = new Proxy(baseUiContext, {
+            get(target, property, receiver) {
+                if (property === "notify")
+                    return notify;
+                const value = Reflect.get(target, property, receiver);
+                return value;
+            },
+        });
         await session.bindExtensions({
+            uiContext,
+            mode: "rpc",
             onError: (error) => {
                 const message = `${error.extensionPath}: ${error.error}`;
                 this.publishActivity(session, "extension error", "error", message);
@@ -1156,10 +1606,15 @@ export class PiSessionService {
     maybeGenerateSessionName(session, firstMessage) {
         if (session.sessionName !== undefined || session.messages.length !== 0 || session.isStreaming || session.isCompacting)
             return;
+        const deterministicName = deterministicSessionName(firstMessage);
+        if (deterministicName !== undefined) {
+            this.applyGeneratedSessionName(session, deterministicName);
+            return;
+        }
         const model = session.model;
         if (model === undefined)
             return;
-        void generateShortSessionName(this.modelRegistry, model, firstMessage).then((name) => {
+        void generateShortSessionName(session.agent.streamFn, model, firstMessage).then((name) => {
             this.applyGeneratedSessionName(session, name ?? fallbackSessionName(firstMessage));
         }).catch(() => {
             this.applyGeneratedSessionName(session, fallbackSessionName(firstMessage));
@@ -1172,10 +1627,11 @@ export class PiSessionService {
         this.publishSessionName(session);
     }
     applyAuthChange(change = {}) {
-        this.modelRegistry.refresh();
+        // ModelRuntime.login()/logout() refresh the shared runtime before AuthService
+        // emits the change, so no refresh is needed here. Keeping this synchronous
+        // also lets every active session observe the same committed auth snapshot.
         for (const active of this.active.values()) {
             const { session } = active.runtime;
-            session.modelRegistry.refresh();
             this.syncCurrentModelAuthWarning(session, change.removedProviderId);
             this.publishStatus(session);
         }
@@ -1187,10 +1643,10 @@ export class PiSessionService {
         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);
+        const registered = session.modelRuntime.getModel(model.provider, model.id);
         if (registered === undefined)
             return;
-        if (session.modelRegistry.hasConfiguredAuth(registered)) {
+        if (session.modelRuntime.hasConfiguredAuth(model.provider)) {
             this.authLossWarnings.delete(warningKey);
             return;
         }
@@ -1334,8 +1790,10 @@ export class PiSessionService {
         const stats = session.getSessionStats();
         const model = session.model === undefined ? undefined : modelToClientModel(session.model);
         const contextUsage = session.getContextUsage();
+        const warnings = this.warningsForSession(session);
         return {
             sessionId: session.sessionId,
+            persisted: sessionFileExists(session.sessionFile),
             ...(model === undefined ? {} : { model }),
             thinkingLevel: session.thinkingLevel,
             isStreaming: session.isStreaming,
@@ -1347,8 +1805,23 @@ export class PiSessionService {
             tokens: stats.tokens,
             cost: stats.cost,
             ...(contextUsage === undefined ? {} : { contextUsage }),
+            ...(warnings.length === 0 ? {} : { warnings }),
         };
     }
+    /**
+     * Compute the live warning set for a session: runtime/resource diagnostics from
+     * the active runtime (if any) plus the Anthropic subscription-auth notice. Read
+     * fresh on each status publish so a rebuilt runtime or an auth/model change is
+     * reflected without caching a stale snapshot.
+     */
+    warningsForSession(session) {
+        const runtime = this.active.get(session.sessionId)?.runtime;
+        const warnings = runtime === undefined ? [] : collectRuntimeWarnings(runtime);
+        const anthropic = anthropicSubscriptionWarning(session, join(this.agentDir, "auth.json"));
+        if (anthropic !== undefined)
+            warnings.push(anthropic);
+        return warnings;
+    }
     pendingMessageCount(session) {
         return session.pendingMessageCount + this.compactionQueuedMessages(session.sessionId).length;
     }
@@ -1368,6 +1841,38 @@ function previewResponseFromPlan(plan) {
         ...(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 errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function modelToClientModel(model) {
     if (model === undefined)
         return {};
@@ -1386,6 +1891,7 @@ function clientSessionFromListEntry(session) {
         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(),
@@ -1514,6 +2020,76 @@ function archivedTimestamp(record) {
 function isDefined(value) {
     return value !== undefined;
 }
+/**
+ * Resolve the delegation capability from server-owned, persisted session
+ * provenance. A copied marker is not enough: the child header and reciprocal
+ * parent link must identify the exact same session files.
+ */
+export async function sessionAllowsDelegationTools(sessionManager, managers) {
+    const trackedLink = await verifiedTrackedSubsessionLink(managers, {
+        sessionId: sessionManager.getSessionId(),
+        sessionFile: sessionManager.getSessionFile(),
+        sessionManager,
+        cwd: sessionManager.getCwd(),
+    });
+    return trackedLink === undefined;
+}
+async function verifiedTrackedSubsessionLink(managers, 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 = findReciprocalParentSubsessionLink(managers, parentSessionFile, marker.spawnedBySessionId, session.sessionId, childSessionFile);
+    if (parentLink === undefined)
+        return undefined;
+    return {
+        parentSessionId: marker.spawnedBySessionId,
+        childSessionId: session.sessionId,
+        childSessionFile,
+        parentSessionFile,
+        cwd: parentLink.cwd ?? session.cwd,
+    };
+}
+function findReciprocalParentSubsessionLink(managers, parentSessionFile, parentSessionId, childSessionId, childSessionFile) {
+    let parentManager;
+    try {
+        parentManager = managers.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;
+}
 function trackedSubsessionLinkFromParentLink(parentSessionId, link, parentSessionFile) {
     return {
         parentSessionId,
@@ -1579,6 +2155,16 @@ function subsessionHydratedParentKey(parentSessionId, 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);
@@ -1697,11 +2283,13 @@ const SUBSESSION_LINK_CUSTOM_TYPE = "pi-web.subsession.link";
 const SUBSESSION_CHILD_LINK_CUSTOM_TYPE = "pi-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)}…`;
+const SUBSESSION_NOTIFICATION_MAX_OUTPUT_CHARS = 2000;
+/** Avoid duplicating a partial result in context when deliberate inspection can return the full output. */
+function formatSubsessionNotificationOutput(childSessionId, text) {
+    if (text.length > SUBSESSION_NOTIFICATION_MAX_OUTPUT_CHARS) {
+        return `Output from subsession ${childSessionId} was too long for this completion notice and was omitted. Call check_subsession with sessionId "${childSessionId}" to retrieve the final output.`;
+    }
+    return `--- SUBSESSION OUTPUT: ${childSessionId} ---\n${text === "" ? "(no output)" : text}`;
 }
 /** Most recent assistant text from a history message list, or "" if none. */
 function finalAssistantText(messages) {