@chainingintention/pi-web-cn 1.202607.5 → 1.202607.7

package/dist/server/sessions/piSessionService.js

@@ -1,19 +1,21 @@
 import { statSync } from "node:fs";
 import { open, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
-import { AuthStorage, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, getAgentDir, ModelRegistry, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, getAgentDir, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, defineTool, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
-import { authScopeFromEventScope, eventScopeFromManagementContext, managementContextKey, NORMAL_SESSION_EVENT_SCOPE } from "../realtime/sessionEventScope.js";
+import { eventScopeFromManagementContext, managementContextKey, NORMAL_SESSION_EVENT_SCOPE } from "../realtime/sessionEventScope.js";
 import { BUILTIN_COMMANDS } from "./builtinCommands.js";
 import { SessionCommandService } from "./sessionCommandService.js";
 import { SessionArchiveStore } from "./sessionArchiveStore.js";
 import { findArchiveCandidateByIdOrPrefix, planSessionArchiveTree } from "./sessionArchiveTree.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 { createPiSessionManagerGateway } from "./piSessionManagerGateway.js";
+import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
+import { piWebDataDir } from "../../config.js";
+import { createScopedSettingsManager, resolveSettingsScopeDirectory } from "./projectSettingsScope.js";
 import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
 import { createSubsessionToolDefinitions } from "./spawnSubsessionTool.js";
 import { buildTranscriptView } from "./subsessionTranscript.js";
@@ -81,46 +83,51 @@ function pathInsideOrEqual(parent, child) {
 function defaultCreateAgentRuntime(createRuntime, options) {
     if (!(options.sessionManager instanceof SessionManager))
         throw new Error("Default runtime creation requires an SDK SessionManager");
-    const runtimeFactory = createRuntimeWithContextAndOneShotInitialModel(createRuntime, options.managementContext, options.initialModel);
+    const runtimeFactory = createRuntimeWithContextAndOneShotInitialModel(createRuntime, options.managementContext, options.initialModel, options.delegationToolsEnabled);
     return createAgentSessionRuntime(runtimeFactory, {
         cwd: options.cwd,
         agentDir: options.agentDir,
         sessionManager: options.sessionManager,
     });
 }
-function createRuntimeWithContextAndOneShotInitialModel(createRuntime, managementContext, initialModel) {
+function createRuntimeWithContextAndOneShotInitialModel(createRuntime, managementContext, initialModel, delegationToolsEnabled) {
     // The inherited model belongs only to the session being spawned. Do not keep
     // reapplying it if that runtime later creates/forks/switches sessions itself.
     let pendingInitialModel = initialModel;
+    let pendingDelegationToolsEnabled = delegationToolsEnabled;
     return async (options) => {
         const model = pendingInitialModel;
+        const toolsEnabled = pendingDelegationToolsEnabled;
         pendingInitialModel = undefined;
+        pendingDelegationToolsEnabled = undefined;
         return createRuntime({
             ...options,
             ...(managementContext === undefined ? {} : { managementContext }),
             ...(model === undefined ? {} : { initialModel: model }),
+            ...(toolsEnabled === undefined ? {} : { delegationToolsEnabled: toolsEnabled }),
         });
     };
 }
-function createDefaultRuntimeFactory(modelRegistry, managementModelRegistry, spawn, subsessions) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel }) => {
-        const scopedModelRegistry = managementContext === undefined ? modelRegistry : managementModelRegistry;
-        const authStorage = scopedModelRegistry.authStorage;
+function createDefaultRuntimeFactory(normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, spawn, subsessions) {
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, delegationToolsEnabled = true }) => {
+        const scopedModelRuntime = managementContext === undefined ? await normalModelRuntimeForCwd(cwd) : await managementModelRuntime();
         if (managementContext !== undefined) {
-            return createManagementRuntimeFactory(authStorage, scopedModelRegistry, spawn, subsessions, managementContext)({
+            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, spawn, subsessions, managementContext)({
                 cwd,
                 agentDir,
                 sessionManager,
+                delegationToolsEnabled,
                 ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
                 ...(initialModel === undefined ? {} : { initialModel }),
             });
         }
-        const services = await createAgentSessionServices({ cwd, agentDir, authStorage, modelRegistry: scopedModelRegistry });
-        const customTools = [
-            ...managedAgentToolDefinitions(cwd),
-            ...(spawn === undefined ? [] : [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))]),
-            ...(subsessions === undefined ? [] : createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool))),
-        ];
+        const settingsManager = await createScopedSettingsManager({
+            cwd,
+            scopeDirectory: await resolveSettingsScope(cwd, "normal"),
+            globalAgentDir: agentDir,
+        });
+        const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime: scopedModelRuntime, settingsManager });
+        const customTools = createPiWebCustomToolDefinitions(cwd, delegationToolsEnabled, spawn, subsessions);
         const result = await createAgentSessionFromServices({
             services,
             sessionManager,
@@ -131,15 +138,20 @@ function createDefaultRuntimeFactory(modelRegistry, managementModelRegistry, spa
         return { ...result, services, diagnostics: services.diagnostics };
     };
 }
-function createManagementRuntimeFactory(authStorage, modelRegistry, spawn, subsessions, managementContext) {
-    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel }) => {
+function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, spawn, subsessions, managementContext) {
+    return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, delegationToolsEnabled = true }) => {
         const policyAgentDir = await writeManagementPermissionSystemPolicy(agentDir, cwd, managementContext);
         return withRuntimeCreationEnvironment({ [PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR]: policyAgentDir }, async () => {
+            const settingsManager = await createScopedSettingsManager({
+                cwd,
+                scopeDirectory: await resolveSettingsScope(cwd, "management"),
+                globalAgentDir: agentDir,
+            });
             const services = await createAgentSessionServices({
                 cwd,
                 agentDir,
-                authStorage,
-                modelRegistry,
+                modelRuntime,
+                settingsManager,
                 resourceLoaderOptions: {
                     agentsFilesOverride: (base) => filterManagedGlobalContextFiles(cwd, agentDir, base),
                 },
@@ -148,8 +160,8 @@ function createManagementRuntimeFactory(authStorage, modelRegistry, spawn, subse
             const customTools = [
                 ...managedAgentToolDefinitions(cwd, managedToolOptions),
                 createManagedPythonToolDefinition(cwd, managementContext),
-                ...(spawn === undefined ? [] : [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))]),
-                ...(subsessions === undefined ? [] : createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool))),
+                ...(delegationToolsEnabled && spawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))] : []),
+                ...(delegationToolsEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool)) : []),
             ];
             const options = {
                 services,
@@ -164,6 +176,13 @@ function createManagementRuntimeFactory(authStorage, modelRegistry, spawn, subse
         });
     };
 }
