@llblab/pi-actors 0.44.0 → 0.45.1

package/AGENTS.md

@@ -44,6 +44,7 @@ Pi host
 
 ## Key Domains
 
+- `extension-runtime.ts`: low-level Pi session lifecycle, tool adaptation, and runtime service composition behind the thin `index.ts` event-registration root.
 - `command-templates.ts`: portable synchronous execution graph.
 - `recipes-references.ts`, `recipes-discovery.ts`, `recipe-control.ts`: Recipe resolution, imports, shadowing, and Control declarations.
 - `async-runs.ts`: lifecycle facade.
@@ -135,6 +136,7 @@ When a deferred Run result gates the next step, wait for its terminal follow-up.
 ## Documentation and Release Discipline
 
 - Keep published text portable: use `~`, `<repo>`, or relative paths.
+- Keep executable JavaScript and TypeScript blocks compact: no blank lines inside function bodies or control-flow blocks. Structural object, type, interface, class, and module bodies are exempt.
 - Update `skills/actors/SKILL.md` when durable operating mechanics change.
 - Keep `skills/swarm/SKILL.md` focused on multi-agent methodology rather than kernel internals.
 - Recipe `description` is optional because discovery supplies stable fallback tool copy; packaged Recipe QA must report zero diagnostics and zero release-blocking warnings without component boilerplate.

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.45.1: Entrypoint and Release Policy
+
+- `Architecture`: Keeps `index.ts` as a thin Pi event-registration and composition root while moving session lifecycle, runtime service composition, Skill discovery, and tool adaptation into the acyclic `extension-runtime.ts` domain.
+- `Release Policy`: Raises the fixed shipped-source ceiling to 32,000 lines and rejects blank lines inside executable JavaScript/TypeScript blocks across the complete source and test tree while exempting structural declarations.
+- `Package Metadata`: Moves the package image to the new raw-content endpoint to restore cross-origin loading.
+
+## 0.45.0: Skill Recipe Standard Library
+
+- `Recipe Values`: Makes inline argument defaults optional, applies caller > values > defaults > inline precedence across tools, Runs, imports, and delegation, and validates final typed/enum values plus duplicate, unknown-default, and conflicting-type declarations.
+- `Recipe Origins`: Gives file-backed Recipes immutable `{recipe_dir}` and active-Skill Recipes `{skill_dir}` across templates, defaults, artifacts, tools, and Runs while retaining local provenance and hiding machine-local origins from model-facing launch values.
+- `Skill Recipe Library`: Adds exact `std:<name>` and Pi-active `skill:<skill>/<path>` component lookup for imports, delegation, spawn, validation, Inspect diagnostics, captured qualified identity, and installed dist without automatically registering Skill Recipes as tools.
+- `Validation`: Covers source, composed async execution, installed dist, namespace collisions/reload, path redaction, and migrated Skill wrappers while resetting the shipped-line ceiling to the validated 29,767-line release tree.
+
 ## 0.44.0: Bounded Run Evidence
 
 - `Trace`: Bounds each Run to 2,048 events and 4 MiB, atomically retaining the newest suffix with one cumulative `runtime.trace_compacted` marker so discarded history is explicit while terminal, result, execution, and artifact evidence remains authoritative.

package/README.md

@@ -1,5 +1,7 @@
 # pi-actors
 
