@introspection-ai/recipes 0.13.0 → 0.14.1

package/dist/pi-extension.js

@@ -1,16 +1,20 @@
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
 import { basename, resolve } from "node:path";
 import { Text } from "@earendil-works/pi-tui";
 import { createRecipeChildAgentRunner, promptResultText, } from "./child-agent.js";
 import { loadRecipeExtensionFactory } from "./recipe-extensions.js";
+import { bindRecipeExtensionFactory, createRecipeExtensionRegistrationRegistry, } from "./extensions.js";
 import { ChildAgentRunStore, } from "./child-agent-store.js";
 import { ChildCompletionQueue, envelopeFromRun, renderCompletionNotice, } from "./child-agent-completions.js";
-import { clearMcpSession, configureMcpLocalConfigPath, formatMcpConfigurationDiagnostics, materializeMcpSession, materializeSessionMcpCli, resolveAgentMcpSelections, stopMcpDaemon, } from "./mcp.js";
+import { clearMcpSession, clearSessionMcpCli, configureMcpLocalConfigPath, createIsolatedMcpEnvironment, formatMcpConfigurationDiagnostics, materializeMcpSession, materializeSessionMcpCli, resolveAgentMcpSelections, stopMcpDaemon, } from "./mcp.js";
 import { clearMcpCatalogPreload, preloadMcpCatalogs, } from "./mcp-catalog.js";
-import { applyRecipeAgentModelConfigToModel } from "./recipe-model.js";
+import { createMcpToolSet } from "./mcp-tools.js";
+import { applyRecipeAgentModelConfigToModel, cloneModelForRecipe, } from "./recipe-model.js";
+import { checkRecipeAtLoad, formatRecipeDiagnostics, } from "./recipe-check.js";
 import { resolveRecipe, } from "./recipe/resolve.js";
-import { createAgentTool, } from "./agent-tool.js";
+import { createAgentTool, } from "./agents.js";
 /** Mid-turn completion delivery retries on this cadence until the session idles. */
 const COMPLETION_DELIVERY_RETRY_MS = 100;
 const require = createRequire(import.meta.url);