+export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions) {
+    return [
+        ...managedAgentToolDefinitions(cwd),
+        ...(delegationEnabled && spawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))] : []),
+        ...(delegationEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool)) : []),
+    ];
+}
 function managedAgentToolDefinitions(cwd, options) {
     if (options === undefined)
         return [createPiWebEditToolDefinition(cwd)];
@@ -198,9 +217,10 @@ function createPiWebEditToolDefinition(cwd, options) {
     });
 }
 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();
@@ -221,16 +241,30 @@ 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.managementModelRegistry = deps.managementModelRegistry ?? this.modelRegistry;
+        this.dataDir = deps.dataDir ?? piWebDataDir();
+        this.projectPathForCwd = deps.projectPathForCwd;
+        this.sessionManager = deps.sessionManager ?? createPiSessionManagerGateway({
+            agentDir: this.agentDir,
+            env: process.env,
+            sessionDirEnvKeys: ["PI_WEB_AGENT_SESSION_DIR", "PI_CODING_AGENT_SESSION_DIR"],
+        });
+        let defaultModelRuntime;
+        const resolveDefaultModelRuntime = () => {
+            defaultModelRuntime ??= deps.modelRuntime === undefined ? ModelRuntime.create() : Promise.resolve(deps.modelRuntime);
+            return defaultModelRuntime;
+        };
+        this.normalModelRuntimeForCwd = deps.normalModelRuntimeForCwd ?? resolveDefaultModelRuntime;
+        const managementModelRuntime = deps.managementModelRuntime;
+        this.managementModelRuntime = managementModelRuntime === undefined
+            ? resolveDefaultModelRuntime
+            : () => Promise.resolve(managementModelRuntime);
         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, this.managementModelRegistry, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
