@pasko70/pibo 1.1.0 → 1.2.0

package/dist/core/session-router.js

@@ -1,14 +1,32 @@
 import { randomUUID } from "node:crypto";
 import { InitialSessionContext, } from "./profiles.js";
-import { createDefaultPiboPluginRegistry } from "../plugins/builtin.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 { withWorkflowSessionKind } from "../sessions/workflow-session-kind.js";
+import { PiboRuntimeTelemetryRecorder } from "./runtime-telemetry.js";
+import { createPiboProviderTelemetryExtension } from "./provider-telemetry.js";
 const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
+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,
@@ -17,6 +35,12 @@ function profileForSession(baseProfile, piSessionId, 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,
@@ -29,7 +53,7 @@ function profileForSession(baseProfile, piSessionId, parentPiSessionId) {
     };
     return new InitialSessionContext(options);
 }
-function formatRunNotification(notification) {
+function formatRunReminderMessage(notification) {
     return [
         "<pibo_run_notification>",
         JSON.stringify({
@@ -66,7 +90,7 @@ function formatRunNotification(notification) {
         "</pibo_run_notification>",
     ].join("\n");
 }
-function isRunNotificationServiceMessage(event) {
+function isRunReminderServiceMessage(event) {
     return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
 }
 function isTerminalRunStatus(status) {
@@ -75,24 +99,47 @@ function isTerminalRunStatus(status) {
 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?.();
+}
 export class PiboSessionRouter {
     options;
     sessions = new Map();
     pendingSessions = new Map();
     listeners = new Set();
     runRegistry;
-    scheduledRunNotifications = new Map();
+    signalRegistry;
+    runtimeRegistry;
+    scheduledRunReminders = new Map();
     baseProfile;
     pluginRegistry;
     sessionStore;
     reliabilityStore;
+    telemetryStore;
+    telemetryRecorder;
     constructor(options = {}) {
         this.options = options;
         this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
         this.sessionStore = options.sessionStore ?? new InMemoryPiboSessionStore();
-        this.baseProfile = options.profile ?? this.pluginRegistry.createProfile("pibo-minimal");
-        this.reliabilityStore = options.reliabilityStore ?? (options.persistSession === false ? undefined : createDefaultPiboReliabilityStore(options.cwd));
+        this.telemetryStore = options.telemetryStore ?? telemetryStoreFromSessionStore(this.sessionStore);
+        this.telemetryRecorder = this.telemetryStore ? new PiboRuntimeTelemetryRecorder(this.telemetryStore) : undefined;
+        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);
@@ -106,16 +153,125 @@ export class PiboSessionRouter {
             return session.enqueueMessage(event);
         }
         const output = await session.executeAction(event);
+        if (event.action === "abort") {
+            this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
+        }
         if (event.action === "dispose") {
-            this.runRegistry.cancelOwnerRuns(event.piboSessionId);
-            this.scheduledRunNotifications.delete(event.piboSessionId);
-            this.sessions.delete(event.piboSessionId);
+            this.disposeSignalSubtree(event.piboSessionId, "dispose action");
+        }
+        else if (shouldResetSessionAfterAction(event.action)) {
+            await this.resetCachedSession(event.piboSessionId, "provider auth changed");
+        }
+        return output;
+    }
+    async killSession(piboSessionId, options) {
+        const killed = [];
+        const cancelledRuns = [];
+        const session = this.sessions.get(piboSessionId);
+        if (session) {
+            killed.push(await session.kill());
+            if (options?.includeRuns) {
+                const runs = this.runRegistry.cancelControllerRuns(piboSessionId);
+                cancelledRuns.push(...runs.map((r) => r.runId));
+            }
+            await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
+            this.signalRegistry.project({ type: "session_interrupted", piboSessionId, reason: "kill" });
+            const children = await this.killChildSessions(piboSessionId, options);
+            killed.push(...children.killed);
+            cancelledRuns.push(...children.cancelledRuns);
+        }
+        return { killed, cancelledRuns };
+    }
+    disposeSignalSubtree(piboSessionId, reason) {
+        const descendants = this.descendantSessionIds(piboSessionId);
+        for (const id of [piboSessionId, ...descendants]) {
+            this.runRegistry.cancelControllerRuns(id);
+            void this.runtimeRegistry.closeControllerSessions(id, { force: true });
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
+            this.scheduledRunReminders.delete(id);
+            this.sessions.delete(id);
+        }
+    }
+    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) => {
@@ -156,7 +312,10 @@ export class PiboSessionRouter {
         const sessions = [...this.sessions.values()];
         this.sessions.clear();
         this.runRegistry.cancelAll("Pibo session router was disposed.");
-        this.scheduledRunNotifications.clear();
+        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()));
     }
     async getOrCreateSession(piboSessionId) {
@@ -177,22 +336,64 @@ export class PiboSessionRouter {
     }
     async createRoutedSession(piboSessionId) {
         const piboSession = this.resolvePiboSession(piboSessionId);
-        const profile = this.pluginRegistry.createProfile(piboSession.profile);
+        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, session: piboSession, model: activeModel })
+            : undefined;
         const runtime = await createPiboRuntime({
             cwd: piboSession.workspace ?? this.options.cwd,
             persistSession: this.options.persistSession,
-            thinkingLevel: this.options.thinkingLevel,
+            thinkingLevel: initialThinkingLevel ?? this.options.thinkingLevel,
             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 session = new RoutedSession(piboSession.id, runtime, this.emitOutput, this.pluginRegistry, this.options.forwardPiEvents ?? false, (result, event) => this.handleSessionOperation(result, event));
+        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 }));
         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;
@@ -214,12 +415,12 @@ export class PiboSessionRouter {
             channel: source.channel,
             kind: "branch",
             profile: source.profile,
-            ownerScope: source.ownerScope,
             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,
@@ -227,22 +428,27 @@ export class PiboSessionRouter {
             },
         });
     }
-    async resetCachedSession(piboSessionId) {
+    async resetCachedSession(piboSessionId, reason) {
         const cached = this.sessions.get(piboSessionId);
         this.sessions.delete(piboSessionId);
+        await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
         await cached?.dispose();
+        if (reason)
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId, reason });
     }
     resolvePiboSession(piboSessionId) {
         const existing = this.sessionStore.get(piboSessionId);
         if (existing)
             return existing;
-        return this.sessionStore.create({
+        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 {
@@ -275,7 +481,7 @@ export class PiboSessionRouter {
         return {
             startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, execute }) => {
                 const run = this.runRegistry.startToolRun({
-                    ownerPiboSessionId: parentPiboSessionId,
+                    controllerPiboSessionId: parentPiboSessionId,
                     toolName,
                     params,
                     completionPolicy,
@@ -287,12 +493,12 @@ export class PiboSessionRouter {
                         const result = await execute();
                         const completed = this.runRegistry.complete(run.runId, result);
                         if (completed)
-                            this.scheduleRunNotification(parentPiboSessionId, false);
+                            this.scheduleRunReminder(parentPiboSessionId, false);
                     }
                     catch (error) {
                         const failed = this.runRegistry.fail(run.runId, error instanceof Error ? error.message : String(error));
                         if (failed)
-                            this.scheduleRunNotification(parentPiboSessionId, false);
+                            this.scheduleRunReminder(parentPiboSessionId, false);
                     }
                 })();
                 return run;
@@ -303,18 +509,18 @@ export class PiboSessionRouter {
             readRun: (runId) => {
                 const run = this.runRegistry.read(parentPiboSessionId, runId);
                 if (run.consumed && isTerminalRunStatus(run.status)) {
-                    this.refreshQueuedRunNotifications(parentPiboSessionId);
+                    this.refreshQueuedRunReminders(parentPiboSessionId);
                 }
                 return run;
             },
             cancelRun: async (runId) => {
                 const cancelled = this.runRegistry.cancel(parentPiboSessionId, runId);
-                this.refreshQueuedRunNotifications(parentPiboSessionId);
+                this.refreshQueuedRunReminders(parentPiboSessionId);
                 return cancelled;
             },
             ackRun: (runId) => {
                 const run = this.runRegistry.ack(parentPiboSessionId, runId);
-                this.refreshQueuedRunNotifications(parentPiboSessionId);
+                this.refreshQueuedRunReminders(parentPiboSessionId);
                 return run;
             },
         };
@@ -339,83 +545,105 @@ export class PiboSessionRouter {
         return depth;
     }
     resolveSubagentSession(parentPiboSessionId, subagent, threadKey) {
-        const targetProfile = this.pluginRegistry.resolveProfileName(subagent.targetProfile);
+        const targetProfile = resolvePiboProfileNameFromRegistryOrDefault(this.pluginRegistry, subagent.targetProfile);
         const parent = this.resolvePiboSession(parentPiboSessionId);
         const resolvedThreadKey = threadKey?.trim() ? threadKey.trim() : randomUUID();
-        const metadata = {
+        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 = parentChatRoomId
-            ? {
-                subagentName: subagent.name,
-                subagentToolName: createSubagentToolName(subagent.name),
-                threadKey: resolvedThreadKey,
-            }
-            : metadata;
-        const existing = this.sessionStore.find({
-            channel: "pibo.subagents",
-            kind: "subagent",
-            parentId: parent.id,
-            profile: targetProfile,
-            metadata,
-        })[0] ?? this.sessionStore.find({
-            channel: "pibo.subagents",
-            kind: "subagent",
-            parentId: parent.id,
-            profile: targetProfile,
-            metadata: legacyMetadata,
-        })[0];
+        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) {
-            if (parentChatRoomId && existing.metadata?.chatRoomId !== parentChatRoomId) {
-                return this.sessionStore.update(existing.id, { metadata: { ...(existing.metadata ?? {}), chatRoomId: parentChatRoomId } }) ?? 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;
         }
-        return this.sessionStore.create({
+        const childProfile = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, targetProfile);
+        const childSession = this.sessionStore.create({
             channel: "pibo.subagents",
             kind: "subagent",
             profile: targetProfile,
-            ownerScope: parent.ownerScope,
             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.scheduleRunNotification(event.piboSessionId, true);
+            this.scheduleRunReminder(event.piboSessionId, true);
         }
     };
-    scheduleRunNotification(piboSessionId, includeAlreadyNotified) {
+    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.scheduledRunNotifications.get(piboSessionId);
+        const previous = this.scheduledRunReminders.get(piboSessionId);
         if (previous !== undefined) {
-            this.scheduledRunNotifications.set(piboSessionId, previous || includeAlreadyNotified);
+            this.scheduledRunReminders.set(piboSessionId, previous || includeAlreadyNotified);
             return;
         }
-        this.scheduledRunNotifications.set(piboSessionId, includeAlreadyNotified);
+        this.scheduledRunReminders.set(piboSessionId, includeAlreadyNotified);
         queueMicrotask(() => {
-            void this.deliverRunNotification(piboSessionId);
+            void this.deliverRunReminder(piboSessionId);
         });
     }
-    refreshQueuedRunNotifications(piboSessionId) {
-        const removed = this.sessions.get(piboSessionId)?.removeQueuedMessages(isRunNotificationServiceMessage) ?? 0;
+    refreshQueuedRunReminders(piboSessionId) {
+        const removed = this.sessions.get(piboSessionId)?.removeQueuedMessages(isRunReminderServiceMessage) ?? 0;
         if (removed > 0)
-            this.scheduleRunNotification(piboSessionId, true);
+            this.scheduleRunReminder(piboSessionId, true);
     }
-    async deliverRunNotification(piboSessionId) {
-        const includeAlreadyNotified = this.scheduledRunNotifications.get(piboSessionId) ?? false;
-        this.scheduledRunNotifications.delete(piboSessionId);
+    async deliverRunReminder(piboSessionId) {
+        const includeAlreadyNotified = this.scheduledRunReminders.get(piboSessionId) ?? false;
+        this.scheduledRunReminders.delete(piboSessionId);
         const notification = this.runRegistry.createNotification(piboSessionId, { includeAlreadyNotified });
         if (!notification)
             return;
@@ -424,16 +652,18 @@ export class PiboSessionRouter {
             session.enqueueMessage({
                 type: "message",
                 piboSessionId,
-                text: formatRunNotification(notification),
+                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: error instanceof Error ? error.message : String(error),
+                error: message,
+                errorDetails: runtimeSessionErrorDetails(message),
             });
         }
     }

package/dist/core/shared-app.js

@@ -0,0 +1,17 @@
+export const SHARED_APP_SCOPE = "shared:app";
+export const SHARED_PRINCIPAL_ID = "shared:app";
+export function compatibleOwnerScopes(ownerScope) {
+    if (!ownerScope || ownerScope === SHARED_APP_SCOPE)
+        return [SHARED_APP_SCOPE];
+    return [ownerScope, SHARED_APP_SCOPE];
+}
+export function compatiblePrincipalIds(principalId) {
+    if (!principalId || principalId === SHARED_PRINCIPAL_ID)
+        return [SHARED_PRINCIPAL_ID];
+    return [principalId, SHARED_PRINCIPAL_ID];
+}
+export function isCompatibleOwnerScope(actual, expected) {
+    if (!expected)
+        return true;
+    return compatibleOwnerScopes(expected).includes(actual ?? SHARED_APP_SCOPE);
+}

package/dist/core/skill-expansion.js

@@ -0,0 +1,43 @@
+import { readFileSync } from "node:fs";
+export function expandInlineSkills(text, skills) {
+    try {
+        const pattern = /(?<!\\)\$([a-z0-9-]+)/g;
+        const matches = [...text.matchAll(pattern)];
+        const seen = new Set();
+        const toExpand = [];
+        for (const match of matches) {
+            const name = match[1];
+            if (seen.has(name))
+                continue;
+            const skill = skills.find((s) => s.name === name);
+            if (!skill)
+                continue;
+            seen.add(name);
+            toExpand.push(skill);
+        }
+        if (toExpand.length === 0)
+            return text;
+        const appendices = toExpand.map((skill) => {
+            try {
+                const content = readFileSync(skill.filePath, "utf-8");
+                const body = stripFrontmatter(content).trim();
+                return `---\n\n$${skill.name}\n${body}`;
+            }
+            catch {
+                return `---\n\n$${skill.name}\n[Error: could not load skill content]`;
+            }
+        });
+        return `${text}\n\n${appendices.join("\n\n")}`;
+    }
+    catch {
+        return text;
+    }
+}
+function stripFrontmatter(content) {
+    if (!content.startsWith("---"))
+        return content;
+    const endIndex = content.indexOf("---", 3);
+    if (endIndex === -1)
+        return content;
+    return content.slice(endIndex + 3).trimStart();
+}