+![pi-actors banner](https://raw.githubusercontent.com/llblab/pi-actors/main/banner.jpg)
+
 Local Run kernel and persistent tool registry for [Pi](https://github.com/badlogic/pi-mono).
 
 ```text
@@ -84,7 +86,7 @@ Persist a trusted command template or Recipe-backed capability under `~/.pi/agen
 
 Recipes can declare:
 
-- args and typed defaults;
+- named typed args, inline fallbacks, configuration `defaults`, and composition `values`;
 - imports and command-template composition;
 - retry, failure, recovery, repeat, concurrency, and timeout policy;
 - artifact paths;
@@ -103,6 +105,8 @@ Example controlled Recipe:
 
 Ordinary one-shot Recipes should omit `control`. Recipe imports compose definitions inside one Run; they do not create peer actors.
 
+File-backed Recipes receive immutable `{recipe_dir}`; Recipes under a Pi-active Skill also receive `{skill_dir}`. Use `std:<recipe>` for an exact packaged component and `skill:<skill>/<recipe-path>` for an exact active-Skill component. Skill Recipes are namespaced reusable components and do not become tools automatically.
+
 String command-template leaves execute directly without shell interpretation. Use template arrays for sequencing or an explicit trusted shell/script when shell semantics matter.
 
 ## Trace

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 /**
  * pi-actors — actor runtime and persistent local tool registry for pi.
  * Zones: composition root, pi agent, actor runtime
- *
- * Wraps command templates as callable pi tools, stores durable user tools as recipe files, and exposes actor orchestration across reloads and sessions.
+ * Owns extension composition and Pi event registration, not domain behavior.
  */
 import * as Pi from "./lib/pi.ts";
 export default function toolRegistryExtension(pi: Pi.ExtensionAPI): void;

package/dist/index.js

@@ -1,113 +1,17 @@
 /**
  * pi-actors — actor runtime and persistent local tool registry for pi.
  * Zones: composition root, pi agent, actor runtime
- *
- * Wraps command templates as callable pi tools, stores durable user tools as recipe files, and exposes actor orchestration across reloads and sessions.
+ * Owns extension composition and Pi event registration, not domain behavior.
  */
-import * as AutomaticReviewRuntime from "./lib/automatic-review-runtime.js";
-import * as CommandTemplates from "./lib/command-templates.js";
+import * as ExtensionRuntime from "./lib/extension-runtime.js";
 import * as InspectorCommand from "./lib/inspector-command.js";
-import * as Paths from "./lib/paths.js";
-import * as Pi from "./lib/pi.js";
-import * as Prompts from "./lib/prompts.js";
-import * as RunUiRuntime from "./lib/run-ui-runtime.js";
-import * as Runtime from "./lib/runtime.js";
-import * as Temp from "./lib/temp.js";
-import * as Tools from "./lib/tools.js";
-import * as ToolsResponse from "./lib/tools-response.js";
 export default function toolRegistryExtension(pi) {
-    let activeRunContext;
-    const getRunOwnerId = Pi.getSessionId;
-    const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
-        getActiveContext: () => activeRunContext,
-        getRunOwnerId,
-        getThinkingLevel: () => pi.getThinkingLevel(),
-    });
-    const runUiRuntime = RunUiRuntime.createRunUiRuntime({
-        getActiveContext: () => activeRunContext,
-        getRunOwnerId,
-        onRunEvent: automaticReview.schedule,
-        pi,
-    });
-    const actorToolDefinitions = new Map();
-    const withCurrentThinkingContext = (definition) => {
-        if (typeof definition.execute !== "function")
-            return definition;
-        const execute = definition.execute;
-        return {
-            ...definition,
-            execute: async (...args) => {
-                const nextArgs = [...args];
-                const ctx = nextArgs[4];
-                if (ctx && typeof ctx === "object") {
-                    nextArgs[4] = {
-                        ...ctx,
-                        getThinkingLevel: () => pi.getThinkingLevel(),
-                    };
-                }
-                try {
-                    return ToolsResponse.spaceToolResult(await execute(...nextArgs));
-                }
-                catch (error) {
-                    throw ToolsResponse.spaceToolError(error);
-                }
-            },
-        };
-    };
-    const runtime = Runtime.createAutoToolsRuntime({
-        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
-        exec: CommandTemplates.execCommandTemplate,
-        getActiveTools: () => pi.getActiveTools(),
-        registerTool: (definition) => {
-            const wrapped = withCurrentThinkingContext(definition);
-            actorToolDefinitions.set(wrapped.name, wrapped);
-            pi.registerTool(wrapped);
-        },
-        reservedToolNames: Tools.RESERVED_TOOL_NAMES,
-        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    });
-    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime);
-    pi.on("resources_discover", async () => {
-        const skillPaths = Paths.getExistingExtensionSkillPaths(import.meta.url);
-        if (skillPaths.length === 0)
-            return;
-        return { skillPaths };
-    });
-    pi.on("session_start", async (_event, ctx) => {
-        // Clear the pre-overlay widget after hot reloads from older pi-actors builds.
-        ctx.ui.setWidget("zz-pi-actors-comms", undefined);
-        activeRunContext = ctx;
-        runUiRuntime.close();
-        automaticReview.close();
-        recipeReload.close();
-        await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
-        if (activeRunContext !== ctx)
-            return;
-        automaticReview.start(ctx);
-        runtime.loadTools(ctx);
-        runUiRuntime.start(ctx);
-        recipeReload.watch(ctx);
-    });
-    pi.on("agent_end", async (_event, ctx) => {
-        if (activeRunContext === ctx)
-            automaticReview.schedule();
-    });
-    pi.on("session_shutdown", async (event, ctx) => {
-        activeRunContext = undefined;
-        automaticReview.close();
-        recipeReload.close();
-        runUiRuntime.shutdown(event.reason, ctx);
-    });
-    InspectorCommand.registerActorInspectorCommand(pi, getRunOwnerId);
-    pi.on("before_agent_start", async (event) => ({
-        systemPrompt: `${event.systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
-    }));
-    Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
-        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
-        getActiveTools: () => pi.getActiveTools(),
-        getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
-        handleRuntimeControl: automaticReview.handleControl,
-        registryRuntime: runtime,
-        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    }).map(withCurrentThinkingContext));
+    const runtime = ExtensionRuntime.createActorExtensionRuntime(pi);
+    pi.on("resources_discover", async () => runtime.discoverResources(import.meta.url));
+    pi.on("session_start", async (_event, ctx) => runtime.onSessionStart(ctx));
+    pi.on("agent_end", async (_event, ctx) => runtime.onAgentEnd(ctx));
+    pi.on("session_shutdown", async (event, ctx) => runtime.onSessionShutdown(event.reason, ctx));
+    pi.on("before_agent_start", async (event) => runtime.beforeAgentStart(event.systemPrompt, event.systemPromptOptions.skills ?? []));
+    InspectorCommand.registerActorInspectorCommand(pi, runtime.getRunOwnerId);
+    runtime.registerCoreTools();
 }

package/dist/lib/async-runs.d.ts

@@ -38,6 +38,8 @@ export interface AsyncRunStartParams {
     template?: CommandTemplateValue;
     args?: string[];
     defaults?: Record<string, unknown>;
+    recipe_dir?: string;
+    skill_dir?: string;
     parallel?: boolean;
     concurrency?: number | string;
     min_successful?: number | string;

package/dist/lib/async-runs.js

@@ -12,6 +12,7 @@ import { CURRENT_MODEL_VALUE_KEY, CURRENT_THINKING_VALUE_KEY, describeCurrentPol
 import * as Paths from "./paths.js";
 import * as RecipesReferences from "./recipes-references.js";
 import * as RecipesUsage from "./recipes-usage.js";
+import * as Schema from "./schema.js";
 import { resolveArtifactPaths, } from "./runs-artifacts.js";
 import { safeRunId } from "./runs-identity.js";
 import { buildTerminalProgress, markTerminalHandled, signalOwnedRunProcess, } from "./runs-control.js";
@@ -151,7 +152,14 @@ function resolveStartParams(params) {
             fileParams.run_id ||
             fileParams.name ||
             getRunIdFromFile(fileParams.file),
-        values: { ...(fileParams.values ?? {}), ...(params.values ?? {}) },
+        values: {
+            ...(fileParams.values ?? {}),
+            ...(params.values ?? {}),
+            ...(fileParams.recipe_dir
+                ? { recipe_dir: fileParams.recipe_dir }
+                : {}),
+            ...(fileParams.skill_dir ? { skill_dir: fileParams.skill_dir } : {}),
+        },
     };
 }
 function readJson(path) {
@@ -249,13 +257,34 @@ export function startRun(params, cwd) {
         !isAbsolute(recipeRelation)
         ? dirname(packagedRecipeRoot)
         : undefined;
-    const values = {
+    const argSpec = Schema.parseToolArgDeclarationList(startParams.args ?? []);
+    if (argSpec.error)
+        throw new Error(argSpec.error);
+    const declaredArgs = new Set(argSpec.args);
+    for (const key of Object.keys(startParams.defaults ?? {})) {
+        if (declaredArgs.size > 0 && !declaredArgs.has(key))
+            throw new Error(`Unknown Recipe default argument: ${key}`);
+    }
+    const values = Schema.normalizeRuntimeValues({
+        ...argSpec.defaults,
+        ...(startParams.defaults || {}),
         ...(packagedRepo ? { repo: packagedRepo } : {}),
         ...(startParams.values || {}),
         run_id: run,
         state_dir: stateDir,
         trace_file: join(stateDir, "trace.jsonl"),
-    };
+    }, argSpec.argTypes);
+    const runtimeTemplate = resolved.template &&
+        typeof resolved.template === "object" &&
+        !Array.isArray(resolved.template)
+        ? {
+            ...resolved.template,
+            defaults: {
+                ...(resolved.template.defaults ?? {}),
+                ...values,
+            },
+        }
+        : resolved.template;
     const modelPolicy = describeCurrentPolicyProvenance({
         defaults: startParams.defaults,
         template: resolved.template,
@@ -312,7 +341,7 @@ export function startRun(params, cwd) {
             state_schema: RuntimeIdentity.RUN_STATE_SCHEMA,
             status: "running",
             ...(startParams.tool ? { tool: startParams.tool } : {}),
-            template: resolved.template,
+            template: runtimeTemplate,
             values,
             model_policy: modelPolicy,
             ...(artifacts ? { artifacts } : {}),

package/dist/lib/config.js

@@ -149,6 +149,7 @@ export function normalizeStoredTool(key, value, reservedToolNames) {
             template: argTemplate,
         };
     const inferredArgTypes = Schema.getTemplateArgTypes(argTemplateConfig);
+    Schema.assertCompatibleToolArgTypes(inferredArgTypes, declarations.argTypes);
     const argTypes = { ...inferredArgTypes, ...declarations.argTypes };
     const cfg = {
         name,

package/dist/lib/extension-runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as Pi from "./pi.ts";
+import * as RecipesReferences from "./recipes-references.ts";
+export interface ActorExtensionRuntime {
+    beforeAgentStart(systemPrompt: string, skills: RecipesReferences.ActiveSkillRecipeSource[]): {
+        systemPrompt: string;
+    };
+    discoverResources(metaUrl: string): {
+        skillPaths: string[];
+    } | undefined;
+    getRunOwnerId(ctx: Pi.ExtensionContext): string;
+    onAgentEnd(ctx: Pi.ExtensionContext): void;
+    onSessionShutdown(reason: string, ctx: Pi.ExtensionContext): void;
+    onSessionStart(ctx: Pi.ExtensionContext): Promise<void>;
+    registerCoreTools(): void;
+}
+export declare function createActorExtensionRuntime(pi: Pi.ExtensionAPI): ActorExtensionRuntime;

package/dist/lib/extension-runtime.js

@@ -0,0 +1,116 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as AutomaticReviewRuntime from "./automatic-review-runtime.js";
+import * as CommandTemplates from "./command-templates.js";
+import * as Paths from "./paths.js";
+import * as Pi from "./pi.js";
+import * as Prompts from "./prompts.js";
+import * as RecipesReferences from "./recipes-references.js";
+import * as RunUiRuntime from "./run-ui-runtime.js";
+import * as Runtime from "./runtime.js";
+import * as Temp from "./temp.js";
+import * as Tools from "./tools.js";
+import * as ToolsResponse from "./tools-response.js";
+export function createActorExtensionRuntime(pi) {
+    let activeRunContext;
+    const getRunOwnerId = Pi.getSessionId;
+    const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        getThinkingLevel: () => pi.getThinkingLevel(),
+    });
+    const runUiRuntime = RunUiRuntime.createRunUiRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        onRunEvent: automaticReview.schedule,
+        pi,
+    });
+    const actorToolDefinitions = new Map();
+    const withCurrentThinkingContext = (definition) => {
+        if (typeof definition.execute !== "function")
+            return definition;
+        const execute = definition.execute;
+        return {
+            ...definition,
+            execute: async (...args) => {
+                const nextArgs = [...args];
+                const ctx = nextArgs[4];
+                if (ctx && typeof ctx === "object") {
+                    nextArgs[4] = {
+                        ...ctx,
+                        getThinkingLevel: () => pi.getThinkingLevel(),
+                    };
+                }
+                try {
+                    return ToolsResponse.spaceToolResult(await execute(...nextArgs));
+                }
+                catch (error) {
+                    throw ToolsResponse.spaceToolError(error);
+                }
+            },
+        };
+    };
+    const runtime = Runtime.createAutoToolsRuntime({
+        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+        exec: CommandTemplates.execCommandTemplate,
+        getActiveTools: () => pi.getActiveTools(),
+        registerTool: (definition) => {
+            const wrapped = withCurrentThinkingContext(definition);
+            actorToolDefinitions.set(wrapped.name, wrapped);
+            pi.registerTool(wrapped);
+        },
+        reservedToolNames: Tools.RESERVED_TOOL_NAMES,
+        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+    });
+    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime);
+    return {
+        beforeAgentStart(systemPrompt, skills) {
+            RecipesReferences.setActiveSkillRecipeSources(skills);
+            return {
+                systemPrompt: `${systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
+            };
+        },
+        discoverResources(metaUrl) {
+            const skillPaths = Paths.getExistingExtensionSkillPaths(metaUrl);
+            return skillPaths.length > 0 ? { skillPaths } : undefined;
+        },
+        getRunOwnerId,
+        onAgentEnd(ctx) {
+            if (activeRunContext === ctx)
+                automaticReview.schedule();
+        },
+        onSessionShutdown(reason, ctx) {
+            activeRunContext = undefined;
+            automaticReview.close();
+            recipeReload.close();
+            runUiRuntime.shutdown(reason, ctx);
+        },
+        async onSessionStart(ctx) {
+            ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+            activeRunContext = ctx;
+            runUiRuntime.close();
+            automaticReview.close();
+            recipeReload.close();
+            await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
+            if (activeRunContext !== ctx)
+                return;
+            automaticReview.start(ctx);
+            runtime.loadTools(ctx);
+            runUiRuntime.start(ctx);
+            recipeReload.watch(ctx);
+        },
+        registerCoreTools() {
+            Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
+                configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+                getActiveTools: () => pi.getActiveTools(),
+                getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
+                handleRuntimeControl: automaticReview.handleControl,
+                registryRuntime: runtime,
+                setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+            }).map(withCurrentThinkingContext));
+        },
+    };
+}

