@llblab/pi-actors 0.45.1 → 0.46.1

package/dist/lib/recipes-references.js

@@ -3,19 +3,34 @@
  * Zones: registry config, async runs, path resolution
  * Owns detection, loading, and recipe-layer expansion for template recipe files
  */
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, extname, isAbsolute, relative, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import * as CommandTemplates from "./command-templates.js";
 import * as Paths from "./paths.js";
 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 activeSkillRecipeRoots = new Map();
-export function setActiveSkillRecipeSources(skills) {
-    activeSkillRecipeRoots.clear();
+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) {
         const name = skill.name.trim();
         const skillDir = skill.baseDir
@@ -25,62 +40,174 @@ export function setActiveSkillRecipeSources(skills) {
                 : undefined;
         if (!name || !skillDir)
             continue;
-        const roots = activeSkillRecipeRoots.get(name) ?? new Set();
+        const roots = rootsByName.get(name) ?? new Set();
         roots.add(resolve(skillDir, "recipes"));
-        activeSkillRecipeRoots.set(name, roots);
+        rootsByName.set(name, roots);
     }
-}
-export function getActiveSkillRecipeNamespaces() {
-    return Object.fromEntries([...activeSkillRecipeRoots.entries()]
+    const namespaces = Object.fromEntries([...rootsByName.entries()]
         .sort(([left], [right]) => left.localeCompare(right))
-        .map(([name, roots]) => [name, [...roots].sort()]));
+        .map(([name, roots]) => [name, Object.freeze([...roots].sort())]));
+    return Object.freeze({ namespaces: Object.freeze(namespaces) });
+}
+export const EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT = createActiveSkillRecipeContext([]);
+export function getActiveSkillRecipeNamespaces(context) {
+    return Object.fromEntries(Object.entries(context.namespaces).map(([name, roots]) => [
+        name,
+        [...roots],
+    ]));
+}
+function nestedRecipeFiles(root) {
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(root, entry.name);
+        if (entry.isDirectory())
+            return nestedRecipeFiles(path);
+        return entry.isFile() && /\.(?:json|md)$/u.test(entry.name) ? [path] : [];
+    });
+}
+export function inventoryActiveSkillRecipeComponents(context) {
+    const components = [];
+    const rejected = [];
+    for (const [skill, roots] of Object.entries(context.namespaces)) {
+        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));
+            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))
+            .map((entry) => join(root, entry.name));
+        const byStem = new Map();
+        for (const file of files) {
+            const stem = getRecipeIdFromPath(file);
+            const matches = byStem.get(stem) ?? [];
+            matches.push(file);
+            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)) {
+                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];
+            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, 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;
 }
