@llblab/pi-actors 0.46.0 → 0.47.0

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,8 +132,9 @@ 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)}`,
+                `Recipe ${id} rejected: ${error instanceof Error ? error.message : String(error)}`,
             ],
             riskLabels: [],
             shadows: [],
@@ -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,83 @@ export function toRegisteredTool(entry) {
             : {}),
     };
 }
+export function summarizeRegisteredToolArgs(tool) {
+    const publicArgs = tool.args.filter((arg) => !RecipesReferences.isRuntimeOwnedRecipeInput(arg));
+    const inlineDefaults = Schema.getExplicitToolArgDefaults(tool.recipe?.args);
+    const required = publicArgs.filter((arg) => !Object.hasOwn(tool.defaults, arg) &&
+        !Object.hasOwn(inlineDefaults, arg));
+    const requiredSet = new Set(required);
+    const optional = publicArgs.filter((arg) => !requiredSet.has(arg));
+    if (tool.recipe?.async === true) {
+        optional.push("run_id", "transport_context");
+    }
+    return { optional, required };
+}
+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;

package/dist/lib/recipes-references.js

@@ -11,7 +11,24 @@ import * as RecipeControl from "./recipe-control.js";
 import * as Schema from "./schema.js";
 const MAX_RECIPE_FILE_BYTES = 1024 * 1024;
 const MAX_RECIPE_IMPORT_DEPTH = 32;
-const RUNTIME_RECIPE_VALUE_NAMES = new Set(["recipe_dir", "skill_dir"]);
+const RESERVED_AUTHORED_RECIPE_VALUE_NAMES = new Set([
+    "recipe_dir",
+    "skill_dir",
+]);
+export const RUNTIME_OWNED_RECIPE_INPUT_NAMES = Object.freeze([
+    "owner_id",
+    "recipe_dir",
+    "run_instance_id",
+    "runtime_state_root",
+    "session_id",
+    "skill_dir",
+    "state_dir",
+    "trace_file",
+]);
+const RUNTIME_OWNED_RECIPE_INPUT_SET = new Set(RUNTIME_OWNED_RECIPE_INPUT_NAMES);
+export function isRuntimeOwnedRecipeInput(name) {
+    return RUNTIME_OWNED_RECIPE_INPUT_SET.has(name);
+}
 export function createActiveSkillRecipeContext(skills) {
     const rootsByName = new Map();
     for (const skill of skills) {
@@ -49,19 +66,31 @@ function nestedRecipeFiles(root) {
         return entry.isFile() && /\.(?:json|md)$/u.test(entry.name) ? [path] : [];
     });
 }
-export function listActiveSkillRecipeComponents(context) {
+export function inventoryActiveSkillRecipeComponents(context) {
     const components = [];
+    const rejected = [];
     for (const [skill, roots] of Object.entries(context.namespaces)) {
-        if (roots.length > 1)
-            throw new Error(`Duplicate active Skill identity ${skill}: ${roots.join(", ")}`);
+        if (roots.length > 1) {
+            rejected.push({
+                reason: `Duplicate active Skill identity ${skill} (${roots.length} active definitions); exact Recipe resolution is ambiguous. Next: inspect target=recipes view=doctor identity=${skill}/<recipe>`,
+                skill,
+            });
+            continue;
+        }
         const root = roots[0];
         if (!root || !existsSync(root))
             continue;
         const direct = readdirSync(root, { withFileTypes: true });
         for (const entry of direct.filter((candidate) => candidate.isDirectory())) {
             const nested = nestedRecipeFiles(join(root, entry.name));
-            if (nested.length > 0)
-                throw new Error(`Nested Skill Recipe file is not addressable: ${nested[0]}`);
+            for (const file of nested) {
+                rejected.push({
+                    file,
+                    reason: `Nested Skill Recipe file is not addressable: ${file}`,
+                    skill,
+                    stem: getRecipeIdFromPath(file),
+                });
+            }
         }
         const files = direct
             .filter((entry) => entry.isFile() && /\.(?:json|md)$/u.test(entry.name))
@@ -74,28 +103,58 @@ export function listActiveSkillRecipeComponents(context) {
             byStem.set(stem, matches);
         }
         for (const [stem, matches] of [...byStem].sort(([a], [b]) => a.localeCompare(b))) {
-            if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(stem))
-                throw new Error(`Invalid Skill Recipe filename stem: ${stem}`);
-            if (matches.length > 1)
-                throw new Error(`Skill Recipe stem collision: ${skill}/${stem} has both .json and .md files`);
+            if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(stem)) {
+                rejected.push({
+                    file: matches[0],
+                    reason: `Invalid Skill Recipe filename stem: ${stem}`,
+                    skill,
+                    stem,
+                });
+                continue;
+            }
+            if (matches.length > 1) {
+                rejected.push({
+                    file: matches[0],
+                    reason: `Skill Recipe stem collision: ${skill}/${stem} has both .json and .md files`,
+                    skill,
+                    stem,
+                });
+                continue;
+            }
             const file = matches[0];
-            const raw = readRawRecipeConfig(file);
-            if (!raw || !Object.hasOwn(raw, "template"))
-                throw new Error(`Invalid Skill Recipe component: ${skill}/${stem}`);
-            assertRecipeHasNoDeclaredName(raw);
-            components.push({
-                file,
-                identity: `${skill}/${stem}`,
-                imports: Object.fromEntries(Object.entries(getRecipeImports(raw)).map(([alias, value]) => [
-                    alias,
-                    getImportFrom(value),
-                ])),
-                skill,
-                stem,
-            });
+            try {
+                const raw = readRawRecipeConfig(file);
+                if (!raw || !Object.hasOwn(raw, "template"))
+                    throw new Error(`Invalid Skill Recipe component: ${skill}/${stem}`);
+                assertRecipeHasNoDeclaredName(raw);
+                components.push({
+                    file,
+                    identity: `${skill}/${stem}`,
+                    imports: Object.fromEntries(Object.entries(getRecipeImports(raw)).map(([alias, value]) => [
+                        alias,
+                        getImportFrom(value),
+                    ])),
+                    skill,
+                    stem,
+                });
+            }
+            catch (error) {
+                rejected.push({
+                    file,
+                    reason: error instanceof Error ? error.message : String(error),
+                    skill,
+                    stem,
+                });
+            }
         }
     }
-    return components;
+    return { components, partial: rejected.length > 0, rejected };
+}
+export function listActiveSkillRecipeComponents(context) {
+    const inventory = inventoryActiveSkillRecipeComponents(context);
+    if (inventory.rejected.length > 0)
+        throw new Error(inventory.rejected[0].reason);
+    return inventory.components;
 }
 const SKILL_RECIPE_REFERENCE = /^([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\/([a-z][a-z0-9]*(?:-[a-z0-9]+)*)$/;
 function qualifiedRecipeNameForFile(file, context) {
@@ -116,10 +175,11 @@ function qualifiedRecipeNameForFile(file, context) {
 }
 function assertRecipeReferencePrefixWasNotRemoved(value) {
     if (value.startsWith("std:")) {
-        throw new Error("std: Recipe references were removed in pi-actors 0.46.\nUse <skill>/<recipe> or an explicit .json/.md file path.");
+        throw new Error("std: Recipe references were removed in pi-actors 0.46. Use <skill>/<recipe> or an explicit .json/.md file path. Next: inspect target=recipes view=status to identify the active owning Skill.");
     }
     if (value.startsWith("skill:")) {
-        throw new Error("skill: Recipe references were removed in pi-actors 0.46.\nUse <skill>/<recipe> without a prefix.");
+        const identity = value.slice("skill:".length);
+        throw new Error(`skill: Recipe references were removed in pi-actors 0.46. Use ${identity} without a prefix. Next: inspect target=recipes view=doctor identity=${identity}`);
     }
 }
 function skillRecipeCandidates(value, context) {
@@ -129,12 +189,15 @@ function skillRecipeCandidates(value, context) {
     const [, skillName, recipeName] = match;
     const roots = [...(context.namespaces[skillName] ?? [])];
     if (roots.length === 0)
-        throw new Error(`Active Skill Recipe not found: ${skillName}/${recipeName}`);
+        throw new Error(`Active Skill Recipe not found: ${skillName}/${recipeName}. Owning Skill "${skillName}" is not active. Next: activate Skill ${skillName}, then inspect target=recipes view=doctor identity=${skillName}/${recipeName}`);
     if (roots.length > 1)
-        throw new Error(`Duplicate active Skill identity ${skillName}: ${roots.join(", ")}`);
+        throw new Error(`Duplicate active Skill identity ${skillName} (${roots.length} active definitions); ${skillName}/${recipeName} cannot resolve unambiguously. Next: inspect target=recipes view=doctor identity=${skillName}/${recipeName}`);
     const root = roots[0];
     const candidates = ["json", "md"].map((extension) => resolve(root, `${recipeName}.${extension}`));
     const existing = candidates.filter((candidate) => existsSync(candidate));
+    if (existing.length === 0) {
+        throw new Error(`Skill Recipe component not found: ${skillName}/${recipeName}; owning Skill "${skillName}" is active. Next: inspect target=recipes view=doctor identity=${skillName}/${recipeName}`);
+    }
     if (existing.length > 1) {
         throw new Error(`Skill Recipe stem collision: ${skillName}/${recipeName} has both .json and .md files`);
     }
@@ -164,13 +227,13 @@ function findOwningSkillDir(recipeFile) {
 function assertRecipeHasNoDeclaredName(raw) {
     if (!Object.hasOwn(raw, "name"))
         return;
-    throw new Error("Recipe.name was removed in pi-actors 0.46.\nFile-backed Recipe identity is derived from its file name.");
+    throw new Error("Recipe.name was removed in pi-actors 0.46. File-backed Recipe identity is derived from its file name. Next: remove the name field, keep the intended filename stem, then inspect target=recipes view=doctor.");
 }
 function assertRuntimeRecipeValuesNotDeclared(raw) {
     const args = Array.isArray(raw.args)
         ? Schema.getExplicitToolArgNames(raw.args.map(String))
         : [];
-    for (const name of RUNTIME_RECIPE_VALUE_NAMES) {
+    for (const name of RESERVED_AUTHORED_RECIPE_VALUE_NAMES) {
         if (args.includes(name) ||
             (isRecord(raw.defaults) && Object.hasOwn(raw.defaults, name)) ||
             (isRecord(raw.values) && Object.hasOwn(raw.values, name))) {
@@ -731,6 +794,28 @@ function getDirectDelegatedRecipe(value, currentRecipeFile, stack, options = {})
     }
     return undefined;
 }
+function resolveDirectDelegationArgs(delegated, wrapperArgs, wrapperDefaults) {
+    if (!Array.isArray(delegated.args))
+        return Array.isArray(wrapperArgs) ? wrapperArgs.map(String) : undefined;
+    const delegatedSpec = Schema.parseToolArgDeclarationList(delegated.args);
+    if (delegatedSpec.error)
+        throw new Error(delegatedSpec.error);
+    const wrapperDeclarations = Array.isArray(wrapperArgs)
+        ? wrapperArgs.map(String)
+        : [];
+    const wrapperSpec = Schema.parseToolArgDeclarationList(wrapperDeclarations);
+    if (wrapperSpec.error)
+        throw new Error(wrapperSpec.error);
+    const declared = new Set(delegatedSpec.args);
+    for (const arg of wrapperSpec.args) {
+        if (!declared.has(arg))
+            throw new Error(`Unknown delegated Recipe argument: ${arg}`);
+    }
+    Schema.assertCompatibleToolArgTypes(delegatedSpec.argTypes, wrapperSpec.argTypes);
+    assertRecipeDefaultsDeclared(delegated.args, wrapperDefaults, "delegated Recipe default");
+    Schema.normalizeRuntimeValues(Object.fromEntries(Object.entries(wrapperDefaults ?? {}).filter(([, value]) => typeof value !== "string" || !/\{[^{}]+\}/.test(value))), delegatedSpec.argTypes);
+    return delegated.args;
+}
 function expandImportNodes(value, imports, options = {}) {
     if (typeof value === "string")
         return value;
@@ -783,7 +868,9 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
     if (stack.length >= MAX_RECIPE_IMPORT_DEPTH) {
         throw new Error(`Recipe import depth exceeds limit ${MAX_RECIPE_IMPORT_DEPTH}: ${[...stack, path].join(" -> ")}`);
     }
-    const raw = readRawRecipeConfig(path);
+    const raw = options.authoredEntry?.path === path
+        ? options.authoredEntry.recipe
+        : readRawRecipeConfig(path);
     if (!raw || !Object.hasOwn(raw, "template"))
         return undefined;
     assertRecipeHasNoDeclaredName(raw);
@@ -844,7 +931,15 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
             role: stack.length > 0 ? "import" : "entry",
         })
         : expandedTemplate;
-    const mergedDefaults = mergeDefaults(delegated?.defaults, isRecord(substituted.defaults) ? substituted.defaults : undefined);
+    const wrapperDefaults = isRecord(substituted.defaults)
+        ? substituted.defaults
+        : undefined;
+    const mergedDefaults = mergeDefaults(delegated?.defaults, wrapperDefaults);
+    const effectiveArgs = delegated
+        ? resolveDirectDelegationArgs(delegated, substituted.args, wrapperDefaults)
+        : Array.isArray(substituted.args)
+            ? substituted.args
+            : undefined;
     const artifactSource = isRecord(substituted.artifacts)
         ? substituted.artifacts
         : delegated?.artifacts;
@@ -879,11 +974,7 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
             ? { imports: getRecipeImports(raw) }
             : {}),
         template: templateWithContext,
-        ...(Array.isArray(substituted.args)
-            ? { args: substituted.args }
-            : Array.isArray(delegated?.args)
-                ? { args: delegated.args }
-                : {}),
+        ...(effectiveArgs ? { args: effectiveArgs } : {}),
         ...(mergedDefaults ? { defaults: mergedDefaults } : {}),
         ...(typeof substituted.parallel === "boolean"
             ? { parallel: substituted.parallel }

package/dist/lib/registry.d.ts

@@ -10,22 +10,32 @@ export interface RegisterToolInput {
     description?: string;
     async?: boolean;
     template?: CommandTemplates.CommandTemplateValue | null;
+    from?: string;
+    defaults?: Record<string, unknown>;
     draft?: string;
     args?: string;
     update?: boolean;
-    values?: Record<string, unknown>;
 }
 export interface RegisterToolResultDetails {
+    active_tool?: boolean;
+    activation?: "current_session" | "unverified";
+    activation_boundary?: string;
     args?: string[];
     async?: boolean;
-    config?: string;
+    callable_now?: boolean;
     defaults?: Record<string, string>;
-    draft?: string;
+    host_registered?: boolean;
+    next_actions?: string[];
+    optional_args?: string[];
+    persisted?: boolean;
     promoted?: boolean;
-    recipeName?: string;
-    template?: CommandTemplates.CommandTemplateValue;
+    registry_active?: boolean;
+    required_args?: string[];
+    resolved?: boolean;
+    source?: string;
     templateWarnings?: string[];
     tool: string;
+    validated?: boolean;
 }
 export interface RegisterToolResult {
     content: Array<{
@@ -34,6 +44,12 @@ export interface RegisterToolResult {
     }>;
     details: RegisterToolResultDetails;
 }
+interface RuntimeActivation {
+    active_tool: boolean;
+    activation: "current_session" | "unverified";
+    callable_now: boolean;
+    host_registered: boolean;
+}
 export interface RegisterToolRuntimeDeps<TContext> {
     configPath: string;
     recipeRoot?: string;
@@ -41,8 +57,9 @@ export interface RegisterToolRuntimeDeps<TContext> {
     getTools: () => Map<string, Config.RegisteredTool>;
     getActiveTools: () => string[];
     notify: (ctx: TContext, message: string, type: "info" | "warning" | "error") => void;
-    registerRuntimeTool: (cfg: Config.RegisteredTool) => void;
+    registerRuntimeTool: (cfg: Config.RegisteredTool) => RuntimeActivation | void;
     reservedToolNames: Set<string>;
     setActiveTools: (toolNames: string[]) => void;
 }
 export declare function executeRegisterTool<TContext>(params: unknown, ctx: TContext, deps: RegisterToolRuntimeDeps<TContext>): Promise<RegisterToolResult>;
+export {};