package/dist/lib/inspector.js

@@ -56,7 +56,12 @@ export function readActorInspectorRecipe(stateDir) {
         !Array.isArray(primary.recipe)
         ? primary.recipe
         : undefined;
-    const redactedRecord = (value) => SessionEvidence.redactSessionEvidenceValue(Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)));
+    const redactedRecord = (value) => SessionEvidence.redactSessionEvidenceValue(Object.fromEntries(Object.entries(value).filter(([key, entry]) => entry !== undefined &&
+        key !== "recipe_dir" &&
+        key !== "skill_dir")));
+    const launchValues = meta.values && typeof meta.values === "object" && !Array.isArray(meta.values)
+        ? Object.fromEntries(Object.entries(meta.values).filter(([key]) => key !== "recipe_dir" && key !== "skill_dir"))
+        : meta.values;
     return {
         composition: contexts.map((entry) => redactedRecord({
             ...(typeof entry.alias === "string" ? { alias: entry.alias } : {}),
@@ -64,6 +69,7 @@ export function readActorInspectorRecipe(stateDir) {
             file: entry.file,
             import_path: entry.import_path,
             name: entry.name,
+            qualified_name: entry.qualified_name,
         })),
         ...(definition ? { definition: redactedRecord(definition) } : {}),
         diagnostics: result.diagnostics.map((diagnostic) => diagnostic.message),
@@ -76,7 +82,7 @@ export function readActorInspectorRecipe(stateDir) {
         launch: redactedRecord({
             cwd: meta.cwd,
             template: meta.template,
-            values: meta.values,
+            values: launchValues,
             model_policy: meta.model_policy,
             control: meta.control,
             artifacts: meta.artifacts,

package/dist/lib/recipes-discovery.js

@@ -53,17 +53,33 @@ function getRecipeCommandTemplateConfig(config) {
         ? config.template
         : config);
 }
+function getRecipeDiagnosticTemplateConfig(config) {
+    const templateConfig = getRecipeCommandTemplateConfig(config);
+    return typeof templateConfig === "object" && !Array.isArray(templateConfig)
+        ? {
+            ...templateConfig,
+            defaults: {
+                ...(templateConfig.defaults ?? {}),
+                ...(config.defaults ?? {}),
+                ...(config.values ?? {}),
+            },
+        }
+        : {
+            defaults: { ...(config.defaults ?? {}), ...(config.values ?? {}) },
+            template: templateConfig,
+        };
+}
 function getRecipeConfigDiagnostics(file, config) {
     if (!config) {
         const reason = RecipesReferences.diagnoseRawRecipeConfigFailure(file);
         return [`Invalid recipe: ${file}${reason ? `: ${reason}` : ""}`];
     }
-    return CommandTemplates.getCommandTemplateWarnings(getRecipeCommandTemplateConfig(config)).map((warning) => `Recipe ${file}: ${warning}`);
+    return CommandTemplates.getCommandTemplateWarnings(getRecipeDiagnosticTemplateConfig(config)).map((warning) => `Recipe ${file}: ${warning}`);
 }
 function getRecipeRiskLabels(config) {
     if (!config)
         return [];
-    const labels = new Set(CommandTemplates.getCommandTemplateRiskLabels(getRecipeCommandTemplateConfig(config)));
+    const labels = new Set(CommandTemplates.getCommandTemplateRiskLabels(getRecipeDiagnosticTemplateConfig(config)));
     if (config.async === true)
         labels.add("risk.long_running");
     return [
@@ -652,8 +668,9 @@ export function toRegisteredTool(entry) {
         const parsed = Schema.parseToolArgToken(String(arg));
         return [parsed.arg, parsed.type];
     }));
-    assertToolSafeRepeatConfig(argTemplateConfig, explicitArgTypes, cfg.defaults ?? {});
+    assertToolSafeRepeatConfig(argTemplateConfig, explicitArgTypes, { ...(cfg.defaults ?? {}), ...(cfg.values ?? {}) });
     const argTypes = Schema.getTemplateArgTypes(argTemplateConfig);
+    Schema.assertCompatibleToolArgTypes(explicitArgTypes, argTypes);
     return {
         name: entry.id,
         description,

package/dist/lib/recipes-references.d.ts

@@ -40,6 +40,8 @@ export interface TemplateRecipeDefinition {
 }
 export interface TemplateRecipeConfig extends TemplateRecipeDefinition {
     async?: boolean;
+    recipe_dir?: string;
+    skill_dir?: string;
 }
 export interface TemplateRecipeContextRecord {
     alias?: string;
@@ -47,12 +49,20 @@ export interface TemplateRecipeContextRecord {
     file: string;
     import_path: string[];
     name: string;
+    qualified_name?: string;
     recipe: Record<string, unknown>;
     role: "entry" | "import";
 }
 export interface ReadResolvedRecipeConfigOptions {
     includeActorRecipeContext?: boolean;
 }
+export interface ActiveSkillRecipeSource {
+    name: string;
+    filePath?: string;
+    baseDir?: string;
+}
+export declare function setActiveSkillRecipeSources(skills: ActiveSkillRecipeSource[]): void;
+export declare function getActiveSkillRecipeNamespaces(): Record<string, string[]>;
 export declare function resolveRecipePath(value: string, recipeRoot?: string): string;
 export declare function resolveRecipeReferencePath(value: unknown, currentRecipeRoot?: string): string | undefined;
 export declare function getRecipePath(value: unknown, recipeRoot?: string): string | undefined;