-function qualifiedRecipeNameForFile(file) {
+const SKILL_RECIPE_REFERENCE = /^([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\/([a-z][a-z0-9]*(?:-[a-z0-9]+)*)$/;
+function qualifiedRecipeNameForFile(file, context) {
     const path = resolve(file);
-    const stdRelation = relative(Paths.getPackagedRecipeRoot(), path);
-    if (stdRelation &&
-        !stdRelation.startsWith("..") &&
-        !isAbsolute(stdRelation)) {
-        return `std:${stdRelation.replace(/\.(?:json|md)$/u, "")}`;
-    }
-    for (const [skillName, roots] of activeSkillRecipeRoots) {
-        if (roots.size !== 1)
+    for (const [skillName, roots] of Object.entries(context.namespaces)) {
+        if (roots.length !== 1)
             continue;
-        const root = [...roots][0];
+        const root = roots[0];
         const relation = relative(root, path);
-        if (relation && !relation.startsWith("..") && !isAbsolute(relation))
-            return `skill:${skillName}/${relation.replaceAll("\\", "/").replace(/\.(?:json|md)$/u, "")}`;
+        if (relation &&
+            dirname(relation) === "." &&
+            !relation.startsWith("..") &&
+            !isAbsolute(relation)) {
+            return `${skillName}/${basename(relation, extname(relation))}`;
+        }
     }
     return undefined;
 }
-function qualifiedRecipeCandidates(value) {
+function assertRecipeReferencePrefixWasNotRemoved(value) {
     if (value.startsWith("std:")) {
-        return recipeNameFiles(value.slice(4)).map((file) => resolve(Paths.getPackagedRecipeRoot(), file));
+        throw new Error("std: Recipe references were removed in pi-actors 0.46.\nUse <skill>/<recipe> or an explicit .json/.md file path.");
     }
-    if (!value.startsWith("skill:"))
+    if (value.startsWith("skill:")) {
+        throw new Error("skill: Recipe references were removed in pi-actors 0.46.\nUse <skill>/<recipe> without a prefix.");
+    }
+}
+function skillRecipeCandidates(value, context) {
+    const match = SKILL_RECIPE_REFERENCE.exec(value);
+    if (!match)
         return undefined;
-    const qualified = value.slice(6);
-    const separator = qualified.indexOf("/");
-    if (separator <= 0 || separator === qualified.length - 1)
-        throw new Error(`Invalid Skill Recipe reference: ${value}`);
-    const skillName = qualified.slice(0, separator);
-    const recipeName = qualified.slice(separator + 1);
-    const roots = [...(activeSkillRecipeRoots.get(skillName) ?? [])];
+    const [, skillName, recipeName] = match;
+    const roots = [...(context.namespaces[skillName] ?? [])];
     if (roots.length === 0)
-        throw new Error(`Active Skill Recipe namespace not found: ${skillName}`);
+        throw new Error(`Active Skill Recipe not found: ${skillName}/${recipeName}`);
     if (roots.length > 1)
-        throw new Error(`Ambiguous active Skill Recipe namespace ${skillName}: ${roots.join(", ")}`);
+        throw new Error(`Duplicate active Skill identity ${skillName}: ${roots.join(", ")}`);
     const root = roots[0];
-    return recipeNameFiles(recipeName).map((file) => {
-        const candidate = resolve(root, file);
-        const relation = relative(root, candidate);
-        if (!relation || relation.startsWith("..") || isAbsolute(relation))
-            throw new Error(`Skill Recipe reference escapes its recipes root: ${value}`);
-        return candidate;
-    });
+    const candidates = ["json", "md"].map((extension) => resolve(root, `${recipeName}.${extension}`));
+    const existing = candidates.filter((candidate) => existsSync(candidate));
+    if (existing.length > 1) {
+        throw new Error(`Skill Recipe stem collision: ${skillName}/${recipeName} has both .json and .md files`);
+    }
+    return candidates;
 }
-function hasWhitespace(value) {
-    return /\s/.test(value);
+function recipeReferenceCandidates(value, baseDir, context) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    assertRecipeReferencePrefixWasNotRemoved(trimmed);
+    if (trimmed.endsWith(".json") || trimmed.endsWith(".md")) {
+        return [resolve(baseDir, trimmed)];
+    }
+    return skillRecipeCandidates(trimmed, context);
 }
 function findOwningSkillDir(recipeFile) {
     let current = dirname(recipeFile);
@@ -93,11 +220,16 @@ function findOwningSkillDir(recipeFile) {
         current = parent;
     }
 }
+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.");
+}
 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))) {
@@ -105,82 +237,28 @@ function assertRuntimeRecipeValuesNotDeclared(raw) {
         }
     }
 }
