@pasko70/pibo 2.1.1 → 2.2.0

package/dist/core/profiles.js

@@ -37,6 +37,7 @@ export class InitialSessionContext {
     builtinTools;
     builtinToolNames;
     autoContextFiles;
+    nativeSubagents;
     toolPackages;
     constructor(options) {
         this.profileName = options.profileName;
@@ -62,6 +63,7 @@ export class InitialSessionContext {
         this.builtinTools = options.builtinTools ?? "default";
         this.builtinToolNames = [...(options.builtinToolNames ?? DEFAULT_BUILTIN_TOOL_NAMES)];
         this.autoContextFiles = options.autoContextFiles ?? true;
+        this.nativeSubagents = options.nativeSubagents;
         this.toolPackages = { ...(options.toolPackages ?? {}) };
     }
 }
@@ -89,6 +91,7 @@ export class InitialSessionContextBuilder {
     builtinTools = "default";
     builtinToolNames = [...DEFAULT_BUILTIN_TOOL_NAMES];
     autoContextFiles = true;
+    nativeSubagents;
     toolPackages = {};
     constructor(profileName) {
         this.profileName = profileName;
@@ -154,6 +157,10 @@ export class InitialSessionContextBuilder {
         this.autoContextFiles = enabled;
         return this;
     }
+    withNativeSubagents(enabled) {
+        this.nativeSubagents = enabled;
+        return this;
+    }
     withToolPackages(packages) {
         this.toolPackages = { ...packages };
         return this;
@@ -231,6 +238,7 @@ export class InitialSessionContextBuilder {
             builtinTools: this.builtinTools,
             builtinToolNames: this.builtinToolNames,
             autoContextFiles: this.autoContextFiles,
+            nativeSubagents: this.nativeSubagents,
             toolPackages: this.toolPackages,
         });
     }

package/dist/core/sensitive-data-redaction.js

@@ -0,0 +1,36 @@
+const SENSITIVE_KEY_PATTERN = /(?:authorization|cookie|credential|access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|bearer|oauth|token|secret|password|passwd)/i;
+const SENSITIVE_TEXT_PATTERNS = [
+    [/\bBearer\s+\S+/gi, "Bearer [redacted]"],
+    [/\b(?:sk|pk|rk|ghp|gho|ghu|ghs|ghr|github_pat|pibo|xoxb|xoxp|xoxa|xoxr)[-_][A-Za-z0-9_-]{8,}\b/g, "[redacted]"],
+    [/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, "[redacted]"],
+    [/\b(access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|authorization|cookie|credential|oauth|token|secret|password|passwd)\b(\s*["']?\s*[:=]\s*["']?)([^\s"'&,;}]+)/gi, "$1$2[redacted]"],
+];
+export function redactSensitiveText(value) {
+    let selected = value;
+    for (const [pattern, replacement] of SENSITIVE_TEXT_PATTERNS)
+        selected = selected.replace(pattern, replacement);
+    return selected;
+}
+export function redactSensitiveValue(value, key, depth = 0) {
+    if (key && SENSITIVE_KEY_PATTERN.test(key))
+        return "[redacted]";
+    if (depth > 32)
+        return "[maximum depth reached]";
+    if (value === null || value === undefined || typeof value === "boolean")
+        return value;
+    if (typeof value === "string")
+        return redactSensitiveText(value);
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (Array.isArray(value))
+        return value.map((entry) => redactSensitiveValue(entry, undefined, depth + 1));
+    if (typeof value === "object") {
+        const result = {};
+        for (const [entryKey, entryValue] of Object.entries(value)) {
+            if (entryValue !== undefined)
+                result[entryKey] = redactSensitiveValue(entryValue, entryKey, depth + 1);
+        }
+        return result;
+    }
+    return String(value);
+}

package/dist/core/session-model.js

@@ -31,6 +31,7 @@ function profileWithSessionIds(profile, piSessionId, parentPiSessionId) {
         builtinTools: profile.builtinTools,
         builtinToolNames: profile.builtinToolNames,
         autoContextFiles: profile.autoContextFiles,
+        nativeSubagents: profile.nativeSubagents,
         toolPackages: profile.toolPackages,
     });
 }

package/dist/core/session-router.js

