@pasko70/pibo 1.9.7 → 1.9.9

package/dist/core/session-router.js

@@ -1,850 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { InitialSessionContext, } from "./profiles.js";
-import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault, selectDefaultPiboProfileName } from "../plugins/builtin.js";
-import { createPiboRuntime } from "./runtime.js";
-import { RoutedSession } from "./routed-session.js";
-import { runtimeSessionErrorDetails } from "./session-errors.js";
-import { createSubagentToolName } from "../subagents/tool.js";
-import { PiboRunRegistry } from "../runs/registry.js";
-import { createPiboSignalRegistry } from "../signals/registry.js";
-import { createDefaultPiboReliabilityStore } from "../reliability/store.js";
-import { InMemoryPiboSessionStore, } from "../sessions/store.js";
-import { getDefaultPiboWorkspace } from "./workspace.js";
-import { loadPiboModelDefaults, selectRequestedFastMode } from "./model-defaults.js";
-import { loadPiboUserSettings } from "./user-settings.js";
-import { resolvePiboSessionActiveModel } from "./session-model.js";
-import { isPiboThinkingLevel } from "./thinking.js";
-import { RuntimeSessionRegistry } from "../tools/runtime/registry.js";
-import { assertGatewayResourceAvailableForWork } from "./gateway-resource-guard.js";
-import { withWorkflowSessionKind } from "../sessions/workflow-session-kind.js";
-import { PiboRuntimeTelemetryRecorder } from "./runtime-telemetry.js";
-import { createPiboProviderTelemetryExtension } from "./provider-telemetry.js";
-import { AsyncTelemetryWriter } from "../data/telemetry-writer.js";
-const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
-const DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
-export const RALPH_RUNTIME_RETRY_DEFAULTS = {
-    enabled: true,
-    maxRetries: 7,
-    baseDelayMs: 2_000,
-};
-export function resolvePiboSessionRetryDefaults(kind, configured) {
-    return configured ?? (kind === "ralph" ? RALPH_RUNTIME_RETRY_DEFAULTS : undefined);
-}
-export function resolvePiboSessionInitialThinkingLevel(session) {
-    const value = session.metadata?.initialThinkingLevel;
-    return typeof value === "string" && isPiboThinkingLevel(value) ? value : undefined;
-}
-export function resolvePiboSessionInitialFastMode(session) {
-    const value = session.metadata?.initialFastMode;
-    return typeof value === "boolean" ? value : undefined;
-}
-function profileForSession(baseProfile, piSessionId, parentPiSessionId) {
-    const options = {
-        profileName: baseProfile.profileName,
-        sessionId: piSessionId,
-        parentSessionId: parentPiSessionId,
-        model: baseProfile.model,
-        mainModel: baseProfile.mainModel,
-        subagentModel: baseProfile.subagentModel,
-        thinkingLevel: baseProfile.thinkingLevel,
-        mainThinkingLevel: baseProfile.mainThinkingLevel,
-        subagentThinkingLevel: baseProfile.subagentThinkingLevel,
-        fast: baseProfile.fast,
-        mainFast: baseProfile.mainFast,
-        subagentFast: baseProfile.subagentFast,
-        skills: baseProfile.skills,
-        tools: baseProfile.tools,
-        subagents: baseProfile.subagents,
-        mcpServers: baseProfile.mcpServers,
-        contextFiles: baseProfile.contextFiles,
-        piPackages: baseProfile.piPackages,
-        builtinTools: baseProfile.builtinTools,
-        builtinToolNames: baseProfile.builtinToolNames,
-        autoContextFiles: baseProfile.autoContextFiles,
-        toolPackages: baseProfile.toolPackages,
-    };
-    return new InitialSessionContext(options);
-}
-function formatRunReminderMessage(notification) {
-    return [
-        "<pibo_run_notification>",
-        JSON.stringify({
-            completed: notification.completed.map((run) => ({
-                runId: run.runId,
-                kind: run.kind,
-                status: run.status,
-                toolName: run.toolName,
-                summary: run.summary,
-            })),
-            failed: notification.failed.map((run) => ({
-                runId: run.runId,
-                kind: run.kind,
-                status: run.status,
-                toolName: run.toolName,
-                summary: run.summary,
-            })),
-            cancelled: notification.cancelled.map((run) => ({
-                runId: run.runId,
-                kind: run.kind,
-                status: run.status,
-                toolName: run.toolName,
-                summary: run.summary,
-            })),
-            running: notification.running.map((run) => ({
-                runId: run.runId,
-                kind: run.kind,
-                status: run.status,
-                toolName: run.toolName,
-                summary: run.summary,
-            })),
-            instruction: "Use pibo_run_read for completed or failed runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
-        }),
-        "</pibo_run_notification>",
-    ].join("\n");
-}
-function isRunReminderServiceMessage(event) {
-    return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
-}
-function isTerminalRunStatus(status) {
-    return status === "completed" || status === "failed" || status === "cancelled";
-}
-function asJsonObject(value) {
-    return value ?? {};
-}
-function shouldResetSessionAfterAction(action) {
-    return action === "login.complete" || action === "login.apikey" || action === "logout";
-}
-function piboRoomIdFromMetadata(metadata) {
-    const value = metadata?.chatRoomId;
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function telemetryStoreFromSessionStore(store) {
-    return store.getTelemetryStore?.();
-}
-function providerEventTelemetryModeFromEnv(env = process.env) {
-    const value = env.PIBO_TELEMETRY_PROVIDER_EVENTS?.trim().toLowerCase();
-    return value === "1" || value === "true" || value === "detailed" ? "detailed" : "aggregate";
-}
-export class PiboSessionRouter {
-    options;
-    sessions = new Map();
-    pendingSessions = new Map();
-    listeners = new Set();
-    runRegistry;
-    signalRegistry;
-    runtimeRegistry;
-    scheduledRunReminders = new Map();
-    idleSessionTimers = new Map();
-    routedSessionIdleTimeoutMs;
-    baseProfile;
-    pluginRegistry;
-    sessionStore;
-    reliabilityStore;
-    telemetryStore;
-    telemetryWriter;
-    telemetryRecorder;
-    disposePromise;
-    closing = false;
-    constructor(options = {}) {
-        this.options = options;
-        this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
-        this.sessionStore = options.sessionStore ?? new InMemoryPiboSessionStore();
-        this.telemetryStore = options.telemetryStore ?? telemetryStoreFromSessionStore(this.sessionStore);
-        this.telemetryWriter = this.telemetryStore ? new AsyncTelemetryWriter(this.telemetryStore) : undefined;
-        this.telemetryRecorder = this.telemetryStore
-            ? new PiboRuntimeTelemetryRecorder(this.telemetryStore, undefined, {
-                providerEventMode: providerEventTelemetryModeFromEnv(),
-                writer: this.telemetryWriter,
-            })
-            : undefined;
-        const idleTimeoutMs = options.routedSessionIdleTimeoutMs;
-        this.routedSessionIdleTimeoutMs = idleTimeoutMs === false
-            ? false
-            : typeof idleTimeoutMs === "number" && Number.isFinite(idleTimeoutMs) && idleTimeoutMs > 0
-                ? idleTimeoutMs
-                : DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS;
-        const defaultProfileName = selectDefaultPiboProfileName(this.pluginRegistry);
-        this.baseProfile = options.profile ?? createPiboProfileFromRegistryOrDefault(this.pluginRegistry, defaultProfileName);
-        this.reliabilityStore = options.reliabilityStore ?? (options.persistSession === false ? undefined : createDefaultPiboReliabilityStore());
-        this.signalRegistry = options.signalRegistry ?? createPiboSignalRegistry();
-        this.runtimeRegistry = new RuntimeSessionRegistry({ cwd: options.cwd ?? getDefaultPiboWorkspace() });
-        this.runRegistry = new PiboRunRegistry({ store: this.reliabilityStore });
-        this.runRegistry.subscribe((event) => this.projectRunRegistryEvent(event));
-        for (const run of this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })) {
-            this.signalRegistry.project({ type: "run_changed", run, reason: "recovered" });
-        }
-    }
-    subscribe(listener) {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-    async emit(event) {
-        if (this.closing)
-            throw new Error("Pibo session router is disposed.");
-        if (event.type === "message" && event.id) {
-            const stored = this.sessionStore.get(event.piboSessionId);
-            if (stored)
-                this.signalRegistry.project({ type: "session_created", session: stored });
-            this.signalRegistry.project({ type: "message_accepted", piboSessionId: event.piboSessionId, eventId: event.id, source: event.source });
-        }
-        let session;
-        try {
-            session = await this.getOrCreateSession(event.piboSessionId);
-        }
-        catch (error) {
-            if (event.type === "message" && event.id) {
-                this.signalRegistry.project({
-                    type: "pibo_output",
-                    event: {
-                        type: "session_error",
-                        piboSessionId: event.piboSessionId,
-                        eventId: event.id,
-                        error: error instanceof Error ? error.message : String(error),
-                    },
-                });
-            }
-            throw error;
-        }
-        this.clearIdleSessionTimer(event.piboSessionId);
-        try {
-            if (event.type === "message") {
-                return session.enqueueMessage(event);
-            }
-            if (event.action === "abort") {
-                this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
-            }
-            else if (event.action === "dispose" || event.action === "kill" || event.action === "kill_all") {
-                this.signalRegistry.project({ type: "session_disposed", piboSessionId: event.piboSessionId, reason: `${event.action} action` });
-            }
-            const output = await session.executeAction(event);
-            if (event.action === "dispose") {
-                await this.disposeSessionSubtree(event.piboSessionId, "dispose action", { cancelRuns: true });
-            }
-            else if (event.action === "kill" || event.action === "kill_all") {
-                await this.disposeSessionSubtree(event.piboSessionId, `${event.action} action`, { cancelRuns: event.action === "kill_all" });
-            }
-            else if (shouldResetSessionAfterAction(event.action)) {
-                await this.resetCachedSession(event.piboSessionId, "provider auth changed");
-            }
-            return output;
-        }
-        finally {
-            this.scheduleIdleSessionEvictionIfIdle(event.piboSessionId);
-        }
-    }
-    async killSession(piboSessionId, options) {
-        const killed = [];
-        const cancelledRuns = [];
-        const session = this.sessions.get(piboSessionId);
-        if (session) {
-            this.signalRegistry.project({ type: "session_disposed", piboSessionId, reason: "kill" });
-            killed.push(await session.kill());
-            if (options?.includeRuns) {
-                const runs = this.runRegistry.cancelControllerRuns(piboSessionId);
-                cancelledRuns.push(...runs.map((r) => r.runId));
-            }
-            const children = await this.killChildSessions(piboSessionId, options);
-            killed.push(...children.killed);
-            cancelledRuns.push(...children.cancelledRuns);
-            await this.disposeSessionSubtree(piboSessionId, "kill", { cancelRuns: false });
-        }
-        return { killed, cancelledRuns };
-    }
-    async disposeSessionSubtree(piboSessionId, reason, options) {
-        const ids = [piboSessionId, ...this.descendantSessionIds(piboSessionId)];
-        const sessions = [];
-        for (const id of ids) {
-            if (options.cancelRuns)
-                this.runRegistry.cancelControllerRuns(id);
-            this.clearIdleSessionTimer(id);
-            this.scheduledRunReminders.delete(id);
-            const cached = this.sessions.get(id);
-            if (cached)
-                sessions.push(cached);
-            this.sessions.delete(id);
-        }
-        try {
-            await Promise.all(ids.map((id) => this.runtimeRegistry.closeControllerSessions(id, { force: true })));
-            await Promise.all(sessions.map((session) => session.dispose()));
-        }
-        finally {
-            await this.telemetryWriter?.flush();
-        }
-        for (const id of ids) {
-            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
-        }
-    }
-    descendantSessionIds(parentId) {
-        const output = [];
-        for (const session of this.sessionStore.list?.() ?? []) {
-            if (session.parentId !== parentId)
-                continue;
-            output.push(session.id, ...this.descendantSessionIds(session.id));
-        }
-        return output;
-    }
-    async killChildSessions(parentId, options) {
-        const killed = [];
-        const cancelledRuns = [];
-        const allSessions = this.sessionStore.list?.() ?? [];
-        for (const session of allSessions) {
-            if (session.parentId === parentId) {
-                const childSession = this.sessions.get(session.id);
-                if (childSession) {
-                    killed.push(await childSession.kill());
-                }
-                if (options?.includeRuns) {
-                    const runs = this.runRegistry.cancelControllerRuns(session.id);
-                    cancelledRuns.push(...runs.map((r) => r.runId));
-                }
-                const nested = await this.killChildSessions(session.id, options);
-                killed.push(...nested.killed);
-                cancelledRuns.push(...nested.cancelledRuns);
-            }
-        }
-        return { killed, cancelledRuns };
-    }
-    getPiboSessionIds() {
-        return [...this.sessions.keys()];
-    }
-    getSessionRuntimeStatus(piboSessionId) {
-        return this.sessions.get(piboSessionId)?.getStatus();
-    }
-    async setLiveSessionActiveModel(piboSessionId, model) {
-        const session = this.sessions.get(piboSessionId);
-        if (!session)
-            return model;
-        const status = session.getStatus();
-        if (status.processing || status.streaming || status.queuedMessages > 0) {
-            throw new Error("Session model can only be changed while the runtime is idle.");
-        }
-        if (!model) {
-            await this.resetCachedSession(piboSessionId);
-            return undefined;
-        }
-        return session.setModel(model);
-    }
-    reportSessionError(piboSessionId, error, options = {}) {
-        this.signalRegistry.project({ type: "session_created", session: this.resolvePiboSession(piboSessionId) });
-        this.emitOutput({
-            type: "session_error",
-            piboSessionId,
-            eventId: options.eventId,
-            error,
-            errorDetails: runtimeSessionErrorDetails(error),
-        });
-    }
-    listSessionRuntimeStatuses() {
-        return [...this.sessions.values()].map((session) => session.getStatus());
-    }
-    listRuns(options = {}) {
-        return this.runRegistry.listAll(options);
-    }
-    getSignalRegistry() {
-        return this.signalRegistry;
-    }
-    snapshotSignalSession(piboSessionId) {
-        this.projectKnownSessionSignals();
-        return this.signalRegistry.snapshotSession(piboSessionId);
-    }
-    snapshotSignalTree(rootPiboSessionId) {
-        this.projectKnownSessionSignals();
-        return this.signalRegistry.snapshotTree(rootPiboSessionId);
-    }
-    subscribeSignalTree(rootPiboSessionId, listener) {
-        return this.signalRegistry.subscribe(rootPiboSessionId, listener);
-    }
-    async emitMessageAndWaitForReply(event, timeoutMs = 120000) {
-        const eventWithId = { ...event, id: event.id ?? randomUUID() };
-        return await new Promise((resolve, reject) => {
-            let settled = false;
-            let lastAssistantMessage;
-            let timeout;
-            const unsubscribe = this.subscribe((output) => {
-                if (output.piboSessionId !== eventWithId.piboSessionId ||
-                    !("eventId" in output) ||
-                    output.eventId !== eventWithId.id) {
-                    return;
-                }
-                if (output.type === "assistant_message") {
-                    lastAssistantMessage = output;
-                }
-                else if (output.type === "message_finished") {
-                    finish(lastAssistantMessage ?? new Error(`Pibo session "${eventWithId.piboSessionId}" finished without an assistant reply`));
-                }
-                else if (output.type === "session_error") {
-                    finish(new Error(output.error));
-                }
-            });
-            const finish = (result) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (timeout)
-                    clearTimeout(timeout);
-                unsubscribe();
-                if (result instanceof Error) {
-                    reject(result);
-                }
-                else {
-                    resolve(result);
-                }
-            };
-            timeout = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                unsubscribe();
-                const timeoutError = new Error(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`);
-                reject(timeoutError);
-                void this.emit({
-                    type: "execution",
-                    piboSessionId: eventWithId.piboSessionId,
-                    action: "abort",
-                    id: randomUUID(),
-                }).catch(() => { });
-            }, timeoutMs);
-            this.emit(eventWithId).catch(finish);
-        });
-    }
-    async disposeAll() {
-        if (this.disposePromise)
-            return this.disposePromise;
-        this.closing = true;
-        this.disposePromise = this.disposeAllUnsafe();
-        return this.disposePromise;
-    }
-    async disposeAllUnsafe() {
-        try {
-            await Promise.allSettled([...this.pendingSessions.values()]);
-            const sessions = [...this.sessions.values()];
-            this.sessions.clear();
-            for (const timer of this.idleSessionTimers.values())
-                clearTimeout(timer);
-            this.idleSessionTimers.clear();
-            this.runRegistry.cancelAll("Pibo session router was disposed.");
-            for (const session of sessions)
-                this.signalRegistry.project({ type: "session_disposed", piboSessionId: session.getStatus().piboSessionId, reason: "router disposed" });
-            this.scheduledRunReminders.clear();
-            await this.runtimeRegistry.closeAll({ force: true });
-            await Promise.all(sessions.map((session) => session.dispose()));
-        }
-        finally {
-            await this.telemetryWriter?.dispose();
-        }
-    }
-    clearIdleSessionTimer(piboSessionId) {
-        const timer = this.idleSessionTimers.get(piboSessionId);
-        if (timer)
-            clearTimeout(timer);
-        this.idleSessionTimers.delete(piboSessionId);
-    }
-    scheduleIdleSessionEvictionIfIdle(piboSessionId) {
-        if (this.routedSessionIdleTimeoutMs === false)
-            return;
-        const session = this.sessions.get(piboSessionId);
-        if (!session)
-            return;
-        const status = session.getStatus();
-        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0) {
-            this.clearIdleSessionTimer(piboSessionId);
-            return;
-        }
-        this.clearIdleSessionTimer(piboSessionId);
-        const timer = setTimeout(() => {
-            this.idleSessionTimers.delete(piboSessionId);
-            void this.evictIdleSession(piboSessionId, session).catch((error) => {
-                const message = error instanceof Error ? error.message : String(error);
-                this.emitOutput({
-                    type: "session_error",
-                    piboSessionId,
-                    error: `Failed to dispose idle routed runtime: ${message}`,
-                    errorDetails: runtimeSessionErrorDetails(message),
-                });
-            });
-        }, this.routedSessionIdleTimeoutMs);
-        timer.unref();
-        this.idleSessionTimers.set(piboSessionId, timer);
-    }
-    async evictIdleSession(piboSessionId, expected) {
-        const current = this.sessions.get(piboSessionId);
-        if (current !== expected)
-            return;
-        const status = current.getStatus();
-        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0)
-            return;
-        await this.resetCachedSession(piboSessionId, "routed runtime idle timeout");
-    }
-    async getOrCreateSession(piboSessionId) {
-        if (this.closing)
-            throw new Error("Pibo session router is disposed.");
-        const existing = this.sessions.get(piboSessionId);
-        if (existing) {
-            this.clearIdleSessionTimer(piboSessionId);
-            return existing;
-        }
-        const pending = this.pendingSessions.get(piboSessionId);
-        if (pending)
-            return pending;
-        const created = this.createRoutedSession(piboSessionId);
-        this.pendingSessions.set(piboSessionId, created);
-        try {
-            return await created;
-        }
-        finally {
-            this.pendingSessions.delete(piboSessionId);
-        }
-    }
-    async createRoutedSession(piboSessionId) {
-        const piboSession = this.resolvePiboSession(piboSessionId);
-        this.signalRegistry.project({ type: "session_created", session: piboSession });
-        const profile = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, piboSession.profile);
-        const parentPiSessionId = piboSession.parentId
-            ? this.resolvePiboSession(piboSession.parentId).piSessionId
-            : undefined;
-        const modelDefaults = this.resolveModelDefaults();
-        const activeModel = this.ensureSessionActiveModel(piboSession, profile, parentPiSessionId, modelDefaults);
-        const initialThinkingLevel = resolvePiboSessionInitialThinkingLevel(piboSession);
-        const userSettings = loadPiboUserSettings();
-        const telemetryExtension = this.telemetryStore
-            ? createPiboProviderTelemetryExtension({ store: this.telemetryStore, writer: this.telemetryWriter, session: piboSession, model: activeModel })
-            : undefined;
-        const runtime = await createPiboRuntime({
-            cwd: piboSession.workspace ?? this.options.cwd,
-            persistSession: this.options.persistSession,
-            thinkingLevel: initialThinkingLevel ?? this.options.thinkingLevel,
-            retryDefaults: resolvePiboSessionRetryDefaults(piboSession.kind, this.options.retryDefaults),
-            profile: profileForSession(profile, piboSession.piSessionId, parentPiSessionId),
-            extensionFactories: [
-                ...(telemetryExtension ? [telemetryExtension] : []),
-                ...(this.options.extensionFactories ?? []),
-            ],
-            subagentRunner: this.createSubagentRunner(piboSession.id),
-            runToolController: this.createRunToolController(piboSession.id),
-            runtimeToolController: this.runtimeRegistry.createController(piboSession.id),
-            modelDefaults,
-            activeModel,
-            sessionContext: {
-                piboSessionId: piboSession.id,
-                piboRoomId: piboRoomIdFromMetadata(piboSession.metadata),
-                timezone: userSettings.timezone,
-            },
-        });
-        const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(profileForSession(profile, piboSession.piSessionId, parentPiSessionId), modelDefaults) ?? false;
-        const session = new RoutedSession(piboSession.id, runtime, this.emitOutput, this.pluginRegistry, this.options.forwardPiEvents ?? false, this.telemetryRecorder
-            ? (id, event, context) => this.telemetryRecorder?.recordPiEvent(id, event, { session: this.sessionStore.get(id), status: context.status, activeEventId: context.activeEventId })
-            : undefined, initialFastMode, (result, event) => this.handleSessionOperation(result, event), (id, opts) => this.killChildSessions(id, opts), (state) => {
-            this.signalRegistry.project({ type: "session_processing_changed", piboSessionId: piboSession.id, processing: state.processing, queuedMessages: state.queuedMessages });
-            if (state.disposed || state.processing || state.queuedMessages > 0)
-                this.clearIdleSessionTimer(piboSession.id);
-            else
-                this.scheduleIdleSessionEvictionIfIdle(piboSession.id);
-        }, (messages, reason) => this.telemetryRecorder?.recordMessagesInterrupted(messages, {
-            session: this.sessionStore.get(piboSession.id),
-            status: this.sessions.get(piboSession.id)?.getStatus(),
-        }, reason));
-        this.sessions.set(piboSession.id, session);
-        return session;
-    }
-    ensureSessionActiveModel(piboSession, profile, parentPiSessionId, modelDefaults) {
-        const activeModel = resolvePiboSessionActiveModel({
-            profile,
-            piboSession,
-            parentPiSessionId,
-            modelDefaults,
-        });
-        if (!piboSession.activeModel && activeModel) {
-            this.sessionStore.update(piboSession.id, { activeModel });
-        }
-        return activeModel;
-    }
-    resolveModelDefaults() {
-        if (typeof this.options.modelDefaults === "function")
-            return this.options.modelDefaults();
-        if (this.options.modelDefaults)
-            return this.options.modelDefaults;
-        return loadPiboModelDefaults(this.options.cwd ?? process.cwd());
-    }
-    async handleSessionOperation(result, event) {
-        if (result.cancelled)
-            return;
-        if (event.action === "session.fork" || event.action === "session.clone") {
-            const action = event.action;
-            const created = this.createDerivedSession(result, action);
-            result.piboSessionId = created.id;
-            await this.resetCachedSession(event.piboSessionId);
-            return;
-        }
-        this.sessionStore.update(event.piboSessionId, {
-            piSessionId: result.current.piSessionId,
-            workspace: result.current.cwd,
-        });
-    }
-    createDerivedSession(result, action) {
-        const source = this.resolvePiboSession(result.piboSessionId);
-        return this.sessionStore.create({
-            channel: source.channel,
-            kind: "branch",
-            profile: source.profile,
-            parentId: source.kind === "subagent" ? source.parentId : undefined,
-            originId: source.id,
-            piSessionId: result.current.piSessionId,
-            workspace: result.current.cwd,
-            title: source.title,
-            activeModel: source.activeModel,
-            metadata: {
-                ...asJsonObject(source.metadata),
-                originAction: action,
-                originPiSessionId: result.previous.piSessionId,
-            },
-        });
-    }
-    async resetCachedSession(piboSessionId, reason) {
-        const cached = this.sessions.get(piboSessionId);
-        this.clearIdleSessionTimer(piboSessionId);
-        this.sessions.delete(piboSessionId);
-        try {
-            await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
-            await cached?.dispose();
-        }
-        finally {
-            await this.telemetryWriter?.flush();
-        }
-        if (reason)
-            this.signalRegistry.project({ type: "session_disposed", piboSessionId, reason });
-    }
-    resolvePiboSession(piboSessionId) {
-        const existing = this.sessionStore.get(piboSessionId);
-        if (existing)
-            return existing;
-        const created = this.sessionStore.create({
-            id: piboSessionId,
-            channel: "pibo.runtime",
-            kind: "runtime",
-            profile: this.baseProfile.profileName,
-            workspace: this.options.cwd ?? getDefaultPiboWorkspace(),
-        });
-        this.signalRegistry.project({ type: "session_created", session: created });
-        return created;
-    }
-    createSubagentRunner(parentPiboSessionId) {
-        return {
-            runSubagent: async ({ subagent, message, threadKey, toolCallId }) => {
-                this.assertSubagentDepth(parentPiboSessionId, subagent);
-                const child = this.resolveSubagentSession(parentPiboSessionId, subagent, threadKey);
-                const toolName = createSubagentToolName(subagent.name);
-                const event = {
-                    type: "message",
-                    piboSessionId: child.id,
-                    text: message,
-                    source: "actor",
-                    id: randomUUID(),
-                };
-                this.emitOutput({
-                    type: "subagent_session",
-                    piboSessionId: parentPiboSessionId,
-                    toolCallId,
-                    toolName,
-                    subagentName: subagent.name,
-                    childPiboSessionId: child.id,
-                    threadKey: typeof child.metadata?.threadKey === "string" ? child.metadata.threadKey : undefined,
-                });
-                const reply = await this.emitMessageAndWaitForReply(event, subagent.timeoutMs ?? DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS);
-                return { piboSessionId: child.id, eventId: event.id, reply };
-            },
-        };
-    }
-    createRunToolController(parentPiboSessionId) {
-        return {
-            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, execute }) => {
-                assertGatewayResourceAvailableForWork(`yielded run ${toolName}`);
-                const run = this.runRegistry.startToolRun({
-                    controllerPiboSessionId: parentPiboSessionId,
-                    toolName,
-                    params,
-                    completionPolicy,
-                    retryable,
-                    maxAttempts,
-                });
-                void (async () => {
-                    try {
-                        const result = await execute();
-                        const completed = this.runRegistry.complete(run.runId, result);
-                        if (completed)
-                            this.scheduleRunReminder(parentPiboSessionId, false);
-                    }
-                    catch (error) {
-                        const failed = this.runRegistry.fail(run.runId, error instanceof Error ? error.message : String(error));
-                        if (failed)
-                            this.scheduleRunReminder(parentPiboSessionId, false);
-                    }
-                })();
-                return run;
-            },
-            listRuns: (options) => this.runRegistry.list(parentPiboSessionId, options),
-            getRunStatus: (runId) => this.runRegistry.status(parentPiboSessionId, runId),
-            waitForRun: (runId, timeoutMs) => this.runRegistry.wait(parentPiboSessionId, runId, timeoutMs),
-            readRun: (runId) => {
-                const run = this.runRegistry.read(parentPiboSessionId, runId);
-                if (run.consumed && isTerminalRunStatus(run.status)) {
-                    this.refreshQueuedRunReminders(parentPiboSessionId);
-                }
-                return run;
-            },
-            cancelRun: async (runId) => {
-                const cancelled = this.runRegistry.cancel(parentPiboSessionId, runId);
-                this.refreshQueuedRunReminders(parentPiboSessionId);
-                return cancelled;
-            },
-            ackRun: (runId) => {
-                const run = this.runRegistry.ack(parentPiboSessionId, runId);
-                this.refreshQueuedRunReminders(parentPiboSessionId);
-                return run;
-            },
-        };
-    }
-    assertSubagentDepth(parentPiboSessionId, subagent) {
-        const maxDepth = subagent.maxDepth ?? 3;
-        if (this.getSubagentDepth(parentPiboSessionId) >= maxDepth) {
-            throw new Error(`Subagent "${subagent.name}" exceeded max depth ${maxDepth} from Pibo session "${parentPiboSessionId}"`);
-        }
-    }
-    getSubagentDepth(piboSessionId) {
-        let depth = 0;
-        let current = this.sessionStore.get(piboSessionId);
-        const seen = new Set();
-        while (current?.parentId) {
-            if (seen.has(current.parentId))
-                break;
-            seen.add(current.parentId);
-            depth += 1;
-            current = this.sessionStore.get(current.parentId);
-        }
-        return depth;
-    }
-    resolveSubagentSession(parentPiboSessionId, subagent, threadKey) {
-        const targetProfile = resolvePiboProfileNameFromRegistryOrDefault(this.pluginRegistry, subagent.targetProfile);
-        const parent = this.resolvePiboSession(parentPiboSessionId);
-        const resolvedThreadKey = threadKey?.trim() ? threadKey.trim() : randomUUID();
-        const baseMetadata = {
-            subagentName: subagent.name,
-            subagentToolName: createSubagentToolName(subagent.name),
-            threadKey: resolvedThreadKey,
-        };
-        const metadata = withWorkflowSessionKind(baseMetadata, "subagent");
-        const parentChatRoomId = typeof parent.metadata?.chatRoomId === "string" ? parent.metadata.chatRoomId : undefined;
-        if (parentChatRoomId)
-            metadata.chatRoomId = parentChatRoomId;
-        const legacyMetadata = { ...baseMetadata };
-        const legacyMetadataWithChatRoom = parentChatRoomId
-            ? { ...baseMetadata, chatRoomId: parentChatRoomId }
-            : undefined;
-        const findExisting = (candidate) => candidate
-            ? this.sessionStore.find({
-                channel: "pibo.subagents",
-                kind: "subagent",
-                parentId: parent.id,
-                profile: targetProfile,
-                metadata: candidate,
-            })[0]
-            : undefined;
-        const existing = findExisting(metadata) ?? findExisting(legacyMetadataWithChatRoom) ?? findExisting(legacyMetadata);
-        if (existing) {
-            const updatedMetadata = withWorkflowSessionKind({
-                ...(existing.metadata ?? {}),
-                ...(parentChatRoomId ? { chatRoomId: parentChatRoomId } : {}),
-            }, "subagent");
-            if (JSON.stringify(updatedMetadata) !== JSON.stringify(existing.metadata ?? {})) {
-                return this.sessionStore.update(existing.id, { metadata: updatedMetadata }) ?? existing;
-            }
-            return existing;
-        }
-        const childProfile = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, targetProfile);
-        const childSession = this.sessionStore.create({
-            channel: "pibo.subagents",
-            kind: "subagent",
-            profile: targetProfile,
-            parentId: parent.id,
-            workspace: parent.workspace,
-            metadata,
-        });
-        this.signalRegistry.project({ type: "session_created", session: childSession });
-        const activeModel = resolvePiboSessionActiveModel({
-            profile: childProfile,
-            piboSession: childSession,
-            parentPiSessionId: parent.piSessionId,
-            modelDefaults: this.resolveModelDefaults(),
-        });
-        return activeModel ? this.sessionStore.update(childSession.id, { activeModel }) ?? childSession : childSession;
-    }
-    emitOutput = (event) => {
-        const session = this.sessionStore.get(event.piboSessionId);
-        this.telemetryRecorder?.recordOutput(event, { session, status: this.sessions.get(event.piboSessionId)?.getStatus() });
-        this.signalRegistry.project({ type: "pibo_output", event, session });
-        this.pluginRegistry.notifyEvent(event);
-        for (const listener of this.listeners) {
-            listener(event);
-        }
-        if (event.type === "message_finished" && event.source !== "service") {
-            this.scheduleRunReminder(event.piboSessionId, true);
-        }
-    };
-    projectKnownSessionSignals() {
-        for (const session of this.sessionStore.list?.() ?? []) {
-            this.signalRegistry.project({ type: "session_created", session });
-        }
-    }
-    projectRunRegistryEvent(event) {
-        if (event.type === "run_removed") {
-            this.signalRegistry.project({ type: "run_removed", runId: event.runId, controllerPiboSessionId: event.controllerPiboSessionId });
-            return;
-        }
-        this.signalRegistry.project({ type: "run_changed", run: event.run, previousStatus: "previousStatus" in event ? event.previousStatus : undefined, reason: "reason" in event ? event.reason : event.type });
-    }
-    scheduleRunReminder(piboSessionId, includeAlreadyNotified) {
-        if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified }))
-            return;
-        const previous = this.scheduledRunReminders.get(piboSessionId);
-        if (previous !== undefined) {
-            this.scheduledRunReminders.set(piboSessionId, previous || includeAlreadyNotified);
-            return;
-        }
-        this.scheduledRunReminders.set(piboSessionId, includeAlreadyNotified);
-        queueMicrotask(() => {
-            void this.deliverRunReminder(piboSessionId);
-        });
-    }
-    refreshQueuedRunReminders(piboSessionId) {
-        const removed = this.sessions.get(piboSessionId)?.removeQueuedMessages(isRunReminderServiceMessage) ?? 0;
-        if (removed > 0)
-            this.scheduleRunReminder(piboSessionId, true);
-    }
-    async deliverRunReminder(piboSessionId) {
-        const includeAlreadyNotified = this.scheduledRunReminders.get(piboSessionId) ?? false;
-        this.scheduledRunReminders.delete(piboSessionId);
-        const notification = this.runRegistry.createNotification(piboSessionId, { includeAlreadyNotified });
-        if (!notification)
-            return;
-        try {
-            const session = await this.getOrCreateSession(piboSessionId);
-            session.enqueueMessage({
-                type: "message",
-                piboSessionId,
-                text: formatRunReminderMessage(notification),
-                source: "service",
-                id: randomUUID(),
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.emitOutput({
-                type: "session_error",
-                piboSessionId,
-                error: message,
-                errorDetails: runtimeSessionErrorDetails(message),
-            });
-        }
-    }
-}