@llblab/pi-actors 0.46.0 → 0.46.1

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.join(", ")}`,
+                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) {
@@ -170,7 +229,7 @@ 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 +790,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 +864,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 +927,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 +970,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

@@ -16,16 +16,24 @@ export interface RegisterToolInput {
     values?: Record<string, unknown>;
 }
 export interface RegisterToolResultDetails {
+    active_tool?: boolean;
+    activation?: "current_session" | "unverified";
     args?: string[];
     async?: boolean;
+    callable_now?: boolean;
     config?: string;
     defaults?: Record<string, string>;
     draft?: string;
+    host_registered?: boolean;
+    persisted?: boolean;
     promoted?: boolean;
+    registry_active?: boolean;
+    resolved?: boolean;
     recipeName?: string;
     template?: CommandTemplates.CommandTemplateValue;
     templateWarnings?: string[];
     tool: string;
+    validated?: boolean;
 }
 export interface RegisterToolResult {
     content: Array<{
@@ -41,7 +49,12 @@ 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) => {
+        active_tool: boolean;
+        activation: "current_session" | "unverified";
+        callable_now: boolean;
+        host_registered: boolean;
+    } | void;
     reservedToolNames: Set<string>;
     setActiveTools: (toolNames: string[]) => void;
 }

package/dist/lib/registry.js

@@ -8,9 +8,11 @@ import { dirname, join, relative, resolve } from "node:path";
 import * as CommandTemplates from "./command-templates.js";
 import * as Config from "./config.js";
 import * as ExecutionOutput from "./execution-output.js";
-import { withFileMutationLock, writeJsonAtomic } from "./file-state.js";
+import { withFileMutationLock, writeJsonAtomic, writeTextAtomic, } from "./file-state.js";
 import * as Identity from "./identity.js";
 import * as Paths from "./paths.js";
+import * as RecipesContext from "./recipes-context.js";
+import * as RecipesDiscovery from "./recipes-discovery.js";
 import * as RecipesReferences from "./recipes-references.js";
 import * as Schema from "./schema.js";
 function textContent(text) {
@@ -58,21 +60,24 @@ function promoteDraftRecipe(name, input, ctx, deps) {
     if ((existing || existsSync(targetPath)) && !input.update) {
         throw new Error(ExecutionOutput.formatToolText(`Tool "${name}" already registered. Use update=true to overwrite.`));
     }
-    const config = RecipesReferences.readResolvedRecipeConfig(draftPath);
-    if (!config) {
+    const raw = RecipesReferences.readRawRecipeConfig(draftPath);
+    if (!raw) {
         const reason = RecipesReferences.diagnoseRawRecipeConfigFailure(draftPath);
         throw new Error(ExecutionOutput.formatToolText(`Draft recipe is invalid${reason ? `: ${reason}` : "."}`));
     }
-    const promoted = buildConfig(name, {
+    const authoredRecipe = buildAuthoredRecipe({
         ...input,
-        description: input.description ?? config.description,
-        template: draftPath,
-    }, existing);
-    const raw = RecipesReferences.readRawRecipeConfig(draftPath);
+        description: input.description ??
+            (typeof raw.description === "string" ? raw.description : undefined),
+    }, existing, raw);
+    const resolutionContext = getRegistrationResolutionContext(ctx, deps);
+    const candidate = RecipesDiscovery.admitUserRecipe(targetPath, resolutionContext, authoredRecipe);
+    if (!candidate.validated || !candidate.tool) {
+        throw new Error(ExecutionOutput.formatToolText(`Draft recipe is invalid: ${candidate.diagnostics.join("; ")}`));
+    }
     mkdirSync(dirname(targetPath), { recursive: true });
-    writeJsonAtomic(targetPath, raw);
-    promoted.template = targetPath;
-    promoted.sourcePath = targetPath;
+    writeJsonAtomic(targetPath, authoredRecipe);
+    const promoted = RecipesDiscovery.admitUserRecipe(targetPath, resolutionContext).tool;
     tools.set(name, promoted);
     deps.registerRuntimeTool(promoted);
     deps.notify(ctx, `Promoted draft recipe: ${name}`, "info");
@@ -89,17 +94,10 @@ function promoteDraftRecipe(name, input, ctx, deps) {
         },
     };
 }
-function persistToolRecipe(deps, cfg) {
-    const path = getToolRecipePath(deps, cfg.name);
+function persistToolRecipe(deps, name, recipe) {
+    const path = getToolRecipePath(deps, name);
     mkdirSync(dirname(path), { recursive: true });
-    writeJsonAtomic(path, {
-        description: cfg.description,
-        ...(cfg.recipe?.async !== undefined ? { async: cfg.recipe.async } : {}),
-        ...(cfg.storedArgs ? { args: cfg.storedArgs } : {}),
-        ...(cfg.storedDefaults ? { defaults: cfg.storedDefaults } : {}),
-        ...(cfg.recipe?.values ? { values: cfg.recipe.values } : {}),
-        template: cfg.template,
-    });
+    writeJsonAtomic(path, recipe);
     return path;
 }
 function deleteTool(name, ctx, deps) {
@@ -130,11 +128,15 @@ function readAuthoritativeStoredTool(deps, name) {
     if (!existsSync(path))
         return { exists: false };
     try {
-        const normalized = Config.normalizeStoredTool(name, JSON.parse(readFileSync(path, "utf8")), deps.reservedToolNames);
+        const bytes = readFileSync(path, "utf8");
+        const recipe = JSON.parse(bytes);
+        const normalized = Config.normalizeStoredTool(name, recipe, deps.reservedToolNames);
         if (!normalized.cfg)
-            return { exists: true };
+            return { bytes, exists: true, recipe };
         return {
+            bytes,
             exists: true,
+            recipe,
             tool: { ...normalized.cfg, sourcePath: path },
         };
     }
@@ -161,7 +163,17 @@ function getInputTemplate(value) {
     }
     throw new Error(ExecutionOutput.formatToolText("Tool template must be a string, object, or sequence."));
 }
-function buildConfig(name, input, existing) {
+function getRegistrationResolutionContext(ctx, deps) {
+    if (ctx &&
+        typeof ctx === "object" &&
+        "recipeResolutionContext" in ctx) {
+        const resolutionContext = ctx.recipeResolutionContext;
+        if (resolutionContext)
+            return resolutionContext;
+    }
+    return RecipesContext.createEmptyRecipeResolutionContext("offline-register-tool", getRecipeRoot(deps));
+}
+function buildAuthoredRecipe(input, existing, existingRecipe) {
     const explicitArgs = input.args === undefined
         ? undefined
         : Schema.parseToolArgDeclarations(input.args);
@@ -175,63 +187,29 @@ function buildConfig(name, input, existing) {
     if (template === null) {
         throw new Error(ExecutionOutput.formatToolText("Tool template cannot be null here."));
     }
-    const finalTemplate = template === undefined || template === "" ? existing?.template : template;
+    const finalTemplate = template === undefined || template === ""
+        ? existingRecipe?.template ?? existing?.template
+        : template;
     if (!finalTemplate) {
         throw new Error(ExecutionOutput.formatToolText("Tool template is required."));
     }
-    const inputRecipe = typeof input.async === "boolean" ? name : undefined;
-    const recipe = inputRecipe
-        ? {
-            name: inputRecipe,
-            ...(typeof input.async === "boolean" ? { async: input.async } : {}),
-            template: finalTemplate,
-            ...(input.values && typeof input.values === "object"
-                ? { values: input.values }
-                : {}),
-        }
-        : template === undefined
-            ? existing?.recipe
-            : undefined;
-    const defaults = explicitArgs?.defaults ?? existing?.storedDefaults ?? {};
-    const storedArgs = explicitArgs
-        ? explicitArgs.declarations
-        : existing?.storedArgs;
-    const storedDefaults = Object.keys(defaults).length > 0 ? defaults : undefined;
-    const recipeTemplate = RecipesReferences.getRecipeTemplate(finalTemplate);
-    const argTemplate = recipeTemplate ?? finalTemplate;
-    const argTemplateConfig = typeof argTemplate === "object" && !Array.isArray(argTemplate)
-        ? {
-            ...argTemplate,
-            ...(storedArgs !== undefined ? { args: storedArgs } : {}),
-            defaults: { ...(argTemplate.defaults ?? {}), ...defaults },
-        }
-        : {
-            args: storedArgs,
-            defaults,
-            template: argTemplate,
-        };
-    const inferredArgTypes = Schema.getTemplateArgTypes(argTemplateConfig);
-    const argTypes = {
-        ...inferredArgTypes,
-        ...(existing?.argTypes ?? {}),
-        ...(explicitArgs?.argTypes ?? {}),
-    };
-    return {
-        name,
+    const authored = {
+        ...(existingRecipe ?? {}),
         description,
         template: finalTemplate,
-        ...(recipe ? { recipe } : {}),
-        args: RecipesReferences.isRecipeTool(finalTemplate, recipe) &&
-            storedArgs !== undefined
-            ? Schema.getExplicitToolArgNames(storedArgs)
-            : RecipesReferences.isRecipeReference(finalTemplate) && !recipeTemplate
-                ? Schema.getExplicitToolArgNames(storedArgs)
-                : Schema.getToolArgNames(argTemplateConfig),
-        defaults,
-        ...(Object.keys(argTypes).length > 0 ? { argTypes } : {}),
-        ...(storedArgs !== undefined ? { storedArgs } : {}),
-        ...(storedDefaults !== undefined ? { storedDefaults } : {}),
     };
+    if (typeof input.async === "boolean")
+        authored.async = input.async;
+    if (explicitArgs) {
+        authored.args = explicitArgs.declarations;
+        if (Object.keys(explicitArgs.defaults).length > 0)
+            authored.defaults = explicitArgs.defaults;
+        else
+            delete authored.defaults;
+    }
+    if (input.values && typeof input.values === "object")
+        authored.values = input.values;
+    return authored;
 }
 function executeRegisterToolUnlocked(params, ctx, deps) {
     const input = params;
@@ -262,37 +240,82 @@ function executeRegisterToolUnlocked(params, ctx, deps) {
     if (template === undefined && !existing) {
         throw new Error(ExecutionOutput.formatToolText("Tool template is required for new registrations."));
     }
-    const cfg = buildConfig(name, input, existing);
-    let recipePath;
+    const recipePath = getToolRecipePath(deps, name);
+    const authoredRecipe = buildAuthoredRecipe(input, existing, authoritative.recipe);
+    const resolutionContext = getRegistrationResolutionContext(ctx, deps);
+    const candidate = RecipesDiscovery.admitUserRecipe(recipePath, resolutionContext, authoredRecipe);
+    if (!candidate.validated || !candidate.tool) {
+        throw new Error(ExecutionOutput.formatToolText(`Tool recipe validation failed: ${candidate.diagnostics.join("; ")}`));
+    }
+    const activeBefore = deps.getActiveTools();
+    let persisted = false;
+    let activation;
+    let cfg;
     try {
-        recipePath = persistToolRecipe(deps, cfg);
+        persistToolRecipe(deps, name, authoredRecipe);
+        persisted = true;
+        const admitted = RecipesDiscovery.admitUserRecipe(recipePath, resolutionContext);
+        if (!admitted.validated || !admitted.tool) {
+            throw new Error(`Persisted tool recipe admission failed: ${admitted.diagnostics.join("; ")}`);
+        }
+        cfg = admitted.tool;
+        tools.set(name, cfg);
+        activation = deps.registerRuntimeTool(cfg) ?? undefined;
+        if (activation &&
+            (!activation.host_registered ||
+                !activation.active_tool ||
+                !activation.callable_now)) {
+            throw new Error(`Host activation verification failed: ${JSON.stringify(activation)}`);
+        }
     }
     catch (error) {
-        throw new Error(ExecutionOutput.formatToolText(`Failed to persist tool recipe: ${error instanceof Error ? error.message : String(error)}`));
+        if (persisted) {
+            if (authoritative.bytes !== undefined)
+                writeTextAtomic(recipePath, authoritative.bytes);
+            else if (existsSync(recipePath))
+                unlinkSync(recipePath);
+        }
+        if (existing) {
+            tools.set(name, existing);
+            deps.registerRuntimeTool(existing);
+        }
+        else {
+            tools.delete(name);
+        }
+        deps.setActiveTools(activeBefore);
+        throw new Error(ExecutionOutput.formatToolText(`Tool registration transaction failed: ${error instanceof Error ? error.message : String(error)}`));
     }
-    cfg.sourcePath = recipePath;
-    tools.set(name, cfg);
-    deps.registerRuntimeTool(cfg);
-    deps.notify(ctx, `Tool persisted: ${name}`, "info");
-    const templateWarnings = CommandTemplates.getCommandTemplateWarnings(typeof cfg.template === "object" && !Array.isArray(cfg.template)
-        ? cfg.template
-        : { template: cfg.template });
+    deps.notify(ctx, `Tool activated: ${name}`, "info");
+    const templateWarnings = CommandTemplates.getCommandTemplateWarnings(typeof cfg.recipe?.template === "object" && !Array.isArray(cfg.recipe.template)
+        ? cfg.recipe.template
+        : { template: cfg.recipe?.template ?? cfg.template });
     const warningText = templateWarnings.length > 0
         ? `\nWarnings:\n${templateWarnings.map((warning) => `- ${warning}`).join("\n")}`
         : "";
+    const outcomeText = activation?.callable_now
+        ? `${existing ? "Updated" : "Registered"} and activated tool "${name}"`
+        : `Persisted tool "${name}"; current-session activation is unverified`;
     return {
         content: [
-            textContent(ExecutionOutput.formatToolText(`${existing ? "Updated" : "Registered"} tool "${name}" (args: ${Schema.formatToolArgs(cfg.args)}).${warningText}`)),
+            textContent(ExecutionOutput.formatToolText(`${outcomeText} (args: ${Schema.formatToolArgs(cfg.args)}).${warningText}`)),
         ],
         details: {
+            active_tool: activation?.active_tool ?? false,
+            activation: activation?.activation ?? "unverified",
             args: cfg.args,
+            callable_now: activation?.callable_now ?? false,
             config: recipePath,
             defaults: cfg.defaults,
+            host_registered: activation?.host_registered ?? false,
+            persisted: true,
+            registry_active: tools.get(name) === cfg,
+            resolved: true,
             ...(cfg.recipe?.async !== undefined ? { async: cfg.recipe.async } : {}),
             ...(cfg.recipe?.name ? { recipeName: cfg.recipe.name } : {}),
             ...(cfg.template ? { template: cfg.template } : {}),
             ...(templateWarnings.length > 0 ? { templateWarnings } : {}),
             tool: name,
+            validated: true,
         },
     };
 }

package/dist/lib/runtime.d.ts

@@ -6,6 +6,7 @@
 import { watch } from "node:fs";
 import * as Config from "./config.ts";
 import type { RegisteredToolExec } from "./execution.ts";
+import type { RecipeResolutionContext } from "./recipes-context.ts";
 import * as ToolsLocal from "./tools-local.ts";
 export interface RuntimeContext {
     hasUI: boolean;
@@ -13,21 +14,46 @@ export interface RuntimeContext {
         notify(message: string, type?: "info" | "warning" | "error"): void;
     };
 }
+export interface RuntimeToolActivation {
+    active_tool: boolean;
+    activation: "current_session" | "unverified";
+    callable_now: boolean;
+    host_registered: boolean;
+}
 export interface ToolRegistryRuntimeDeps {
     configPath: string;
     exec: RegisteredToolExec;
     recipeRoot?: string;
     getActiveTools?: () => string[];
+    getAllTools?: () => Array<{
+        name: string;
+    }>;
     registerTool: (definition: ReturnType<typeof ToolsLocal.createRuntimeToolDefinition>) => void;
     reservedToolNames: Set<string>;
     setActiveTools?: (toolNames: string[]) => void;
 }
+export interface RecipeRegistryStatus {
+    active_tool_count: number;
+    last_scan_counts: {
+        active: number;
+        rejected: number;
+        scanned: number;
+    };
+    last_scan_at?: string;
+    registry_generation: number;
+    resolution_generation?: string;
+    watch_status: "closed" | "failed" | "watching_parent" | "watching_root";
+    watched_root: string;
+}
 export interface ToolRegistryRuntime {
+    getStatus(): RecipeRegistryStatus;
+    getToolStatus(name: string): Record<string, unknown> | undefined;
     getToolNameBlocker(name: string): string | undefined;
     getTools(): Map<string, Config.RegisteredTool>;
-    loadTools(ctx: RuntimeContext): void;
+    loadTools(ctx: RuntimeContext, resolutionContext?: RecipeResolutionContext): void;
     notify(ctx: RuntimeContext, message: string, type: "info" | "warning" | "error"): void;
-    registerRuntimeTool(cfg: Config.RegisteredTool): void;
+    registerRuntimeTool(cfg: Config.RegisteredTool): RuntimeToolActivation;
+    setWatchStatus(status: RecipeRegistryStatus["watch_status"]): void;
 }
 export interface RecipeToolReloadWatcher {
     close(): void;
@@ -36,7 +62,8 @@ export interface RecipeToolReloadWatcher {
 export declare function createAutoToolsRuntime(deps: ToolRegistryRuntimeDeps): ToolRegistryRuntime;
 export interface RecipeToolReloadWatcherDeps {
     exists?: (path: string) => boolean;
+    getResolutionContext?: () => RecipeResolutionContext | undefined;
     recipeRoot?: string;
     watchPath?: typeof watch;
 }
-export declare function createRecipeToolReloadWatcher(runtime: Pick<ToolRegistryRuntime, "loadTools">, deps?: RecipeToolReloadWatcherDeps): RecipeToolReloadWatcher;
+export declare function createRecipeToolReloadWatcher(runtime: Pick<ToolRegistryRuntime, "loadTools"> & Partial<Pick<ToolRegistryRuntime, "setWatchStatus">>, deps?: RecipeToolReloadWatcherDeps): RecipeToolReloadWatcher;