-export function resolveRecipePath(value, recipeRoot = Paths.getRecipeRoot()) {
-    const trimmed = value.trim();
-    const repoRoot = resolve(recipeRoot, "..");
-    const expanded = trimmed
-        .replaceAll("{repo}", repoRoot)
-        .replaceAll("{agent}", Paths.getAgentDir());
-    if (expanded.startsWith("~/"))
-        return resolve(homedir(), expanded.slice(2));
-    if (expanded.includes("/"))
-        return resolve(expanded);
-    return resolve(recipeRoot, expanded.endsWith(".json") || expanded.endsWith(".md")
-        ? expanded
-        : `${expanded}.json`);
-}
-function isBareRecipeName(value) {
-    const trimmed = value.trim();
-    return (Boolean(trimmed) &&
-        !trimmed.includes("/") &&
-        !trimmed.startsWith("~") &&
-        !trimmed.includes("{"));
+export function resolveRecipePath(value, baseDir = Paths.getRecipeRoot()) {
+    const candidates = recipeReferenceCandidates(value, baseDir, EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT);
+    if (!candidates || candidates.length !== 1) {
+        throw new Error(`Recipe file reference must be an explicit .json or .md path: ${value}`);
+    }
+    return candidates[0];
 }
-function recipeNameFiles(value) {
-    const trimmed = value.trim();
-    if (trimmed.endsWith(".json") || trimmed.endsWith(".md"))
-        return [trimmed];
-    return [`${trimmed}.json`, `${trimmed}.md`];
-}
-function recipeCandidatePaths(value, currentRecipeRoot) {
-    const qualified = qualifiedRecipeCandidates(value.trim());
-    if (qualified)
-        return qualified;
-    if (!isBareRecipeName(value))
-        return [resolveRecipePath(value, currentRecipeRoot)];
-    const roots = [
-        Paths.getRecipeRoot(),
-        currentRecipeRoot,
-        Paths.getPackagedRecipeRoot(),
-    ];
-    return [
-        ...new Set(roots.flatMap((root) => recipeNameFiles(value).map((file) => resolve(root, file)))),
-    ];
-}
-function resolveRecipeImportPath(value, currentRecipeRoot) {
-    const candidates = recipeCandidatePaths(value, currentRecipeRoot);
+function resolveRecipeImportPath(value, recipeDir, context) {
+    const candidates = recipeReferenceCandidates(value, recipeDir, context);
+    if (!candidates) {
+        throw new Error(`Recipe import must use <skill>/<recipe> or an explicit .json/.md file path: ${value}`);
+    }
     return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
 }
-export function resolveRecipeReferencePath(value, currentRecipeRoot = Paths.getRecipeRoot()) {
+export function resolveRecipeReferencePath(value, baseDir = Paths.getRecipeRoot(), context = EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT) {
     if (typeof value !== "string")
         return undefined;
-    const trimmed = value.trim();
-    if (!trimmed || hasWhitespace(trimmed))
-        return undefined;
-    for (const path of recipeCandidatePaths(trimmed, currentRecipeRoot)) {
-        if (!existsSync(path))
-            continue;
-        try {
-            const raw = readRawRecipeConfig(path);
-            if (raw && typeof raw === "object" && Object.hasOwn(raw, "template"))
-                return path;
-            return path;
-        }
-        catch {
-            return path;
-        }
-    }
-    return undefined;
+    const candidates = recipeReferenceCandidates(value, baseDir, context);
+    return candidates?.find((candidate) => existsSync(candidate));
 }
-export function getRecipePath(value, recipeRoot = Paths.getRecipeRoot()) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed || hasWhitespace(trimmed))
-        return undefined;
-    if (trimmed.endsWith(".json") || trimmed.endsWith(".md"))
-        return resolveRecipePath(trimmed, recipeRoot);
-    return resolveRecipeReferencePath(trimmed, recipeRoot);
+export function getRecipePath(value, baseDir = Paths.getRecipeRoot(), context = EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT) {
+    return resolveRecipeReferencePath(value, baseDir, context);
 }
 function isImportNode(value) {
     if (!isRecord(value) || Object.hasOwn(value, "template"))
@@ -655,7 +733,7 @@ function withActorRecipeContext(value, context) {
     return { actorRecipeContext: context, template: value };
 }
 function loadDelegatedRecipe(value, currentRecipeFile, stack, options) {
-    const path = resolveRecipeReferencePath(value, dirname(currentRecipeFile));
+    const path = resolveRecipeReferencePath(value, dirname(currentRecipeFile), options.skillContext);
     if (!path)
         return undefined;
     const config = readResolvedRecipeConfig(path, [...stack, currentRecipeFile], options);
@@ -712,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;
@@ -764,15 +864,18 @@ 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);
     RecipeControl.assertRecipeHasNoMailbox(raw);
     assertRuntimeRecipeValuesNotDeclared(raw);
     assertRecipeArgumentContract(raw);
     const imports = {};
     for (const [alias, binding] of Object.entries(getRecipeImports(raw))) {
-        const importPath = resolveRecipeImportPath(getImportFrom(binding), dirname(path));
+        const importPath = resolveRecipeImportPath(getImportFrom(binding), dirname(path), options.skillContext ?? EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT);
         const config = readResolvedRecipeConfig(importPath, [...stack, path], options);
         if (!config)
             throw new Error(`Recipe import not found: ${alias}`);
@@ -782,7 +885,7 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
         imports[alias] = {
             alias,
             file: importPath,
-            name: config.name ?? alias,
+            name: getRecipeIdFromPath(importPath),
             config,
             defaults: { ...(config.defaults ?? {}), ...(bindingDefaults ?? {}) },
             values: {
@@ -824,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;
@@ -859,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 }
@@ -930,7 +1037,7 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
         ...(isRecord(substituted.usage) ? { usage: substituted.usage } : {}),
     };
 }
-function collectRecipeContextRecords(file, stack, importPath, alias) {
+function collectRecipeContextRecords(file, stack, importPath, context, alias) {
     const path = resolveRecipePath(file, stack.length > 0 ? dirname(stack.at(-1)) : Paths.getRecipeRoot());
     if (stack.includes(path)) {
         throw new Error(`Cyclic recipe import: ${[...stack, path].join(" -> ")}`);
@@ -941,26 +1048,32 @@ function collectRecipeContextRecords(file, stack, importPath, alias) {
     const raw = readRawRecipeConfig(path);
     if (!raw || !Object.hasOwn(raw, "template"))
         return [];
-    const qualifiedName = qualifiedRecipeNameForFile(path);
+    assertRecipeHasNoDeclaredName(raw);
+    const qualifiedName = qualifiedRecipeNameForFile(path, context);
+    const skill = qualifiedName?.split("/", 1)[0];
     const record = {
         ...(alias ? { alias } : {}),
         depth: stack.length,
-        file: path,
         import_path: importPath,
+        logical_reference: qualifiedName ?? basename(path),
         name: getRecipeIdFromPath(path),
-        ...(qualifiedName ? { qualified_name: qualifiedName } : {}),
         recipe: raw,
         role: stack.length === 0 ? "entry" : "import",
+        ...(skill ? { skill } : {}),
+        source_file: path,
+        source_kind: qualifiedName
+            ? "active_skill_component"
+            : "explicit_file_recipe",
     };
     const imports = getRecipeImports(raw);
     const children = Object.entries(imports).flatMap(([childAlias, binding]) => {
-        const importFile = resolveRecipeImportPath(getImportFrom(binding), dirname(path));
-        return collectRecipeContextRecords(importFile, [...stack, path], [...importPath, childAlias], childAlias);
+        const importFile = resolveRecipeImportPath(getImportFrom(binding), dirname(path), context);
+        return collectRecipeContextRecords(importFile, [...stack, path], [...importPath, childAlias], context, childAlias);
     });
     return [record, ...children];
 }
-export function buildRecipeContextRecords(file) {
-    return collectRecipeContextRecords(file, [], []);
+export function buildRecipeContextRecords(file, context = EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT) {
+    return collectRecipeContextRecords(file, [], [], context);
 }
 export function getRecipeTemplate(value) {
     return readRecipeConfig(value)?.template;

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;
 }