@@ -27,6 +27,7 @@ import { AsyncTelemetryWriter } from "../data/telemetry-writer.js";
 import { createPiboToolPayloadWriter } from "../tools/payload-writer.js";
 import { PiboPortableToolService, } from "../tools/session-service.js";
 import { PiboRuntimeResourceService, } from "../agent-runtime/resource-service.js";
+import { PORTABLE_HISTORY_HANDOFF_METADATA_KEY, PORTABLE_HISTORY_LAST_IMPORT_METADATA_KEY, PiboDataPortableHistoryProvider, createPortableHistoryHandoffMetadata, readPortableHistoryHandoffMetadata, withoutPortableHistoryHandoffMetadata, withPortableHistoryHandoffMetadata, } from "../agent-runtime/portable-history.js";
 const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_SUBAGENT_MAX_DEPTH = 3;
 const MAX_SUBAGENT_THREAD_KEY_BYTES = 512;
@@ -68,15 +69,16 @@ function subagentAbortError() {
     return error;
 }
 function profileForSession(baseProfile, runtimeInstanceId, nativeSessionId, parentNativeSessionId, subagentDepth) {
+    const usesProfileRuntime = baseProfile.runtimeInstanceId === runtimeInstanceId;
     const options = {
         profileName: baseProfile.profileName,
         runtimeInstanceId,
-        runtimeOptions: baseProfile.runtimeOptions,
+        runtimeOptions: usesProfileRuntime ? baseProfile.runtimeOptions : {},
         sessionId: nativeSessionId,
         parentSessionId: parentNativeSessionId,
-        model: baseProfile.model,
-        mainModel: baseProfile.mainModel,
-        subagentModel: baseProfile.subagentModel,
+        model: usesProfileRuntime ? baseProfile.model : undefined,
+        mainModel: usesProfileRuntime ? baseProfile.mainModel : undefined,
+        subagentModel: usesProfileRuntime ? baseProfile.subagentModel : undefined,
         thinkingLevel: baseProfile.thinkingLevel,
         mainThinkingLevel: baseProfile.mainThinkingLevel,
         subagentThinkingLevel: baseProfile.subagentThinkingLevel,
@@ -92,6 +94,7 @@ function profileForSession(baseProfile, runtimeInstanceId, nativeSessionId, pare
         builtinTools: baseProfile.builtinTools,
         builtinToolNames: baseProfile.builtinToolNames,
         autoContextFiles: baseProfile.autoContextFiles,
+        nativeSubagents: usesProfileRuntime ? baseProfile.nativeSubagents : undefined,
         toolPackages: baseProfile.toolPackages,
     };
     return new InitialSessionContext(options);
@@ -179,6 +182,18 @@ function runtimeBindingsEqual(left, right) {
         && JSON.stringify(left.locator ?? null) === JSON.stringify(right.locator ?? null)
         && JSON.stringify(left.metadata ?? {}) === JSON.stringify(right.metadata ?? {});
 }
+function withPersistedPortableHistoryAuditMetadata(persisted, live) {
+    const metadata = { ...(live.metadata ?? {}) };
+    for (const key of [PORTABLE_HISTORY_HANDOFF_METADATA_KEY, PORTABLE_HISTORY_LAST_IMPORT_METADATA_KEY]) {
+        if (Object.prototype.hasOwnProperty.call(persisted.metadata ?? {}, key)) {
+            metadata[key] = structuredClone(persisted.metadata[key]);
+        }
+        else {
+            delete metadata[key];
+        }
+    }
+    return { ...live, metadata };
+}
 class PiboSessionDisposalTimeoutError extends Error {
     piboSessionId;
     timeoutMs;
@@ -195,6 +210,10 @@ function telemetryStoreFromSessionStore(store) {
 function payloadStoreFromSessionStore(store) {
     return store.getPayloadStore?.();
 }
+function portableHistoryProviderFromSessionStore(store) {
+    const dataStore = store.getDataStore?.();
+    return dataStore ? new PiboDataPortableHistoryProvider(dataStore) : undefined;
+}
 function providerEventTelemetryModeFromEnv(env = process.env) {
     const value = env.PIBO_TELEMETRY_PROVIDER_EVENTS?.trim().toLowerCase();
     return value === "1" || value === "true" || value === "detailed" ? "detailed" : "aggregate";
@@ -211,11 +230,13 @@ export class PiboSessionRouter {
     portableToolService;
     portableToolSessions = new Map();
     runtimeResourceService;
+    portableHistoryProvider;
     runtimeResourceSessions = new Map();
     runtimeAuthFingerprints = new Map();
     activeSubagentChildren = new Map();
     scheduledRunReminders = new Map();
     runReminderGenerations = new Map();
+    runCancellationHandlers = new Map();
     quiescingSessions = new Set();
     disposingSessions = new Map();
     idleSessionTimers = new Map();
@@ -266,6 +287,7 @@ export class PiboSessionRouter {
             ...(payloadStore ? { payloadWriter: createPiboToolPayloadWriter(payloadStore) } : {}),
         });
         this.runtimeResourceService = options.runtimeResourceService ?? new PiboRuntimeResourceService();
+        this.portableHistoryProvider = options.portableHistoryProvider ?? portableHistoryProviderFromSessionStore(this.sessionStore);
         this.runRegistry = new PiboRunRegistry({ store: this.reliabilityStore });
         this.runRegistry.subscribe((event) => this.projectRunRegistryEvent(event));
         const recoveredRuntimeState = options.recoverInterruptedRuntimeState
@@ -334,6 +356,9 @@ export class PiboSessionRouter {
         if (teardownAction)
             this.beginSessionQuiescence(teardownIds);
         try {
+            if (!teardownAction && this.quiescingSessions.has(event.piboSessionId)) {
+                throw new Error(`Pibo session "${event.piboSessionId}" is quiescing.`);
+            }
             if (event.type === "message") {
                 return event.delivery === "steer"
                     ? await session.steerMessage(event)
@@ -428,6 +453,12 @@ export class PiboSessionRouter {
             if (options?.includeRuns) {
                 const runs = this.runRegistry.cancelControllerRuns(id);
                 cancelledRuns.push(...runs.map((run) => run.runId));
+                try {
+                    await this.invokeRunCancellationHandlers(runs);
+                }
+                catch (error) {
+                    failures.push(error);
+                }
             }
         }
         try {
@@ -477,16 +508,18 @@ export class PiboSessionRouter {
         if (existingDisposals.length > 0)
             await Promise.all(existingDisposals);
         this.beginSessionQuiescence(ids);
-        if (options.cancelRuns) {
-            for (const id of ids)
-                this.runRegistry.cancelControllerRuns(id);
-        }
         let releaseStart;
         const startGate = new Promise((resolve) => {
             releaseStart = resolve;
         });
         const operation = (async () => {
             await startGate;
+            const runCancellationResults = options.cancelRuns
+                ? await Promise.allSettled(ids.map(async (id) => {
+                    const runs = this.runRegistry.cancelControllerRuns(id);
+                    await this.invokeRunCancellationHandlers(runs);
+                }))
+                : [];
             const pending = ids.map((id) => this.pendingSessions.get(id)).filter((value) => Boolean(value));
             if (pending.length > 0)
                 await Promise.allSettled(pending);
@@ -494,7 +527,7 @@ export class PiboSessionRouter {
                 const session = this.sessions.get(id);
                 return session ? [{ id, session }] : [];
             });
-            const failures = [];
+            const failures = runCancellationResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
             const closeResults = await Promise.allSettled(ids.map((id) => this.runtimeRegistry.closeControllerSessions(id, { force: true })));
             for (const result of closeResults) {
                 if (result.status === "rejected")
@@ -550,6 +583,7 @@ export class PiboSessionRouter {
                 if (options?.includeRuns) {
                     const runs = this.runRegistry.cancelControllerRuns(session.id);
                     cancelledRuns.push(...runs.map((r) => r.runId));
+                    await this.invokeRunCancellationHandlers(runs);
                 }
                 const nested = await this.killChildSessions(session.id, options);
                 killed.push(...nested.killed);
@@ -606,6 +640,20 @@ export class PiboSessionRouter {
         return session ? structuredClone(this.resolveSessionRuntimeBinding(session)) : undefined;
     }
     async rebindSessionRuntime(piboSessionId, input) {
+        if (this.quiescingSessions.has(piboSessionId)) {
+            throw new Error(`Pibo session "${piboSessionId}" is already quiescing.`);
+        }
+        this.quiescingSessions.add(piboSessionId);
+        this.clearIdleSessionTimer(piboSessionId);
+        try {
+            return await this.rebindSessionRuntimeQuiesced(piboSessionId, input);
+        }
+        finally {
+            this.quiescingSessions.delete(piboSessionId);
+            this.scheduleIdleSessionEvictionIfIdle(piboSessionId);
+        }
+    }
+    async rebindSessionRuntimeQuiesced(piboSessionId, input) {
         const session = this.sessionStore.get(piboSessionId);
         if (!session)
             throw new Error(`Unknown Pibo session "${piboSessionId}".`);
@@ -618,38 +666,94 @@ export class PiboSessionRouter {
         if (liveStatus && (liveStatus.processing || liveStatus.streaming || liveStatus.queuedMessages > 0)) {
             throw new Error("A runtime binding can only be repaired or rebound while the session is idle.");
         }
+        const registry = this.resolveAgentRuntimeRegistry(input.runtimeInstanceId);
+        const adapter = registry.requireAgentRuntimeAdapter(input.runtimeInstanceId);
+        const switchingRuntime = current.runtimeInstanceId !== input.runtimeInstanceId
+            || current.adapterId !== adapter.descriptor.id;
+        const startsNewNativeSession = switchingRuntime || input.startFresh === true;
+        const portableHistoryProvider = this.portableHistoryProvider;
+        if (startsNewNativeSession && (input.nativeSessionId || input.state === "bound" || input.locator)) {
+            throw new Error("Runtime switches create a new native session; nativeSessionId, bound state, and locator are not accepted.");
+        }
+        if (switchingRuntime && input.startFresh !== true) {
+            if (!adapter.descriptor.capabilities.historyImport) {
+                throw new Error(`Runtime instance "${input.runtimeInstanceId}" cannot import portable history. Retry with startFresh: true to discard prior context explicitly.`);
+            }
+            if (!portableHistoryProvider) {
+                throw new Error("Portable Pibo history is unavailable for this session store. Retry with startFresh: true to discard prior context explicitly.");
+            }
+        }
+        const workspace = session.workspace ?? this.options.cwd ?? getDefaultPiboWorkspace();
+        const baseProfile = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, session.profile);
+        const targetProfile = profileForSession(baseProfile, input.runtimeInstanceId, startsNewNativeSession ? undefined : input.nativeSessionId, undefined, this.getSubagentDepth(session.id));
+        const targetDiagnostics = await adapter.diagnose();
+        const unavailableTarget = targetDiagnostics.find((diagnostic) => diagnostic.severity === "error");
+        if (unavailableTarget) {
+            throw new Error(`Runtime target preflight failed: ${unavailableTarget.message}`);
+        }
+        const profileDiagnostics = [
+            ...validateAgentRuntimeProfileCapabilities(targetProfile, adapter.descriptor.capabilities),
+            ...adapter.validateProfile({ profile: targetProfile, workspace }),
+        ];
+        const invalidProfile = profileDiagnostics.find((diagnostic) => diagnostic.severity === "error");
+        if (invalidProfile)
+            throw new Error(`Runtime profile validation failed: ${invalidProfile.message}`);
+        let handoffMetadata;
+        if (switchingRuntime && input.startFresh !== true) {
+            handoffMetadata = createPortableHistoryHandoffMetadata({
+                mode: "import",
+                sourceBinding: current,
+                targetBinding: {
+                    runtimeInstanceId: input.runtimeInstanceId,
+                    adapterId: adapter.descriptor.id,
+                },
+                checkpoint: portableHistoryProvider.createCheckpoint(piboSessionId),
+            });
+        }
+        else if (input.startFresh === true) {
+            handoffMetadata = createPortableHistoryHandoffMetadata({
+                mode: "fresh",
+                sourceBinding: current,
+                targetBinding: {
+                    runtimeInstanceId: input.runtimeInstanceId,
+                    adapterId: adapter.descriptor.id,
+                },
+            });
+        }
         if (this.sessions.has(piboSessionId) || this.pendingSessions.has(piboSessionId)) {
             await this.resetCachedSession(piboSessionId, "runtime binding rebind");
         }
-        const registry = this.resolveAgentRuntimeRegistry(input.runtimeInstanceId);
-        const adapter = registry.requireAgentRuntimeAdapter(input.runtimeInstanceId);
-        const requestedState = input.state ?? (input.nativeSessionId ? "bound" : "unbound");
+        const requestedState = startsNewNativeSession
+            ? "unbound"
+            : input.state ?? (input.nativeSessionId ? "bound" : "unbound");
         let next = {
             piboSessionId,
             runtimeInstanceId: input.runtimeInstanceId,
             adapterId: adapter.descriptor.id,
-            nativeSessionId: input.nativeSessionId,
+            nativeSessionId: startsNewNativeSession ? undefined : input.nativeSessionId,
             state: requestedState,
             protocol: adapter.descriptor.protocol?.name,
             protocolVersion: current.runtimeInstanceId === input.runtimeInstanceId ? current.protocolVersion : undefined,
-            locator: input.locator,
-            metadata: {},
+            locator: startsNewNativeSession ? undefined : input.locator,
+            metadata: handoffMetadata
+                ? withPortableHistoryHandoffMetadata({}, handoffMetadata)
+                : {},
         };
         if (next.state === "bound" && adapter.resolveBinding) {
-            next = await adapter.resolveBinding({
-                binding: next,
-                workspace: session.workspace ?? this.options.cwd ?? getDefaultPiboWorkspace(),
-            });
+            next = await adapter.resolveBinding({ binding: next, workspace });
         }
         const mode = (current.state === "missing" || current.state === "error")
             && current.runtimeInstanceId === next.runtimeInstanceId
             && current.adapterId === next.adapterId
+            && input.startFresh !== true
             ? "repair"
             : "rebind";
         const persisted = this.persistSessionRuntimeBinding(session, next, {
             expectedRevision: input.expectedRevision,
             mode,
         });
+        if (switchingRuntime)
+            this.sessionStore.update(piboSessionId, { activeModel: null });
         return structuredClone(persisted);
     }
     getSessionRuntimeStatus(piboSessionId) {
@@ -799,7 +903,8 @@ export class PiboSessionRouter {
             for (const timer of this.idleSessionTimers.values())
                 clearTimeout(timer);
             this.idleSessionTimers.clear();
-            this.runRegistry.cancelAll("Pibo session router was disposed.");
+            const cancelledRuns = this.runRegistry.cancelAll("Pibo session router was disposed.");
+            const runCancellationResult = await Promise.allSettled([this.invokeRunCancellationHandlers(cancelledRuns)]);
             this.scheduledRunReminders.clear();
             const closeResult = await Promise.allSettled([this.runtimeRegistry.closeAll({ force: true })]);
             const disposeResults = await Promise.allSettled(sessions.map(([id, session]) => this.disposeRoutedSession(id, session, "router disposed")));
@@ -809,6 +914,7 @@ export class PiboSessionRouter {
                 this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason: "router disposed" });
             }
             const failures = [
+                ...runCancellationResult.filter((result) => result.status === "rejected").map((result) => result.reason),
                 ...closeResult.filter((result) => result.status === "rejected").map((result) => result.reason),
                 ...disposeResults.filter((result) => result.status === "rejected").map((result) => result.reason),
             ];
@@ -820,14 +926,20 @@ export class PiboSessionRouter {
                 this.pluginRegistry.disposeAgentRuntimeAuth(),
                 ...(this.compatibilityRuntimeRegistry ? [this.compatibilityRuntimeRegistry.disposeAgentRuntimeAuth()] : []),
             ]);
+            const ownedPluginRegistries = this.options.pluginRegistry === undefined
+                ? [this.pluginRegistry]
+                : this.compatibilityRuntimeRegistry ? [this.compatibilityRuntimeRegistry] : [];
+            const webAppDisposals = await Promise.allSettled(ownedPluginRegistries.flatMap((registry) => registry.getWebApps().map((app) => app.dispose?.())));
             await this.portableToolService.dispose();
             await this.runtimeResourceService.dispose();
             this.runtimeResourceSessions.clear();
             this.activeSubagentChildren.clear();
             await this.telemetryWriter?.dispose();
-            const authFailures = authDisposals.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-            if (authFailures.length > 0)
-                throw new AggregateError(authFailures, "Failed to dispose runtime authentication controllers.");
+            const lifecycleFailures = [...authDisposals, ...webAppDisposals]
+                .flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (lifecycleFailures.length > 0) {
+                throw new AggregateError(lifecycleFailures, "Failed to dispose runtime authentication controllers or web apps.");
+            }
         }
     }
     clearIdleSessionTimer(piboSessionId) {
@@ -915,9 +1027,23 @@ export class PiboSessionRouter {
             ? parentBinding.nativeSessionId
             : undefined;
         const modelDefaults = this.resolveModelDefaults();
-        const activeModel = this.ensureSessionActiveModel(piboSession, profile, parentModelScopeId, modelDefaults);
         const initialThinkingLevel = resolvePiboSessionInitialThinkingLevel(piboSession);
         const sessionProfile = profileForSession(profile, binding.runtimeInstanceId, binding.nativeSessionId, runtimeParentNativeSessionId, this.getSubagentDepth(piboSession.id));
+        const persistedHistoryHandoff = readPortableHistoryHandoffMetadata(binding.metadata);
+        if (binding.metadata?.[PORTABLE_HISTORY_HANDOFF_METADATA_KEY] !== undefined && !persistedHistoryHandoff) {
+            throw new Error("The pending portable history handoff metadata is invalid; refusing to start a contextless target runtime.");
+        }
+        if (persistedHistoryHandoff
+            && (persistedHistoryHandoff.targetRuntimeInstanceId !== binding.runtimeInstanceId
+                || persistedHistoryHandoff.targetAdapterId !== binding.adapterId)) {
+            throw new Error("The pending portable history handoff targets a different runtime binding; refusing to import it.");
+        }
+        const changesRuntimeModelNamespace = Boolean(persistedHistoryHandoff
+            && (persistedHistoryHandoff.sourceRuntimeInstanceId !== binding.runtimeInstanceId
+                || persistedHistoryHandoff.sourceAdapterId !== binding.adapterId));
+        const activeModel = changesRuntimeModelNamespace
+            ? undefined
+            : this.ensureSessionActiveModel(piboSession, sessionProfile, parentModelScopeId, modelDefaults);
         const userSettings = loadPiboUserSettings();
         const telemetryExtension = this.telemetryStore
             ? createPiboProviderTelemetryExtension({ store: this.telemetryStore, writer: this.telemetryWriter, session: piboSession, model: activeModel })
@@ -948,6 +1074,29 @@ export class PiboSessionRouter {
         if (invalidProfile) {
             throw new Error(`Runtime profile validation failed: ${invalidProfile.message}`);
         }
+        let historyHandoff;
+        if (persistedHistoryHandoff?.mode === "import") {
+            if (!runtimeAdapter.descriptor.capabilities.historyImport) {
+                throw new Error(`Runtime instance "${binding.runtimeInstanceId}" no longer supports portable history import.`);
+            }
+            if (!this.portableHistoryProvider || !persistedHistoryHandoff.checkpoint) {
+                throw new Error("Portable Pibo history is unavailable for the pending runtime switch.");
+            }
+            historyHandoff = {
+                mode: "import",
+                history: this.portableHistoryProvider.read({
+                    piboSession,
+                    sourceBinding: {
+                        runtimeInstanceId: persistedHistoryHandoff.sourceRuntimeInstanceId,
+                        adapterId: persistedHistoryHandoff.sourceAdapterId,
+                    },
+                    checkpoint: persistedHistoryHandoff.checkpoint,
+                }),
+            };
+        }
+        else if (persistedHistoryHandoff?.mode === "fresh") {
+            historyHandoff = { mode: "fresh" };
+        }
         const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(sessionProfile, modelDefaults) ?? false;
         const subagentRunner = this.createSubagentRunner(piboSession.id);
         const runToolController = this.createRunToolController(piboSession.id);
@@ -995,11 +1144,16 @@ export class PiboSessionRouter {
         let runtimeSession;
         try {
             runtimeSession = await runtimeRegistry.openAgentRuntimeSession(binding.runtimeInstanceId, {
-                piboSession: { ...piboSession, runtimeBinding: binding },
+                piboSession: {
+                    ...piboSession,
+                    ...(changesRuntimeModelNamespace ? { activeModel: undefined } : {}),
+                    runtimeBinding: binding,
+                },
                 profile: sessionProfile,
                 binding,
                 workspace,
                 activeModel,
+                historyHandoff,
                 productContext: {
                     piboSessionId: piboSession.id,
                     piboRoomId: piboRoomIdFromMetadata(piboSession.metadata),
@@ -1049,10 +1203,25 @@ export class PiboSessionRouter {
             throw error;
         }
         try {
-            const openedBinding = runtimeSession.getBinding();
+            let openedBinding = runtimeSession.getBinding();
             if (openedBinding.runtimeInstanceId !== binding.runtimeInstanceId || openedBinding.adapterId !== binding.adapterId) {
                 throw new AgentRuntimeUnavailableError(binding.runtimeInstanceId, `Runtime instance "${binding.runtimeInstanceId}" opened an inconsistent binding for Pibo session "${piboSession.id}".`);
             }
+            if (persistedHistoryHandoff) {
+                openedBinding = {
+                    ...openedBinding,
+                    metadata: withoutPortableHistoryHandoffMetadata({
+                        metadata: openedBinding.metadata,
+                        handoff: persistedHistoryHandoff,
+                        history: historyHandoff?.mode === "import" ? historyHandoff.history : undefined,
+                    }),
+                };
+            }
+            if (changesRuntimeModelNamespace) {
+                this.sessionStore.update(piboSession.id, {
+                    activeModel: runtimeSession.getStatus().activeModel ?? null,
+                });
+            }
             if (!runtimeBindingsEqual(binding, openedBinding)) {
                 binding = this.persistSessionRuntimeBinding(piboSession, openedBinding, {
                     expectedRevision: binding.revision,
@@ -1183,7 +1352,8 @@ export class PiboSessionRouter {
         if (!session)
             return;
         try {
-            this.persistSessionRuntimeBinding(session, runtimeSession.getBinding());
+            const persisted = this.resolveSessionRuntimeBinding(session);
+            this.persistSessionRuntimeBinding(session, withPersistedPortableHistoryAuditMetadata(persisted, runtimeSession.getBinding()));
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -1445,9 +1615,21 @@ export class PiboSessionRouter {
             },
         };
     }
+    async invokeRunCancellationHandlers(runs) {
+        const results = await Promise.allSettled(runs.map(async (run) => {
+            const cancel = this.runCancellationHandlers.get(run.runId);
+            if (!cancel)
+                return;
+            this.runCancellationHandlers.delete(run.runId);
+            await cancel();
+        }));
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length > 0)
+            throw new AggregateError(failures, "Failed to terminate cancelled yielded runs.");
+    }
     createRunToolController(parentPiboSessionId) {
         return {
-            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, timeoutMs, serviceWarning, resources, execute }) => {
+            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, timeoutMs, serviceWarning, resources, execute, cancel }) => {
                 const admission = this.gatewayWorkAdmission.reserve(`yielded run ${toolName}`);
                 if (resources)
                     resources.admission = admission.admission;
@@ -1470,6 +1652,8 @@ export class PiboSessionRouter {
                     admission.release();
                     throw error;
                 }
+                if (cancel)
+                    this.runCancellationHandlers.set(run.runId, cancel);
                 void (async () => {
                     try {
                         const result = await execute();
@@ -1492,6 +1676,7 @@ export class PiboSessionRouter {
                             this.handleTerminalRunReminder(parentPiboSessionId, terminalRun.runId, reminderGeneration);
                     }
                     finally {
+                        this.runCancellationHandlers.delete(run.runId);
                         admission.release();
                     }
                 })();
@@ -1508,7 +1693,12 @@ export class PiboSessionRouter {
             },
             cancelRun: async (runId) => {
                 const cancelled = this.runRegistry.cancel(parentPiboSessionId, runId);
-                this.refreshQueuedRunReminders(parentPiboSessionId);
+                try {
+                    await this.invokeRunCancellationHandlers([cancelled]);
+                }
+                finally {
+                    this.refreshQueuedRunReminders(parentPiboSessionId);
+                }
                 return cancelled;
             },
             ackRun: (runId) => {

package/dist/data/pibo-store.js

@@ -1,7 +1,8 @@
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { piboHomePath } from "../core/pibo-home.js";
+import { ensurePrivatePiboHomeForPath, piboHomePath } from "../core/pibo-home.js";
+import { protectPrivateFileSync } from "../core/private-path.js";
 import { PiboEventLogStore } from "./event-log.js";
 import { MessageStore } from "./message-store.js";
 import { NavigationStore } from "./navigation-store.js";
@@ -22,9 +23,12 @@ export class PiboDataStore {
     telemetry;
     constructor(path = piboHomePath("pibo.sqlite"), options = {}) {
         this.path = path === ":memory:" ? path : resolve(path);
+        const insidePiboHome = ensurePrivatePiboHomeForPath(this.path);
         if (this.path !== ":memory:")
             mkdirSync(dirname(this.path), { recursive: true });
         this.db = new DatabaseSync(this.path);
+        if (insidePiboHome)
+            protectPrivateFileSync(this.path);
         this.db.exec("PRAGMA busy_timeout = 5000");
         this.db.exec("PRAGMA foreign_keys = ON");
         if (this.path !== ":memory:")

package/dist/gateway/server.js

@@ -129,6 +129,7 @@ export class PiboGatewayServer {
     options;
     pluginRegistry;
     compatibilityRuntimeRegistry;
+    ownsPluginRegistry;
     runtimeInstanceId;
     sessionStore;
     ownsSessionStore = false;
@@ -142,6 +143,7 @@ export class PiboGatewayServer {
     resourceReaper;
     constructor(options = {}) {
         this.options = options;
+        this.ownsPluginRegistry = options.pluginRegistry === undefined;
         this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
         this.compatibilityRuntimeRegistry = options.pluginRegistry ? createDefaultPiboPluginRegistry() : undefined;
         this.runtimeInstanceId = options.runtimeInstanceId ?? `gateway:${process.pid}:${randomUUID()}`;
@@ -200,6 +202,13 @@ export class PiboGatewayServer {
         }
         await this.router?.disposeAll();
         this.router = undefined;
+        const ownedPluginRegistries = this.ownsPluginRegistry
+            ? [this.pluginRegistry]
+            : this.compatibilityRuntimeRegistry ? [this.compatibilityRuntimeRegistry] : [];
+        for (const registry of ownedPluginRegistries) {
+            for (const app of registry.getWebApps())
+                await app.dispose?.();
+        }
         if (this.ownsSessionStore) {
             this.sessionStore?.close?.();
         }

package/dist/plugins/context-files.js

@@ -339,6 +339,7 @@ class ContextFileService {
     snapshots = new Map();
     pollTimer;
     pollFailureReported = false;
+    disposed = false;
     constructor(paths, api) {
         this.paths = paths;
         this.api = api;
@@ -589,6 +590,13 @@ class ContextFileService {
         }, POLL_INTERVAL_MS);
         this.pollTimer.unref?.();
     }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.stopWatcher();
+        this.store.close();
+    }
     stopWatcher() {
         if (!this.pollTimer)
             return;
@@ -915,6 +923,9 @@ function createContextFilesWebApp(service) {
         name: CONTEXT_FILES_APP_NAME,
         mountPath: CONTEXT_FILES_MOUNT_PATH,
         apiPrefix: CONTEXT_FILES_API_PREFIX,
+        dispose() {
+            service.dispose();
+        },
         async handleRequest(request, context) {
             const url = new URL(request.url);
             const asset = builtAsset(url.pathname);

package/dist/plugins/registry.js

@@ -265,6 +265,7 @@ export class PiboPluginRegistry {
                 builtinTools: sessionContext.builtinTools,
                 builtinToolNames: [...sessionContext.builtinToolNames],
                 autoContextFiles: sessionContext.autoContextFiles,
+                nativeSubagents: sessionContext.nativeSubagents,
                 runControl: sessionContext.toolPackages.runControl === true,
                 goalControl: sessionContext.toolPackages.goalControl !== false,
             };