@llblab/pi-actors 0.46.0 → 0.46.1

package/dist/lib/extension-runtime.js

@@ -8,6 +8,7 @@ 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 RecipeResolution from "./recipes-context.js";
 import * as RecipesReferences from "./recipes-references.js";
 import * as RunUiRuntime from "./run-ui-runtime.js";
 import * as Runtime from "./runtime.js";
@@ -16,10 +17,16 @@ import * as Tools from "./tools.js";
 import * as ToolsResponse from "./tools-response.js";
 export function createActorExtensionRuntime(pi) {
     let activeRunContext;
-    const skillContextsBySession = new Map();
+    const recipeResolutionContextsBySession = new Map();
     const getRunOwnerId = Pi.getSessionId;
-    const getSkillContext = (ctx) => skillContextsBySession.get(getRunOwnerId(ctx)) ??
-        RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT;
+    const getRecipeResolutionContext = (ctx) => {
+        const sessionId = getRunOwnerId(ctx);
+        const resolutionContext = recipeResolutionContextsBySession.get(sessionId);
+        if (!resolutionContext) {
+            throw new Error(`Recipe resolution context is unavailable for session ${sessionId}.`);
+        }
+        return resolutionContext;
+    };
     const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
         getActiveContext: () => activeRunContext,
         getRunOwnerId,
@@ -44,7 +51,7 @@ export function createActorExtensionRuntime(pi) {
                 if (ctx && typeof ctx === "object") {
                     nextArgs[4] = {
                         ...ctx,
-                        activeSkillRecipeContext: getSkillContext(ctx),
+                        recipeResolutionContext: getRecipeResolutionContext(ctx),
                         getThinkingLevel: () => pi.getThinkingLevel(),
                     };
                 }
@@ -61,6 +68,7 @@ export function createActorExtensionRuntime(pi) {
         configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
         exec: CommandTemplates.execCommandTemplate,
         getActiveTools: () => pi.getActiveTools(),
+        getAllTools: () => pi.getAllTools(),
         registerTool: (definition) => {
             const wrapped = withCurrentThinkingContext(definition);
             actorToolDefinitions.set(wrapped.name, wrapped);
@@ -69,10 +77,17 @@ export function createActorExtensionRuntime(pi) {
         reservedToolNames: Tools.RESERVED_TOOL_NAMES,
         setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
     });
-    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime);
+    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime, {
+        getResolutionContext: () => activeRunContext
+            ? getRecipeResolutionContext(activeRunContext)
+            : undefined,
+    });
     return {
         beforeAgentStart(systemPrompt, skills, ctx) {
-            skillContextsBySession.set(getRunOwnerId(ctx), RecipesReferences.createActiveSkillRecipeContext(skills));
+            const sessionId = getRunOwnerId(ctx);
+            const resolutionContext = RecipeResolution.createRecipeResolutionContext(sessionId, ctx.cwd, RecipesReferences.createActiveSkillRecipeContext(skills));
+            recipeResolutionContextsBySession.set(sessionId, resolutionContext);
+            runtime.loadTools(ctx, resolutionContext);
             return {
                 systemPrompt: `${systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
             };
@@ -87,14 +102,15 @@ export function createActorExtensionRuntime(pi) {
                 automaticReview.schedule();
         },
         onSessionShutdown(reason, ctx) {
-            skillContextsBySession.delete(getRunOwnerId(ctx));
+            recipeResolutionContextsBySession.delete(getRunOwnerId(ctx));
             activeRunContext = undefined;
             automaticReview.close();
             recipeReload.close();
             runUiRuntime.shutdown(reason, ctx);
         },
         async onSessionStart(ctx) {
-            skillContextsBySession.set(getRunOwnerId(ctx), RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT);
+            const sessionId = getRunOwnerId(ctx);
+            recipeResolutionContextsBySession.set(sessionId, RecipeResolution.createEmptyRecipeResolutionContext(sessionId, ctx.cwd));
             ctx.ui.setWidget("zz-pi-actors-comms", undefined);
             activeRunContext = ctx;
             runUiRuntime.close();
@@ -104,7 +120,6 @@ export function createActorExtensionRuntime(pi) {
             if (activeRunContext !== ctx)
                 return;
             automaticReview.start(ctx);
-            runtime.loadTools(ctx);
             runUiRuntime.start(ctx);
             recipeReload.watch(ctx);
         },
@@ -113,6 +128,7 @@ export function createActorExtensionRuntime(pi) {
                 configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
                 getActiveTools: () => pi.getActiveTools(),
                 getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
+                getRuntimeToolStatus: runtime.getToolStatus,
                 handleRuntimeControl: automaticReview.handleControl,
                 registryRuntime: runtime,
                 setActiveTools: (toolNames) => pi.setActiveTools(toolNames),

package/dist/lib/inspector.js

@@ -115,6 +115,7 @@ export function readActorInspectorRecipe(stateDir) {
             logical_reference: primaryLogicalReference,
             ...(typeof primary?.skill === "string" ? { skill: primary.skill } : {}),
             source_kind: primarySourceKind,
+            launch_kind: meta.launch_kind ?? meta.launch_source,
             launch_source: meta.launch_source,
         }),
         launch: redactedRecord({

package/dist/lib/prompts.d.ts

@@ -6,7 +6,7 @@
 export declare const REGISTER_TOOL_DESCRIPTION: string;
 export declare const REGISTER_TOOL_PROMPT_SNIPPET = "Register persistent command templates as agent-callable tools";
 export declare const REGISTER_TOOL_GUIDELINES: string[];
-export declare const ONBOARDING_SYSTEM_PROMPT = "pi-actors quick model:\n- Local-first actor memory: persist trusted local capabilities instead of rebuilding shell recipes.\n- Layers: task -> command template -> recipe/tool -> spawn -> run:<id>; tool:<name> wraps registered capabilities.\n- Command templates stay sync and shell-free: string leaves split into executable + argv, infer .js/.mjs through node\u2192bun\u2192deno run and .sh through bash, and treat operators such as && as literal arguments; use template arrays for sequencing or an explicit trusted shell/script when shell semantics are required. Flags include args/defaults, parallel, concurrency, min_successful, when, timeout, delay, retry, failure, recover, repeat, accept_output, output.\n- Placeholders support typed/default args plus {value??fallback} and {flag?yes:no}.\n- ~/.pi/agent/recipes/*.json is actor muscle memory: every recipe there is auto-registered as an agent tool across sessions; register_tool writes there.\n- Recipes own template directly and may declare metadata/defaults/imports/control/artifacts; files >1 MiB or import depth >32 fail closed.\n- Recipe imports are local variables; imported recipes are definitions, not nested async runs; parent async:true creates one run.\n- Actor-mode trigger: if work may outlive this turn, need steering/follow-up/artifacts, run as a service, fan out, or be resumed/inspected later, use spawn -> message -> inspect instead of ad hoc shell backgrounding.\n- Use spawn/message/inspect for actor-level start/send/observe; short foreground checks can stay ordinary tools/templates; avoid internal transport vocabulary in public guidance.\n- Run state lives under ~/.pi/agent/tmp/pi-actors/runs. Inspect intentionally and avoid busy-polling. Terminal and coordinator-bound notifications queue as Pi follow-ups so concurrently completed actors can reach the coordinator after current work instead of steering between tool calls. Terminal follow-up content stays minimal: run, status, one base path, and relative artifact names only; semantic output stays in non-LLM details and run state. When a deferred actor result gates the next step, wait for its terminal follow-up; do not schedule continuation loops, repeatedly inspect, or mutate its reviewed scope while it runs. Inspect early only for an operator request, a meaningful actor event, or diagnosis of an overdue/stuck run.\n- Maintain ~/.pi/agent/recipes like MEMORY.md for capabilities: keep useful tools, curate stale ones, and fix/remove/disable invalid recipes flagged by registry warnings; active-Skill and explicit file Recipes remain components outside user tool discovery; offer to save successful recurring patterns only after confirmation.\n- Prefer maintained active-Skill Recipes with spawn recipe=<skill>/<recipe> before ad hoc scripts/wrappers; explicit file Recipes use exact .json/.md paths; review swarms inherit current model/thinking, preflight before fanout, and expose quorum/concurrency/TTL knobs unless explicit args are passed.\n- For any non-trivial actor use or pi-actors change, read the bundled actors skill first. Before launching multiple actors/subagents for parallel implementation, independent artifact generation, delegated audit, or review, also read the bundled swarm skill; the coordinator owns decomposition, disjoint scopes, launch correctness, integration, and final validation. For deeper guidance, inspect installed extension sources/docs/recipes because README/docs are not automatically in context.";
+export declare const ONBOARDING_SYSTEM_PROMPT = "pi-actors quick model:\n- Local-first actor memory: persist trusted local capabilities instead of rebuilding shell recipes.\n- Layers: task -> command template -> recipe/tool -> spawn -> run:<id>; tool:<name> wraps registered capabilities.\n- Command templates stay sync and shell-free: string leaves split into executable + argv, infer .js/.mjs through node\u2192bun\u2192deno run and .sh through bash, and treat operators such as && as literal arguments; use template arrays for sequencing or an explicit trusted shell/script when shell semantics are required. Flags include args/defaults, parallel, concurrency, min_successful, when, timeout, delay, retry, failure, recover, repeat, accept_output, output.\n- Placeholders support typed/default args plus {value??fallback} and {flag?yes:no}.\n- ~/.pi/agent/recipes/*.json is actor muscle memory: valid admitted recipes are reconciled as tools across sessions; register_tool writes there and reports current activation truth.\n- Recipes own template directly and may declare metadata/defaults/imports/control/artifacts; files >1 MiB or import depth >32 fail closed.\n- Recipe imports are local variables; imported recipes are definitions, not nested async runs; parent async:true creates one run.\n- Actor-mode trigger: if work may outlive this turn, need steering/follow-up/artifacts, run as a service, fan out, or be resumed/inspected later, use spawn -> message -> inspect instead of ad hoc shell backgrounding.\n- Use spawn/message/inspect for actor-level start/send/observe; short foreground checks can stay ordinary tools/templates; avoid internal transport vocabulary in public guidance.\n- Run state lives under ~/.pi/agent/tmp/pi-actors/runs. Inspect intentionally and avoid busy-polling. Terminal and coordinator-bound notifications queue as Pi follow-ups so concurrently completed actors can reach the coordinator after current work instead of steering between tool calls. Terminal follow-up content stays minimal: run, status, one base path, and relative artifact names only; semantic output stays in non-LLM details and run state. When a deferred actor result gates the next step, wait for its terminal follow-up; do not schedule continuation loops, repeatedly inspect, or mutate its reviewed scope while it runs. Inspect early only for an operator request, a meaningful actor event, or diagnosis of an overdue/stuck run.\n- Maintain ~/.pi/agent/recipes like MEMORY.md for capabilities: keep useful tools, curate stale ones, and fix/remove/disable invalid recipes flagged by registry warnings; active-Skill and explicit file Recipes remain components outside user tool discovery; offer to save successful recurring patterns only after confirmation.\n- Prefer maintained active-Skill Recipes with spawn recipe=<skill>/<recipe> before ad hoc scripts/wrappers; explicit file Recipes use exact .json/.md paths; review swarms inherit current model/thinking, preflight before fanout, and expose quorum/concurrency/TTL knobs unless explicit args are passed.\n- For any non-trivial actor use or pi-actors change, read the bundled actors skill first. Before launching multiple actors/subagents for parallel implementation, independent artifact generation, delegated audit, or review, also read the bundled swarm skill; the coordinator owns decomposition, disjoint scopes, launch correctness, integration, and final validation. For deeper guidance, inspect installed extension sources/docs/recipes because README/docs are not automatically in context.";
 export declare const REGISTER_TOOL_PARAM_DESCRIPTIONS: {
     readonly name: "Tool name in snake_case (e.g., 'transcribe')";
     readonly description: "Describe what the tool does for the LLM. Required unless deleting; omitted updates keep the old description.";

package/dist/lib/prompts.js

@@ -9,7 +9,7 @@ export const REGISTER_TOOL_DESCRIPTION = "Register a persistent custom tool from
 export const REGISTER_TOOL_PROMPT_SNIPPET = "Register persistent command templates as agent-callable tools";
 export const REGISTER_TOOL_GUIDELINES = [
     "Use register_tool to wrap trusted local commands, scripts, programs, libraries, or template recipes as persistent pi tools.",
-    "After register_tool succeeds, the new tool is immediately callable and remains available after reload.",
+    "After register_tool succeeds, trust its callable_now and activation result; persisted definitions remain available for admission after reload.",
     'Set template=null or template="" in register_tool to delete a persisted tool.',
     "Set update=true in register_tool to overwrite an existing tool registration.",
 ];
@@ -18,7 +18,7 @@ export const ONBOARDING_SYSTEM_PROMPT = `pi-actors quick model:
 - Layers: task -> command template -> recipe/tool -> spawn -> run:<id>; tool:<name> wraps registered capabilities.
 - Command templates stay sync and shell-free: string leaves split into executable + argv, infer .js/.mjs through node→bun→deno run and .sh through bash, and treat operators such as && as literal arguments; use template arrays for sequencing or an explicit trusted shell/script when shell semantics are required. Flags include args/defaults, parallel, concurrency, min_successful, when, timeout, delay, retry, failure, recover, repeat, accept_output, output.
 - Placeholders support typed/default args plus {value??fallback} and {flag?yes:no}.
-- ~/.pi/agent/recipes/*.json is actor muscle memory: every recipe there is auto-registered as an agent tool across sessions; register_tool writes there.
+- ~/.pi/agent/recipes/*.json is actor muscle memory: valid admitted recipes are reconciled as tools across sessions; register_tool writes there and reports current activation truth.
 - Recipes own template directly and may declare metadata/defaults/imports/control/artifacts; files >1 MiB or import depth >32 fail closed.
 - Recipe imports are local variables; imported recipes are definitions, not nested async runs; parent async:true creates one run.
 - Actor-mode trigger: if work may outlive this turn, need steering/follow-up/artifacts, run as a service, fan out, or be resumed/inspected later, use spawn -> message -> inspect instead of ad hoc shell backgrounding.

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

@@ -1,10 +1,19 @@
 /**
- * Recipe context prompt assembly.
- * Zones: async runner prompt context, recipe provenance, LLM child launches
- * Owns compact actor recipe context records appended to child-agent prompts.
+ * Recipe context contracts and prompt assembly.
+ * Zones: live session resolution, async runner prompt context, recipe provenance, LLM child launches
+ * Owns the immutable live Recipe environment and compact actor context appended to child-agent prompts.
  */
 import type { CommandTemplateActorRecipeContext } from "./command-templates.ts";
+import * as RecipesReferences from "./recipes-references.ts";
 import type { TemplateRecipeContextRecord } from "./recipes-references.ts";
+export interface RecipeResolutionContext {
+    readonly activeSkills: RecipesReferences.ActiveSkillRecipeContext;
+    readonly cwd: string;
+    readonly generation: string;
+    readonly sessionId: string;
+}
+export declare function createRecipeResolutionContext(sessionId: string, cwd: string, activeSkills: RecipesReferences.ActiveSkillRecipeContext): RecipeResolutionContext;
+export declare function createEmptyRecipeResolutionContext(sessionId: string, cwd: string): RecipeResolutionContext;
 export interface MarkedRecipeContextRecord extends TemplateRecipeContextRecord {
     you_are_here?: true;
     you_are_here_path?: string;

package/dist/lib/recipes-context.js

@@ -1,10 +1,34 @@
 /**
- * Recipe context prompt assembly.
- * Zones: async runner prompt context, recipe provenance, LLM child launches
- * Owns compact actor recipe context records appended to child-agent prompts.
+ * Recipe context contracts and prompt assembly.
+ * Zones: live session resolution, async runner prompt context, recipe provenance, LLM child launches
+ * Owns the immutable live Recipe environment and compact actor context appended to child-agent prompts.
  */
+import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
-import { basename } from "node:path";
+import { basename, resolve } from "node:path";
+import * as RecipesReferences from "./recipes-references.js";
+export function createRecipeResolutionContext(sessionId, cwd, activeSkills) {
+    const normalizedSessionId = sessionId.trim();
+    if (!normalizedSessionId)
+        throw new Error("Recipe resolution session id is required.");
+    const normalizedCwd = resolve(cwd);
+    const generation = createHash("sha256")
+        .update(JSON.stringify({
+        activeSkills: RecipesReferences.getActiveSkillRecipeNamespaces(activeSkills),
+        cwd: normalizedCwd,
+        sessionId: normalizedSessionId,
+    }))
+        .digest("hex");
+    return Object.freeze({
+        activeSkills,
+        cwd: normalizedCwd,
+        generation,
+        sessionId: normalizedSessionId,
+    });
+}
+export function createEmptyRecipeResolutionContext(sessionId, cwd) {
+    return createRecipeResolutionContext(sessionId, cwd, RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT);
+}
 function commandName(command) {
     return basename(command).toLowerCase();
 }

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

@@ -5,6 +5,7 @@
  */
 import * as CommandTemplates from "./command-templates.ts";
 import type { RegisteredTool } from "./config.ts";
+import type { RecipeResolutionContext } from "./recipes-context.ts";
 import type { TemplateRecipeConfig } from "./recipes-references.ts";
 export interface DiscoveredRecipe {
     id: string;
@@ -18,6 +19,7 @@ export interface DiscoveredRecipe {
     disabled: boolean;
     tool: boolean;
     mutableUsage: boolean;
+    resolutionContext?: RecipeResolutionContext;
     diagnostics: string[];
     riskLabels: CommandTemplates.CommandTemplateRiskLabel[];
     shadows: string[];
@@ -44,6 +46,21 @@ export interface RecipesDiscoverySource {
     file?: string;
     defaultTool?: boolean;
     mutableUsage?: boolean;
+    resolutionContext?: RecipeResolutionContext;
+}
+export interface UserRecipeAdmission {
+    args?: string[];
+    argTypes?: RegisteredTool["argTypes"];
+    artifacts?: Record<string, string>;
+    async?: boolean;
+    control?: string[];
+    defaults?: Record<string, unknown>;
+    diagnostics: string[];
+    effectiveRecipe?: TemplateRecipeConfig;
+    identity: string;
+    sourcePath: string;
+    tool?: RegisteredTool;
+    validated: boolean;
 }
 export declare function hasBroadWindowsWriteAcl(icaclsOutput: string): boolean;
 export declare function discoverRecipeSources(sources: RecipesDiscoverySource[]): RecipesDiscoveryResult;
@@ -52,4 +69,5 @@ export declare function createRecipeIntegrityManifest(result: RecipesDiscoveryRe
 export declare function getShadowedLaunchDiagnostic(result: RecipesDiscoveryResult, id: string): Record<string, unknown> | undefined;
 export declare function listDraftRecipes(root: string): Array<Record<string, unknown>>;
 export declare function summarizeDiscovery(result: RecipesDiscoveryResult): Record<string, unknown>;
+export declare function admitUserRecipe(sourcePath: string, resolutionContext: RecipeResolutionContext, authoredRecipe?: Record<string, unknown>, mutableUsage?: boolean): UserRecipeAdmission;
 export declare function toRegisteredTool(entry: DiscoveredRecipe): RegisteredTool | undefined;

package/dist/lib/recipes-discovery.js

@@ -94,10 +94,12 @@ function getRecipeRiskLabels(config) {
         "risk.platform_specific",
     ].filter((label) => labels.has(label));
 }
-function readDiscoveredRecipe(root, file, priority, defaultTool = false, mutableUsage = false) {
+function readDiscoveredRecipe(root, file, priority, defaultTool = false, mutableUsage = false, resolutionContext) {
     const id = RecipesReferences.getRecipeIdFromPath(file);
     try {
-        const config = RecipesReferences.readResolvedRecipeConfig(file);
+        const config = RecipesReferences.readResolvedRecipeConfig(file, [], {
+            skillContext: resolutionContext?.activeSkills,
+        });
         const invalid = !config;
         const disabled = config?.disabled === true;
         return {
@@ -112,6 +114,7 @@ function readDiscoveredRecipe(root, file, priority, defaultTool = false, mutable
             disabled,
             tool: defaultTool && !disabled && !invalid,
             mutableUsage,
+            resolutionContext,
             diagnostics: getRecipeConfigDiagnostics(file, config),
             riskLabels: getRecipeRiskLabels(config),
             shadows: [],
@@ -129,6 +132,7 @@ function readDiscoveredRecipe(root, file, priority, defaultTool = false, mutable
             disabled: false,
             tool: false,
             mutableUsage,
+            resolutionContext,
             diagnostics: [
                 `Failed to load recipe ${file}: ${error instanceof Error ? error.message : String(error)}`,
             ],
@@ -147,6 +151,7 @@ function filesForSource(source) {
                 file: source.file,
                 defaultTool,
                 mutableUsage,
+                resolutionContext: source.resolutionContext,
             },
         ];
     return source.root
@@ -155,6 +160,7 @@ function filesForSource(source) {
             file,
             defaultTool,
             mutableUsage,
+            resolutionContext: source.resolutionContext,
         }))
         : [];
 }
@@ -222,7 +228,7 @@ function getRecipeRootDiagnostics(sources) {
     return diagnostics;
 }
 export function discoverRecipeSources(sources) {
-    const entries = sources.flatMap((source, priority) => filesForSource(source).map(({ root, file, defaultTool, mutableUsage }) => readDiscoveredRecipe(root, file, priority, defaultTool, mutableUsage)));
+    const entries = sources.flatMap((source, priority) => filesForSource(source).map(({ root, file, defaultTool, mutableUsage, resolutionContext }) => readDiscoveredRecipe(root, file, priority, defaultTool, mutableUsage, resolutionContext)));
     const byId = new Map();
     for (const entry of entries) {
         const bucket = byId.get(entry.id) ?? [];
@@ -647,12 +653,8 @@ export function summarizeDiscovery(result) {
         integrity_manifest: createRecipeIntegrityManifest(result),
     };
 }
-export function toRegisteredTool(entry) {
-    if (!entry.tool || entry.invalid || entry.disabled || !entry.config)
-        return undefined;
-    const cfg = entry.config;
-    const template = entry.path;
-    const description = cfg.description ?? `Execute template recipe: ${entry.id}`;
+function projectRegisteredTool(identity, path, cfg, mutableUsage) {
+    const description = cfg.description ?? `Execute template recipe: ${identity}`;
     const argTemplate = cfg.template;
     const argTemplateConfig = typeof argTemplate === "object" && !Array.isArray(argTemplate)
         ? {
@@ -669,24 +671,27 @@ export function toRegisteredTool(entry) {
         return [parsed.arg, parsed.type];
     }));
     assertToolSafeRepeatConfig(argTemplateConfig, explicitArgTypes, { ...(cfg.defaults ?? {}), ...(cfg.values ?? {}) });
-    const argTypes = Schema.getTemplateArgTypes(argTemplateConfig);
-    Schema.assertCompatibleToolArgTypes(explicitArgTypes, argTypes);
+    const inferredArgTypes = Schema.getTemplateArgTypes(argTemplateConfig);
+    Schema.assertCompatibleToolArgTypes(explicitArgTypes, inferredArgTypes);
+    const effectiveArgTypes = { ...inferredArgTypes, ...explicitArgTypes };
+    const args = Schema.getToolArgNames(argTemplateConfig).filter((arg) => !RecipesReferences.isRuntimeOwnedRecipeInput(arg));
+    const callerArgSet = new Set(args);
+    const argTypes = Object.fromEntries(Object.entries(effectiveArgTypes).filter(([arg]) => callerArgSet.has(arg)));
+    const defaults = Object.fromEntries(Object.entries(cfg.defaults ?? {}).filter(([arg]) => callerArgSet.has(arg)));
+    const storedArgs = cfg.args?.filter((arg) => callerArgSet.has(Schema.parseToolArgToken(String(arg)).arg));
     return {
-        name: entry.id,
+        name: identity,
         description,
-        template,
+        template: path,
         recipe: cfg,
-        args: Schema.getToolArgNames(argTemplateConfig),
-        defaults: Object.fromEntries(Object.entries(cfg.defaults ?? {}).map(([key, value]) => [
-            key,
-            String(value),
-        ])),
+        args,
+        defaults: Object.fromEntries(Object.entries(defaults).map(([key, value]) => [key, String(value)])),
         ...(Object.keys(argTypes).length > 0 ? { argTypes } : {}),
-        ...(entry.mutableUsage ? { sourcePath: entry.path } : {}),
-        ...(cfg.args ? { storedArgs: cfg.args } : {}),
-        ...(cfg.defaults
+        ...(mutableUsage ? { sourcePath: path } : {}),
+        ...(storedArgs ? { storedArgs } : {}),
+        ...(Object.keys(defaults).length > 0
             ? {
-                storedDefaults: Object.fromEntries(Object.entries(cfg.defaults).map(([key, value]) => [
+                storedDefaults: Object.fromEntries(Object.entries(defaults).map(([key, value]) => [
                     key,
                     String(value),
                 ])),
@@ -694,3 +699,71 @@ export function toRegisteredTool(entry) {
             : {}),
     };
 }
+function boundedAdmissionDiagnostic(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.length <= 4096 ? message : `${message.slice(0, 4095)}…`;
+}
+export function admitUserRecipe(sourcePath, resolutionContext, authoredRecipe, mutableUsage = true) {
+    const identity = RecipesReferences.getRecipeIdFromPath(sourcePath);
+    try {
+        const effectiveRecipe = RecipesReferences.readResolvedRecipeConfig(sourcePath, [], {
+            ...(authoredRecipe
+                ? { authoredEntry: { path: sourcePath, recipe: authoredRecipe } }
+                : {}),
+            skillContext: resolutionContext.activeSkills,
+        });
+        if (!effectiveRecipe) {
+            return {
+                diagnostics: [
+                    authoredRecipe
+                        ? "Recipe must define a valid template."
+                        : RecipesReferences.diagnoseRawRecipeConfigFailure(sourcePath) ??
+                            "Recipe must define a valid template.",
+                ],
+                identity,
+                sourcePath,
+                validated: false,
+            };
+        }
+        if (effectiveRecipe.disabled === true) {
+            return {
+                diagnostics: ["Recipe is disabled."],
+                effectiveRecipe,
+                identity,
+                sourcePath,
+                validated: false,
+            };
+        }
+        const tool = projectRegisteredTool(identity, sourcePath, effectiveRecipe, mutableUsage);
+        return {
+            args: tool.args,
+            argTypes: tool.argTypes,
+            artifacts: effectiveRecipe.artifacts,
+            async: effectiveRecipe.async === true,
+            control: effectiveRecipe.control,
+            defaults: effectiveRecipe.defaults,
+            diagnostics: [],
+            effectiveRecipe,
+            identity,
+            sourcePath,
+            tool,
+            validated: true,
+        };
+    }
+    catch (error) {
+        return {
+            diagnostics: [boundedAdmissionDiagnostic(error)],
+            identity,
+            sourcePath,
+            validated: false,
+        };
+    }
+}
+export function toRegisteredTool(entry) {
+    if (!entry.tool || entry.invalid || entry.disabled || !entry.config)
+        return undefined;
+    if (entry.resolutionContext) {
+        return admitUserRecipe(entry.path, entry.resolutionContext, undefined, entry.mutableUsage).tool;
+    }
+    return projectRegisteredTool(entry.id, entry.path, entry.config, entry.mutableUsage);
+}

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

@@ -56,9 +56,15 @@ export interface TemplateRecipeContextRecord {
     source_kind: "active_skill_component" | "explicit_file_recipe" | "user_registry_capability";
 }
 export interface ReadResolvedRecipeConfigOptions {
+    authoredEntry?: {
+        path: string;
+        recipe: Record<string, unknown>;
+    };
     includeActorRecipeContext?: boolean;
     skillContext?: ActiveSkillRecipeContext;
 }
+export declare const RUNTIME_OWNED_RECIPE_INPUT_NAMES: readonly string[];
+export declare function isRuntimeOwnedRecipeInput(name: string): boolean;
 export interface ActiveSkillRecipeSource {
     name: string;
     filePath?: string;
@@ -77,6 +83,18 @@ export interface ActiveSkillRecipeComponent {
     skill: string;
     stem: string;
 }
+export interface SkillRecipeComponentDiagnostic {
+    file?: string;
+    reason: string;
+    skill: string;
+    stem?: string;
+}
+export interface SkillRecipeComponentInventory {
+    components: ActiveSkillRecipeComponent[];
+    partial: boolean;
+    rejected: SkillRecipeComponentDiagnostic[];
+}
+export declare function inventoryActiveSkillRecipeComponents(context: ActiveSkillRecipeContext): SkillRecipeComponentInventory;
 export declare function listActiveSkillRecipeComponents(context: ActiveSkillRecipeContext): ActiveSkillRecipeComponent[];
 export declare function resolveRecipePath(value: string, baseDir?: string): string;
 export declare function resolveRecipeReferencePath(value: unknown, baseDir?: string, context?: ActiveSkillRecipeContext): string | undefined;