@@ -53,8 +57,8 @@ function visibleSubagents(state) {
 function mcpSelectionsForAgent(agent) {
     return resolveAgentMcpSelections(agent.mcp);
 }
-function scopedMcpSelections(state) {
-    return [state.resolved.agent, ...visibleSubagents(state)].flatMap(mcpSelectionsForAgent);
+function resolvedMcpMode(state) {
+    return state.resolved.mcp?.mode ?? "cli";
 }
 function textResult(text, details) {
     return {
@@ -102,7 +106,7 @@ function formatAgentCall(args, theme) {
     const label = args.label ? ` ${themeFg(theme, "muted", `(${args.label})`)}` : "";
     return `${themeFg(theme, "toolTitle", themeBold(theme, `agent ${action}`))} ${themeFg(theme, "accent", agent)}${label}`;
 }
-// Keep the legacy wire value so resumed transcripts retain their renderer.
+// Stable wire value used by persisted transcripts and the renderer.
 const AGENT_COMPLETIONS_TYPE = "recipe-agent-completions";
 function formatDurationMs(ms) {
     const seconds = Math.round(ms / 1000);
@@ -196,7 +200,10 @@ function bulletList(items) {
 }
 function activeRecipeTools(state, activeTools) {
     const active = new Set(activeTools);
-    const recipeTools = new Set(state.resolved.tools);
+    const recipeTools = new Set([
+        ...state.resolved.tools,
+        ...(state.resolved.subagents.size > 0 ? ["agent"] : []),
+    ]);
     return [...recipeTools]
         .filter((tool) => active.has(tool))
         .sort();
@@ -207,14 +214,18 @@ function recipeSummary(state, activeTools) {
         "Active Recipe",
         `Name: ${state.resolved.manifest.name}@${state.resolved.manifest.version}`,
         state.resolved.manifest.description ? `Description: ${state.resolved.manifest.description}` : undefined,
-        `Agent: ${state.resolved.agentName}`,
-        `Model: ${state.resolved.agent.model?.name ?? "(session default)"}`,
-        `Thinking level: ${state.resolved.agent.model?.thinkingLevel ?? "(session default)"}`,
+        `Agent: ${state.resolved.name}`,
+        `Model: ${state.resolved.definition.model?.name ?? "(session default)"}`,
+        `Thinking level: ${state.resolved.definition.model?.thinkingLevel ?? "(session default)"}`,
         `Subagents: ${nameList(subagents)}`,
         "",
         "Active recipe tools:",
         ...bulletList(activeRecipeTools(state, activeTools)),
         "",
+        `Package extensions: ${state.resolved.extensionPaths.length}`,
+        `Package prompts: ${state.resolved.promptPaths.length}`,
+        "Host layer: trusted ambient Pi hooks and settings may also apply",
+        "",
         `Directory: ${state.resolved.recipeDir}`,
         `Workspace: ${state.cwd}`,
     ].filter((line) => line !== undefined).join("\n");
@@ -414,10 +425,32 @@ export function createRecipesExtension(opts = {}) {
             childRuns.delete(id);
             return controllerSummary(run, "closed");
         },
+        async shutdown() {
+            await closeAllChildRuns();
+        },
     };
     async function closeAllChildRuns() {
         await Promise.all([...childRuns.keys()].map((id) => localRunController.close(id)));
     }
+    async function closeRootMcpRuntime() {
+        const privateEnv = state?.mcpPrivateEnv;
+        const privateDirectory = state?.mcpPrivateDirectory;
+        if (privateEnv) {
+            clearMcpCatalogPreload(privateEnv);
+            await stopMcpDaemon(privateEnv);
+        }
+        if (privateDirectory) {
+            await rm(privateDirectory, { recursive: true, force: true });
+        }
+        if (state) {
+            state.mcpPrivateEnv = undefined;
+            state.mcpPrivateDirectory = undefined;
+            if (state.mcpAmbientMcporterConfig) {
+                env.MCPORTER_CONFIG = state.mcpAmbientMcporterConfig;
+                state.mcpAmbientMcporterConfig = undefined;
+            }
+        }
+    }
     function archivedControlError(id) {
         return {
             ...textResult(`Agent run ${id} belongs to a previous Pi session and cannot be controlled; only status and wait are available.`, { id }),
@@ -429,6 +462,8 @@ export function createRecipesExtension(opts = {}) {
     // later session load in the same process.
     const launchRecipeDir = stringFlag(env.PI_RECIPE_DIR);
     const launchAgentName = stringFlag(env.PI_AGENT_NAME);
+    const originalRecipeDirEnv = env.PI_RECIPE_DIR;
+    const originalAgentNameEnv = env.PI_AGENT_NAME;
     function recipeFlag(pi) {
         return stringFlag(pi.getFlag("recipe")) ?? launchRecipeDir;
     }
@@ -447,12 +482,11 @@ export function createRecipesExtension(opts = {}) {
         const key = [cwd, recipeDir, requestedAgentName ?? ""].join("\0");
         if (state?.key === key)
             return state;
+        let resolvedRecipe;
         let resolved;
         try {
-            resolved = resolveRecipe({
-                recipeDir,
-                agentName: requestedAgentName,
-            });
+            resolvedRecipe = resolveRecipe({ recipeDir });
+            resolved = resolvedRecipe.selectAgent(requestedAgentName);
         }
         catch (err) {
             throw new RecipeLaunchError(recipeLoadErrorMessage(flag, err instanceof Error ? err.message : String(err)));
@@ -461,13 +495,22 @@ export function createRecipesExtension(opts = {}) {
         // recipe-authored instructions. In production `env` is process.env, so
         // built-in shell tools and child agents inherit these resolved values.
         env.PI_RECIPE_DIR = recipeDir;
-        env.PI_AGENT_NAME = resolved.agentName;
+        env.PI_AGENT_NAME = resolved.name;
         state = {
             key,
             cwd,
+            resolvedRecipe,
             resolved,
+            extensionRegistrations: createRecipeExtensionRegistrationRegistry(),
             extensionsLoaded: false,
             configured: false,
+            mcpConfigured: false,
+            agentMcpMode: "cli",
+            initialMcpToolNames: [],
+            extensionAllowedToolNames: new Set([
+                ...resolved.tools,
+                ...(resolved.subagents.size > 0 ? ["agent"] : []),
+            ]),
         };
         return state;
     }
@@ -479,29 +522,57 @@ export function createRecipesExtension(opts = {}) {
             if (!(err instanceof RecipeLaunchError))
                 throw err;
             const key = [cwd, recipeFlag(pi) ?? "", err.message].join("\0");
-            if (ctx && lastLaunchErrorKey !== key) {
-                ctx.ui.notify(err.message, "warning");
+            if (lastLaunchErrorKey !== key) {
+                failRecipeSession(pi, err.message, ctx);
                 lastLaunchErrorKey = key;
             }
+            else {
+                sessionConfigurationError = err.message;
+                pi.setActiveTools([]);
+            }
             return null;
         }
     }
+    function failRecipeSession(pi, message, ctx) {
+        sessionConfigurationError = message;
+        pi.setActiveTools([]);
+        ctx?.ui.notify(`Recipe session cannot start: ${message}`, "warning");
+        if (ctx?.mode === "json" || ctx?.mode === "print") {
+            process.exitCode = 1;
+        }
+    }
     async function loadRecipeExtensions(pi, ctx, launchState) {
+        if (launchState.extensionFailure) {
+            throw new Error(launchState.extensionFailure);
+        }
         if (launchState.extensionsLoaded)
             return;
+        // Pi cannot unload registrations made by an earlier factory if a later
+        // factory fails. Mark the closure attempted before execution so the same
+        // live runner never retries a partially installed closure.
+        launchState.extensionsLoaded = true;
+        for (const tool of pi.getAllTools()) {
+            launchState.extensionRegistrations.claim("tool", tool.name, "<host>");
+        }
         let loadedCount = 0;
-        for (const extensionPath of launchState.resolved.extensionPaths) {
-            try {
-                const factory = await loadRecipeExtensionFactory(launchState.resolved.recipeDir, extensionPath);
+        try {
+            for (const extensionPath of launchState.resolved.extensionPaths) {
+                const factory = bindRecipeExtensionFactory(await loadRecipeExtensionFactory(launchState.resolved.recipeDir, extensionPath), Object.freeze({
+                    recipe: Object.freeze({ name: launchState.resolved.manifest.name }),
+                    agent: Object.freeze({ name: launchState.resolved.name }),
+                    session: Object.freeze({
+                        role: "root",
+                    }),
+                }), launchState.extensionRegistrations, extensionPath, launchState.extensionAllowedToolNames);
                 await factory(pi);
                 loadedCount += 1;
             }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                ctx.ui.notify(`Recipe extension failed to load: ${extensionPath}\n${message}`, "warning");
-            }
         }
-        launchState.extensionsLoaded = true;
+        catch (error) {
+            launchState.extensionFailure =
+                error instanceof Error ? error.message : String(error);
+            throw error;
+        }
         if (launchState.resolved.extensionPaths.length > 0) {
             ctx.ui.notify(`Recipe extensions: ${loadedCount}/${launchState.resolved.extensionPaths.length} loaded`, "info");
         }
@@ -511,15 +582,16 @@ export function createRecipesExtension(opts = {}) {
             return;
         const labelParts = [
             `${launchState.resolved.manifest.name}@${launchState.resolved.manifest.version}`,
-            `agent:${launchState.resolved.agentName}`,
+            `agent:${launchState.resolved.name}`,
         ].filter(Boolean);
         pi.setSessionName(labelParts.join(" "));
         const { provider, model } = modelParts(launchState.resolved.modelSpec);
         const lookupProvider = provider === "gemini" ? "google" : provider;
-        const resolvedModel = ctx.modelRegistry.find(lookupProvider, model);
-        if (!resolvedModel) {
+        const registeredModel = ctx.modelRegistry.find(lookupProvider, model);
+        if (!registeredModel) {
             throw new Error(`Recipe model is not available: ${launchState.resolved.modelSpec}`);
         }
+        const resolvedModel = cloneModelForRecipe(registeredModel);
         applyRecipeAgentModelConfigToModel(resolvedModel, launchState.resolved.modelConfig);
         const ok = await pi.setModel(resolvedModel);
         if (!ok) {
@@ -528,54 +600,167 @@ export function createRecipesExtension(opts = {}) {
         if (launchState.resolved.thinkingLevel) {
             pi.setThinkingLevel(launchState.resolved.thinkingLevel);
         }
-        const activeTools = new Set(launchState.resolved.tools);
+        const activeTools = new Set([
+            ...launchState.resolved.tools,
+            ...(launchState.resolved.subagents.size > 0 ? ["agent"] : []),
+            ...launchState.initialMcpToolNames,
+            ...(launchState.mcpSearchToolName
+                ? [launchState.mcpSearchToolName]
+                : []),
+        ]);
+        const registeredTools = new Set(pi.getAllTools().map((tool) => tool.name));
+        const missingTools = [...activeTools].filter((name) => !registeredTools.has(name));
+        if (missingTools.length > 0) {
+            throw new Error(`Recipe agent "${launchState.resolved.name}" declares unavailable tool(s): ${missingTools.join(", ")}`);
+        }
         pi.setActiveTools([...activeTools]);
         launchState.configured = true;
         sessionConfigurationError = null;
     }
-    async function configureMcp(launchState, ctx) {
-        const mcpSelections = scopedMcpSelections(launchState);
-        if (mcpSelections.length === 0) {
-            await clearMcpSession(env, launchState.cwd);
+    async function configureMcp(pi, launchState, ctx) {
+        if (launchState.mcpConfigured)
             return;
-        }
+        launchState.agentMcpMode = resolvedMcpMode(launchState);
+        launchState.initialMcpToolNames = [];
+        launchState.mcpSearchToolName = undefined;
         configureMcpLocalConfigPath({
             cwd: launchState.cwd,
             recipeDir: launchState.resolved.recipeDir,
             env,
         });
-        const [, session] = await Promise.all([
-            materializeSessionMcpCli({
-                cwd: launchState.cwd,
-                env,
-            }),
-            materializeMcpSession({
-                cwd: launchState.cwd,
-                manifest: launchState.resolved.manifest,
-                agentMcp: mcpSelections,
-                env,
-            }),
-        ]);
-        if (session.servers.length > 0) {
-            void preloadMcpCatalogs({ env }).catch((error) => {
-                console.warn(`Recipe MCP catalog preload failed: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            ctx.ui.notify(`Recipe MCP: ${session.servers.length} server(s) configured; runtime warming in background`, "info");
+        if (launchState.agentMcpMode === "cli") {
+            const mcpSelections = resolveAgentMcpSelections(launchState.resolved.mcp);
+            if (mcpSelections.length === 0) {
+                await clearMcpSession(env, launchState.cwd);
+                launchState.mcpConfigured = true;
+                return;
+            }
+            const [, session] = await Promise.all([
+                materializeSessionMcpCli({
+                    cwd: launchState.cwd,
+                    env,
+                }),
+                materializeMcpSession({
+                    cwd: launchState.cwd,
+                    manifest: launchState.resolved.manifest,
+                    agentMcp: mcpSelections,
+                    env,
+                }),
+            ]);
+            if (session.servers.length > 0) {
+                void preloadMcpCatalogs({ env }).catch((error) => {
+                    console.warn(`Recipe MCP catalog preload failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                ctx.ui.notify(`Recipe MCP: ${session.servers.length} server(s) configured; runtime warming in background`, "info");
+            }
+            else {
+                const detail = formatMcpConfigurationDiagnostics(session.diagnostics ?? []);
+                ctx.ui.notify([
+                    "Recipe MCP: no servers are available to this agent. Check package policy and .pi/mcp.local.json.",
+                    ...(detail ? ["", detail] : []),
+                ].join("\n"), "warning");
+            }
             const detail = formatMcpConfigurationDiagnostics(session.diagnostics ?? []);
-            if (detail) {
+            if (session.servers.length > 0 && detail) {
                 ctx.ui.notify([
                     "Recipe MCP: some configured servers or tools were filtered.",
                     "",
                     detail,
                 ].join("\n"), "warning");
             }
+            launchState.mcpConfigured = true;
+            return;
         }
-        else {
-            const detail = formatMcpConfigurationDiagnostics(session.diagnostics ?? []);
-            ctx.ui.notify([
-                "Recipe MCP: no servers are available to this agent. Check package policy and .pi/mcp.local.json.",
-                ...(detail ? ["", detail] : []),
-            ].join("\n"), "warning");
+        const clearedCli = await clearSessionMcpCli(env, launchState.cwd);
+        launchState.mcpAmbientMcporterConfig =
+            clearedCli.previousMcporterConfig;
+        const rootMcp = launchState.resolved.mcp;
+        const rootSelections = mcpSelectionsForAgent(launchState.resolved.definition);
+        if (!rootMcp || rootSelections.length === 0) {
+            launchState.mcpConfigured = true;
+            return;
+        }
+        const privateRuntime = await createIsolatedMcpEnvironment(env);
+        launchState.mcpPrivateEnv = privateRuntime.env;
+        launchState.mcpPrivateDirectory = privateRuntime.directory;
+        try {
+            const session = await materializeMcpSession({
+                cwd: launchState.cwd,
+                manifest: launchState.resolved.manifest,
+                agentMcp: rootSelections,
+                env: privateRuntime.env,
+                mcporterConfigPath: privateRuntime.mcporterConfigPath,
+            });
+            if (session.servers.length === 0) {
+                const detail = formatMcpConfigurationDiagnostics(session.diagnostics ?? []);
+                ctx.ui.notify([
+                    "Recipe MCP tools: no servers are available to the root agent.",
+                    ...(detail ? ["", detail] : []),
+                ].join("\n"), "warning");
+                launchState.mcpConfigured = true;
+                return;
+            }
+            const catalogs = await preloadMcpCatalogs({
+                env: privateRuntime.env,
+                allowPartial: true,
+            });
+            const materialized = createMcpToolSet({
+                session,
+                catalogs,
+                mcp: rootMcp,
+                env: privateRuntime.env,
+                activation: {
+                    getActiveTools: () => pi.getActiveTools(),
+                    setActiveTools: (names) => pi.setActiveTools(names),
+                },
+            });
+            const existing = new Set(pi.getAllTools().map((tool) => tool.name));
+            for (const tool of materialized.tools) {
+                if (existing.has(tool.name)) {
+                    throw new Error(`Cannot register MCP tool '${tool.name}': the Pi tool name is already in use.`);
+                }
+            }
+            for (const tool of materialized.tools)
+                pi.registerTool(tool);
+            const registered = new Set(pi.getAllTools().map((tool) => tool.name));
+            const missing = materialized.tools
+                .map((tool) => tool.name)
+                .filter((name) => !registered.has(name));
+            if (missing.length > 0) {
+                throw new Error(`Pi did not register MCP tool(s): ${missing.join(", ")}`);
+            }
+            launchState.initialMcpToolNames =
+                materialized.initialActiveToolNames;
+            launchState.mcpSearchToolName = materialized.searchToolName;
+            for (const toolName of materialized.toolNames) {
+                launchState.extensionAllowedToolNames.add(toolName);
+            }
+            if (materialized.searchToolName) {
+                launchState.extensionAllowedToolNames.add(materialized.searchToolName);
+            }
+            ctx.ui.notify(`Recipe MCP tools: ${materialized.toolNames.length} registered, ${materialized.initialActiveToolNames.length} initially active${materialized.searchToolName ? "; deferred search enabled" : ""}`, "info");
+            const diagnostics = [
+                ...formatMcpConfigurationDiagnostics(session.diagnostics ?? [])
+                    .split("\n")
+                    .filter(Boolean),
+                ...materialized.diagnostics,
+            ];
+            if (diagnostics.length > 0) {
+                ctx.ui.notify([
+                    "Recipe MCP: some configured tools were unavailable.",
+                    "",
+                    ...diagnostics,
+                ].join("\n"), "warning");
+            }
+            launchState.mcpConfigured = true;
+        }
+        catch (error) {
+            clearMcpCatalogPreload(privateRuntime.env);
+            await stopMcpDaemon(privateRuntime.env);
+            await rm(privateRuntime.directory, { recursive: true, force: true });
+            launchState.mcpPrivateEnv = undefined;
+            launchState.mcpPrivateDirectory = undefined;
+            throw error;
         }
     }
     async function runChildAgent(launchState, agentName, prompt, label, ctx, onUpdate) {
@@ -593,7 +778,7 @@ export function createRecipesExtension(opts = {}) {
             }
         };
         const runner = createChildAgentRunner({
-            recipeDir: launchState.resolved.recipeDir,
+            recipe: launchState.resolvedRecipe,
             workspaceDir: launchState.cwd,
             env,
             agentName,
@@ -763,6 +948,7 @@ export function createRecipesExtension(opts = {}) {
                         return;
                     }
                     await closeAllChildRuns();
+                    await closeRootMcpRuntime();
                     state = null;
                     archivedRuns.clear();
                     completions.clear();
@@ -798,37 +984,65 @@ export function createRecipesExtension(opts = {}) {
         pi.on("session_start", async (_event, ctx) => {
             sessionCtx = ctx;
             localAgentContext = ctx;
+            const selectedRecipe = recipeFlag(pi);
+            if (selectedRecipe) {
+                const recipeDir = resolve(ctx.cwd, selectedRecipe);
+                if (existsSync(recipeDir)) {
+                    try {
+                        const report = await checkRecipeAtLoad(recipeDir, env);
+                        if (!report.valid) {
+                            const message = formatRecipeDiagnostics(report.diagnostics);
+                            failRecipeSession(pi, `validation failed\n${message}`, ctx);
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        failRecipeSession(pi, `validation failed\n${message}`, ctx);
+                        return;
+                    }
+                }
+            }
             const launchState = safeLoadState(pi, ctx.cwd, ctx);
             if (!launchState)
                 return;
+            launchState.configured = false;
             visibleAgentDefinitions.clear();
             for (const [name, definition] of launchState.resolved.subagents) {
                 visibleAgentDefinitions.set(name, definition);
             }
-            await loadRecipeExtensions(pi, ctx, launchState);
             try {
-                await configureMcp(launchState, ctx);
+                await loadRecipeExtensions(pi, ctx, launchState);
             }
             catch (err) {
-                ctx.ui.notify(`Recipe MCP failed to configure: ${err instanceof Error ? err.message : String(err)}`, "warning");
+                const message = err instanceof Error ? err.message : String(err);
+                failRecipeSession(pi, `extension startup failed\n${message}`, ctx);
                 return;
             }
             try {
-                await configureSession(pi, ctx, launchState);
+                await configureMcp(pi, launchState, ctx);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                // A recipe's declared model is part of its behavior contract. Continuing
-                // with Pi's previously active model can produce plausible but invalid
-                // results, so stop the session instead of silently falling back.
                 sessionConfigurationError = message;
                 pi.setActiveTools([]);
-                ctx.ui.notify(`Recipe session cannot start: ${message}`, "warning");
+                ctx.ui.notify(`Recipe MCP failed to configure: ${message}`, "warning");
                 if (ctx.mode === "json" || ctx.mode === "print") {
                     process.exitCode = 1;
                 }
                 return;
             }
+            try {
+                await configureSession(pi, ctx, launchState);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                // A recipe's declared model is part of its behavior contract. Continuing
+                // with Pi's previously active model can produce plausible but invalid
+                // results, so stop the session instead of silently falling back.
+                failRecipeSession(pi, message, ctx);
+                return;
+            }
             // Restore run snapshots persisted by a previous Pi process so run ids
             // referenced in a resumed conversation stay resolvable (read-only).
             try {
@@ -844,8 +1058,21 @@ export function createRecipesExtension(opts = {}) {
         });
         pi.on("session_shutdown", async () => {
             await closeAllChildRuns();
+            await closeRootMcpRuntime();
             clearMcpCatalogPreload(env);
             await stopMcpDaemon(env);
+            if (originalRecipeDirEnv === undefined) {
+                delete env.PI_RECIPE_DIR;
+            }
+            else {
+                env.PI_RECIPE_DIR = originalRecipeDirEnv;
+            }
+            if (originalAgentNameEnv === undefined) {
+                delete env.PI_AGENT_NAME;
+            }
+            else {
+                env.PI_AGENT_NAME = originalAgentNameEnv;
+            }
         });
         pi.on("agent_start", (_event, ctx) => {
             if (!sessionConfigurationError)
@@ -860,8 +1087,8 @@ export function createRecipesExtension(opts = {}) {
             if (!launchState)
                 return {};
             return {
-                skillPaths: launchState.resolved.skillPaths,
-                promptPaths: launchState.resolved.promptPaths,
+                skillPaths: [...launchState.resolved.skillPaths],
+                promptPaths: [...launchState.resolved.promptPaths],
             };
         });
         pi.on("before_agent_start", (event, ctx) => {
@@ -874,7 +1101,5 @@ export function createRecipesExtension(opts = {}) {
         });
     };
 }
-/** @deprecated Use `createRecipesExtension`. */
-export const createPiRecipesExtension = createRecipesExtension;
 export default createRecipesExtension();
 //# sourceMappingURL=pi-extension.js.map