+        this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.normalModelRuntimeForCwd, this.managementModelRuntime, (cwd, mode) => this.resolveSettingsScopeDirectory(cwd, mode), 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),
@@ -254,6 +288,15 @@ export class PiSessionService {
     activeCount() {
         return this.active.size;
     }
+    async resolveSettingsScopeDirectory(cwd, mode) {
+        const projectPath = this.projectPathForCwd === undefined ? undefined : await this.projectPathForCwd(cwd);
+        return resolveSettingsScopeDirectory({
+            dataDir: this.dataDir,
+            cwd,
+            mode,
+            ...(projectPath === undefined ? {} : { projectPath }),
+        });
+    }
     async cleanupPreview(request) {
         return previewResponseFromPlan(await this.cleanupPlan(request));
     }
@@ -298,8 +341,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();
@@ -316,6 +363,8 @@ export class PiSessionService {
         }));
     }
     async list(cwd, managementContext) {
+        if (managementContext === undefined)
+            await this.normalModelRuntimeForCwd(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
@@ -331,9 +380,15 @@ export class PiSessionService {
         return [...unarchivedSessions, ...archivedSessions];
     }
     async start(cwd, options = {}) {
+        if (options.managementContext === undefined)
+            await this.normalModelRuntimeForCwd(cwd);
+        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.managementContext === undefined ? {} : { managementContext: options.managementContext }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
+            ...(options.creationProvenance === undefined ? {} : { creationProvenance: options.creationProvenance }),
         });
         const { session } = active.runtime;
         const created = {
@@ -382,9 +437,10 @@ 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.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 = {
@@ -579,61 +635,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);
@@ -670,6 +678,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
@@ -691,7 +709,11 @@ export class PiSessionService {
         const status = this.activityForSession(session)?.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 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--- SUBSESSION OUTPUT: ${childId} ---\n${preview}`;
         void this.notifyParentOfSubsession(link.parentSessionId, childId, text);
     }
     async getOrOpenParentForSubsession(parentSessionId, childSessionId) {
@@ -736,21 +758,21 @@ export class PiSessionService {
     }
     async availableModels(ref, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
-        session.modelRegistry.refresh();
+        await session.modelRuntime.reloadConfig();
         const models = session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRegistry.getAvailable();
+            : await session.modelRuntime.getAvailable();
         return models.map(modelToClientModel);
     }
     async setModel(ref, provider, modelId, managementContext) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref, managementContext);
-        session.modelRegistry.refresh();
+        await session.modelRuntime.reloadConfig();
         const candidates = session.scopedModels.length > 0
             ? session.scopedModels.map((scoped) => scoped.model)
-            : session.modelRegistry.getAvailable();
+            : await session.modelRuntime.getAvailable();
         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(`未找到模型：${provider}/${modelId}`);
         await session.setModel(model);
@@ -1121,6 +1143,14 @@ export class PiSessionService {
         this.publishActivity(active.runtime.session, "stopped", "idle");
         this.publishStatus(active.runtime.session);
     }
+    async clearQueue(ref, managementContext) {
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref, managementContext);
+        this.clearCompactionPromptQueue(session.sessionId);
+        clearSessionQueue(session);
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
     stop(ref, managementContext) {
         const active = this.activeForLookup(ref, managementContext);
         if (active === undefined)
@@ -1316,6 +1346,9 @@ export class PiSessionService {
         return [...names];
     }
     async closeActive(sessionId) {
+        const pendingOpens = this.pendingSessionOpenPromises(sessionId);
+        if (pendingOpens.length > 0)
+            await Promise.allSettled(pendingOpens);
         const activeSessions = this.activeSessionsForId(sessionId);
         await Promise.all(activeSessions.map((active) => this.closeActiveSession(active)));
     }
@@ -1358,14 +1391,36 @@ export class PiSessionService {
             return active;
         const archived = await this.getArchived(ref);
         if (archived?.archivePath !== undefined) {
-            return this.create(this.sessionManager.open(archived.archivePath), archived.cwd, managementContext === undefined ? {} : { managementContext });
+            const archivePath = archived.archivePath;
+            return this.openPending(archived.sessionId, archived.cwd, managementContext, () => 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("未找到会话");
-        return this.create(this.sessionManager.open(match.path), match.cwd, managementContext === undefined ? {} : { managementContext });
+        return this.openPending(match.id, match.cwd, managementContext, () => this.sessionManager.open(match.path));
+    }
+    openPending(sessionId, cwd, managementContext, openSessionManager) {
+        const key = JSON.stringify([canonicalizeStoredCwd(cwd), sessionId, managementContextKey(managementContext)]);
+        const existing = this.pendingSessionOpens.get(key);
+        if (existing !== undefined)
+            return existing.promise;
+        const pending = {
+            sessionId,
+            promise: this.create(openSessionManager(), cwd, managementContext === undefined ? {} : { managementContext }),
+        };
+        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));
@@ -1425,25 +1480,53 @@ export class PiSessionService {
         return [...new Set(this.active.values())].filter((active) => active.runtime.session.sessionId === sessionId);
     }
     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.managementContext === undefined ? {} : { managementContext: options.managementContext }),
             ...(options.initialModel === undefined ? {} : { initialModel: options.initialModel }),
         });
         const active = { runtime, unsubscribe: noop, managementContextKey: managementContextKey(options.managementContext), eventScope: eventScopeFromManagementContext(options.managementContext) };
-        this.active.set(activeSessionKey(runtime.session.sessionId, active.eventScope), active);
-        await this.bindSessionExtensions(runtime.session);
-        this.bindRuntime(active);
-        runtime.setRebindSession(async (session) => {
-            await this.bindSessionExtensions(session);
+        try {
+            await this.bindSessionExtensions(runtime.session);
             this.bindRuntime(active);
-            await this.recoverSubsessionTrackingForOpenedSession(session);
-        });
-        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(activeSessionKey(runtime.session.sessionId, active.eventScope), active);
+            await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
+            this.publishStatus(runtime.session);
+            return active;
+        }
+        catch (error) {
+            active.unsubscribe();
+            let removedActive = false;
+            for (const [sessionKey, candidate] of this.active.entries()) {
+                if (candidate !== active)
+                    continue;
+                this.active.delete(sessionKey);
+                this.activities.delete(sessionKey);
+                removedActive = true;
+            }
+            this.clearAuthLossWarningsForSession(runtime.session.sessionId);
+            this.clearCompactionPromptQueue(runtime.session.sessionId);
+            if (removedActive) {
+                this.workspaceActivity?.removeSession(runtime.session.sessionId, runtime.session.sessionManager.getCwd(), active.eventScope);
+            }
+            try {
+                await runtime.session.abort();
+            }
+            finally {
+                await runtime.dispose();
+            }
+            throw error;
+        }
     }
     async bindSessionExtensions(session) {
         await session.bindExtensions({
@@ -1559,15 +1642,12 @@ export class PiSessionService {
         session.setSessionName(name);
         this.publishSessionName(session);
     }
-    applyAuthChange(change = {}) {
-        this.modelRegistry.refresh();
-        this.managementModelRegistry.refresh();
-        const changedScope = change.scope ?? "normal";
+    applyAuthChange(change) {
+        const changedRuntime = change.modelRuntime;
         for (const active of this.active.values()) {
-            if (authScopeFromEventScope(active.eventScope) !== changedScope)
-                continue;
             const { session } = active.runtime;
-            session.modelRegistry.refresh();
+            if (session.modelRuntime !== changedRuntime)
+                continue;
             this.syncCurrentModelAuthWarning(session, active.eventScope, change.removedProviderId);
             this.publishStatus(session);
         }
@@ -1579,10 +1659,10 @@ export class PiSessionService {
         if (model.provider === "unknown" && model.id === "unknown")
             return;
         const warningKey = authLossWarningKey(session.sessionId, eventScope, 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(registered.provider)) {
             this.authLossWarnings.delete(warningKey);
             return;
         }
@@ -1847,6 +1927,76 @@ function addSessionName(names, name) {
 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,