@llblab/pi-actors 0.46.0 → 0.47.0

package/dist/lib/runtime.js

@@ -7,11 +7,21 @@ import { existsSync, watch } from "node:fs";
 import { basename, dirname } from "node:path";
 import * as Paths from "./paths.js";
 import * as RecipesDiscovery from "./recipes-discovery.js";
+import * as RecipesReferences from "./recipes-references.js";
+import * as RecipesUsage from "./recipes-usage.js";
 import * as ToolsLocal from "./tools-local.js";
 export function createAutoToolsRuntime(deps) {
     const tools = new Map();
     const runtimeToolFingerprints = new Map();
     const runtimeTools = new Set();
+    const recipeRoot = deps.recipeRoot ?? Paths.getRecipeRoot();
+    const status = {
+        active_tool_count: 0,
+        last_scan_counts: { active: 0, rejected: 0, scanned: 0 },
+        registry_generation: 0,
+        watch_status: "closed",
+        watched_root: recipeRoot,
+    };
     function notify(ctx, message, type) {
         if (ctx.hasUI)
             ctx.ui.notify(message, type);
@@ -31,6 +41,21 @@ export function createAutoToolsRuntime(deps) {
             template: cfg.template,
         });
     }
+    function registeredToolSource(cfg) {
+        const raw = cfg.sourcePath
+            ? RecipesReferences.readRawRecipeConfig(cfg.sourcePath)
+            : undefined;
+        const template = raw?.template;
+        if (typeof template === "string" &&
+            /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*\/[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(template)) {
+            return template;
+        }
+        if (typeof template === "string" &&
+            (template.endsWith(".json") || template.endsWith(".md"))) {
+            return `<explicit-file:${basename(template)}>`;
+        }
+        return "template";
+    }
     function deactivateMissingRuntimeTools(activeNames) {
         const stale = [...runtimeTools].filter((name) => !activeNames.has(name));
         if (stale.length === 0)
@@ -44,13 +69,29 @@ export function createAutoToolsRuntime(deps) {
         const staleSet = new Set(stale);
         deps.setActiveTools(deps.getActiveTools().filter((name) => !staleSet.has(name)));
     }
+    function activationFor(name) {
+        const hostRegistered = deps.getAllTools?.().some((tool) => tool.name === name) ?? false;
+        const activeTool = deps.getActiveTools?.().includes(name) ?? false;
+        return {
+            active_tool: activeTool,
+            activation: hostRegistered && activeTool ? "current_session" : "unverified",
+            callable_now: hostRegistered && activeTool,
+            host_registered: hostRegistered,
+        };
+    }
     function registerRuntimeTool(cfg) {
         const fingerprint = getToolFingerprint(cfg);
-        if (runtimeToolFingerprints.get(cfg.name) === fingerprint)
-            return;
-        deps.registerTool(ToolsLocal.createRuntimeToolDefinition(cfg, deps.exec));
-        runtimeTools.add(cfg.name);
-        runtimeToolFingerprints.set(cfg.name, fingerprint);
+        if (runtimeToolFingerprints.get(cfg.name) !== fingerprint) {
+            deps.registerTool(ToolsLocal.createRuntimeToolDefinition(cfg, deps.exec));
+            runtimeTools.add(cfg.name);
+            runtimeToolFingerprints.set(cfg.name, fingerprint);
+        }
+        if (deps.getActiveTools && deps.setActiveTools) {
+            deps.setActiveTools([
+                ...new Set([...deps.getActiveTools(), cfg.name]),
+            ]);
+        }
+        return activationFor(cfg.name);
     }
     function isStartupActionableRegistryWarning(warning) {
         if (warning.includes(" shadows "))
@@ -80,13 +121,18 @@ export function createAutoToolsRuntime(deps) {
             lines.push("Other registry diagnostics:");
             lines.push(...other.map((warning) => `• ${warning}`));
         }
+        lines.push("Next: inspect target=recipes view=doctor");
         return `${lines.join("\n")}\n`;
     }
-    function loadTools(ctx) {
+    function loadTools(ctx, resolutionContext) {
         const warnings = [];
-        const recipeRoot = deps.recipeRoot ?? Paths.getRecipeRoot();
         const discovered = RecipesDiscovery.discoverRecipeSources([
-            { root: recipeRoot, defaultTool: true, mutableUsage: true },
+            {
+                root: recipeRoot,
+                defaultTool: true,
+                mutableUsage: true,
+                resolutionContext,
+            },
         ]);
         warnings.push(...discovered.diagnostics);
         tools.clear();
@@ -109,17 +155,65 @@ export function createAutoToolsRuntime(deps) {
             }
             registerRuntimeTool(cfg);
         }
+        status.active_tool_count = tools.size;
+        status.last_scan_at = new Date().toISOString();
+        status.last_scan_counts = {
+            active: tools.size,
+            rejected: discovered.entries.filter((entry) => entry.invalid).length,
+            scanned: discovered.entries.length,
+        };
+        status.registry_generation += 1;
+        status.resolution_generation = resolutionContext?.generation;
         const startupWarnings = warnings.filter(isStartupActionableRegistryWarning);
         if (startupWarnings.length > 0) {
             notify(ctx, formatRecipeToolWarnings(startupWarnings), "warning");
         }
     }
     return {
+        getStatus: () => ({
+            ...status,
+            last_scan_counts: { ...status.last_scan_counts },
+        }),
+        getToolStatus: (name) => {
+            const cfg = tools.get(name);
+            if (!cfg)
+                return undefined;
+            const usage = cfg.sourcePath
+                ? RecipesUsage.readRecipeUsage(cfg.sourcePath)
+                : undefined;
+            const activation = activationFor(name);
+            const args = RecipesDiscovery.summarizeRegisteredToolArgs(cfg);
+            return {
+                ...activation,
+                activation_boundary: activation.callable_now
+                    ? "current_session"
+                    : !activation.host_registered
+                        ? "host_registration"
+                        : "active_tool_set",
+                persisted: Boolean(cfg.sourcePath),
+                registry_active: true,
+                source: registeredToolSource(cfg),
+                required_args: args.required,
+                optional_args: args.optional,
+                next_actions: activation.callable_now
+                    ? [`call tool ${name}`]
+                    : [
+                        `register_tool name=${name} update=true`,
+                        `inspect target=tool:${name} view=status`,
+                    ],
+                ...(usage?.launch_kind ? { launch_kind: usage.launch_kind } : {}),
+                spawn_calls: Number(usage?.spawn_calls ?? 0),
+                tool_calls: Number(usage?.tool_calls ?? 0),
+            };
+        },
         getToolNameBlocker,
         getTools: () => tools,
         loadTools,
         notify,
         registerRuntimeTool,
+        setWatchStatus: (watchStatus) => {
+            status.watch_status = watchStatus;
+        },
     };
 }
 export function createRecipeToolReloadWatcher(runtime, deps = {}) {
@@ -129,6 +223,7 @@ export function createRecipeToolReloadWatcher(runtime, deps = {}) {
     let rootWatcher;
     let parentWatcher;
     let failureNotified = false;
+    const setWatchStatus = (watchStatus) => runtime.setWatchStatus?.(watchStatus);
     const close = () => {
         const closingRoot = rootWatcher;
         rootWatcher = undefined;
@@ -139,11 +234,13 @@ export function createRecipeToolReloadWatcher(runtime, deps = {}) {
         if (reloadTimeout)
             clearTimeout(reloadTimeout);
         reloadTimeout = undefined;
+        setWatchStatus("closed");
     };
     const notifyFailure = (ctx) => {
         if (failureNotified)
             return;
         failureNotified = true;
+        setWatchStatus("failed");
         ctx.ui.notify("Recipe live reload watcher failed; restart the session or use register_tool again to refresh recipe tools.", "warning");
     };
     const scheduleReload = (ctx) => {
@@ -151,7 +248,7 @@ export function createRecipeToolReloadWatcher(runtime, deps = {}) {
         if (reloadTimeout)
             clearTimeout(reloadTimeout);
         reloadTimeout = setTimeout(() => {
-            runtime.loadTools(ctx);
+            runtime.loadTools(ctx, deps.getResolutionContext?.());
             ctx.ui.notify("Recipe tools refreshed from ~/.pi/agent/recipes", "info");
         }, 150);
         reloadTimeout.unref?.();
@@ -181,6 +278,7 @@ export function createRecipeToolReloadWatcher(runtime, deps = {}) {
                 scheduleReload(ctx);
             });
             parentWatcher = watcher;
+            setWatchStatus("watching_parent");
             watcher.on("error", () => {
                 if (parentWatcher !== watcher)
                     return;
@@ -214,6 +312,7 @@ export function createRecipeToolReloadWatcher(runtime, deps = {}) {
                 scheduleReload(ctx);
             });
             rootWatcher = watcher;
+            setWatchStatus("watching_root");
             watcher.on("error", () => {
                 if (rootWatcher !== watcher)
                     return;

package/dist/lib/tools-inspect.d.ts

@@ -3,10 +3,13 @@
  * Zones: Run Recipe/Trace/Control views and runtime/recipe/tool diagnostics
  * Owns exact inspect target/view dispatch; source projection stays in domain modules.
  */
+import * as Runtime from "./runtime.ts";
 export interface InspectToolDeps<TContext = unknown> {
     getRunStatus?: (runOrDir: string) => Record<string, any>;
     getTool?: (name: string) => any | undefined;
+    getToolStatus?: (name: string) => Record<string, unknown> | undefined;
     listRuns?: () => Array<Record<string, any>>;
     recipeRoot?: string;
+    registryStatus?: () => Runtime.RecipeRegistryStatus;
 }
 export declare function createInspectToolDefinition<TContext = unknown>(deps?: InspectToolDeps<TContext>): any;

package/dist/lib/tools-inspect.js

@@ -3,8 +3,8 @@
  * Zones: Run Recipe/Trace/Control views and runtime/recipe/tool diagnostics
  * Owns exact inspect target/view dispatch; source projection stays in domain modules.
  */
-import { statSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
 import * as AsyncRuns from "./async-runs.js";
 import * as ControlProjection from "./control-projection.js";
 import * as Inspector from "./inspector.js";
@@ -157,7 +157,114 @@ function inspectRuntime(view, input, ctx, deps) {
         return runtimeTriage(ctx, deps);
     throw new Error("inspect runtime supports view=status, view=runs, or view=triage.");
 }
-function inspectRecipes(view, deps, context) {
+function portableSkillRecipePath(file, skill, namespaces) {
+    const root = namespaces[skill]?.[0];
+    if (!root)
+        return `<active-skill:${skill}>`;
+    const relation = relative(root, file);
+    return !relation.startsWith("..") && !isAbsolute(relation)
+        ? `<active-skill:${skill}>/${relation.replaceAll("\\", "/")}`
+        : `<active-skill:${skill}>`;
+}
+function portableSkillRecipeDiagnosticReason(diagnostic, namespaces) {
+    let reason = diagnostic.reason;
+    if (diagnostic.file) {
+        reason = reason.replaceAll(diagnostic.file, portableSkillRecipePath(diagnostic.file, diagnostic.skill, namespaces));
+    }
+    for (const root of namespaces[diagnostic.skill] ?? []) {
+        reason = reason.replaceAll(root, `<active-skill:${diagnostic.skill}>`);
+    }
+    return reason;
+}
+function inspectRecipeIdentity(identity, resolutionContext, namespaces, inventory, registryStatus) {
+    const match = /^([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\/([a-z][a-z0-9]*(?:-[a-z0-9]+)*)$/u.exec(identity);
+    const skill = match?.[1] ?? "";
+    const roots = skill ? namespaces[skill] ?? [] : [];
+    const skillActive = roots.length === 1;
+    const matchingComponent = inventory.components.find((component) => component.identity === identity);
+    const matchingRejection = inventory.rejected.find((diagnostic) => diagnostic.skill === skill &&
+        (diagnostic.stem === undefined || diagnostic.stem === match?.[2]));
+    let sourceLocation;
+    let rejectedReason;
+    let resolvable = false;
+    if (!match) {
+        rejectedReason =
+            "Identity must use canonical <skill>/<recipe> syntax.";
+    }
+    else if (roots.length === 0) {
+        rejectedReason = `Active Skill Recipe not found: ${identity}`;
+    }
+    else if (roots.length > 1) {
+        rejectedReason = matchingRejection
+            ? portableSkillRecipeDiagnosticReason(matchingRejection, namespaces)
+            : `Duplicate active Skill identity ${skill}`;
+    }
+    else if (matchingRejection) {
+        rejectedReason = portableSkillRecipeDiagnosticReason(matchingRejection, namespaces);
+        if (matchingRejection.file) {
+            sourceLocation = portableSkillRecipePath(matchingRejection.file, skill, namespaces);
+        }
+    }
+    else {
+        try {
+            const file = RecipesReferences.resolveRecipeReferencePath(identity, resolutionContext?.cwd, resolutionContext?.activeSkills);
+            if (!file || !existsSync(file)) {
+                rejectedReason = `Skill Recipe component not found: ${identity}`;
+            }
+            else {
+                sourceLocation = portableSkillRecipePath(file, skill, namespaces);
+                const recipe = RecipesReferences.readResolvedRecipeConfig(file, [], {
+                    skillContext: resolutionContext?.activeSkills,
+                });
+                if (recipe)
+                    resolvable = true;
+                else {
+                    rejectedReason =
+                        RecipesReferences.diagnoseRawRecipeConfigFailure(file) ??
+                            `Recipe could not be resolved: ${identity}`;
+                }
+            }
+        }
+        catch (error) {
+            rejectedReason = error instanceof Error ? error.message : String(error);
+        }
+    }
+    const componentStatus = resolvable
+        ? "available"
+        : !match
+            ? "invalid_identity"
+            : roots.length === 0
+                ? "skill_inactive"
+                : roots.length > 1
+                    ? "ambiguous_skill"
+                    : matchingRejection
+                        ? "rejected"
+                        : matchingComponent
+                            ? "unresolvable"
+                            : "missing";
+    return {
+        identity,
+        skill_active: skillActive,
+        resolvable,
+        catalog_partial: inventory.partial,
+        component_status: componentStatus,
+        ...(sourceLocation ? { source_location: sourceLocation } : {}),
+        resolution_generation: resolutionContext?.generation ?? registryStatus?.resolution_generation ?? "unavailable",
+        ...(rejectedReason ? { rejected_reason: rejectedReason } : {}),
+        next_actions: resolvable
+            ? [
+                `spawn recipe=${identity}`,
+                `register_tool name=<tool-name> from=${identity}`,
+            ]
+            : roots.length === 0 && skill
+                ? [
+                    `activate Skill ${skill}`,
+                    `inspect target=recipes view=doctor identity=${identity}`,
+                ]
+                : ["inspect target=recipes view=imports verbose=true"],
+    };
+}
+function inspectRecipes(view, input, deps, context) {
     if (view !== "status" &&
         view !== "summary" &&
         view !== "doctor" &&
@@ -172,30 +279,47 @@ function inspectRecipes(view, deps, context) {
     const discovered = RecipesDiscovery.discoverRecipeSources([
         { root: recipeRoot, defaultTool: true, mutableUsage: true },
     ]);
-    const skillContext = context && typeof context === "object" && "activeSkillRecipeContext" in context
-        ? context.activeSkillRecipeContext
+    const resolutionContext = context && typeof context === "object" && "recipeResolutionContext" in context
+        ? context.recipeResolutionContext
         : undefined;
-    const activeSkillContext = skillContext ?? RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT;
+    const activeSkillContext = resolutionContext?.activeSkills ??
+        RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT;
     const skillRecipeNamespaces = RecipesReferences.getActiveSkillRecipeNamespaces(activeSkillContext);
-    let skillRecipeComponents = [];
-    const skillRecipeComponentDiagnostics = [];
-    try {
-        skillRecipeComponents = RecipesReferences.listActiveSkillRecipeComponents(activeSkillContext).map((component) => ({
-            identity: component.identity,
-            source_kind: "active_skill_component",
-            skill: component.skill,
-            stem: component.stem,
-            imports: component.imports,
-        }));
+    const skillInventory = RecipesReferences.inventoryActiveSkillRecipeComponents(activeSkillContext);
+    const registryStatus = deps.registryStatus?.();
+    const identity = typeof input.identity === "string" ? input.identity.trim() : "";
+    if (identity && view !== "doctor") {
+        throw new Error("inspect recipes identity is supported only with view=doctor.");
     }
-    catch (error) {
-        skillRecipeComponentDiagnostics.push({
-            error: error instanceof Error ? error.message : String(error),
-        });
+    if (view === "doctor" && identity) {
+        return inspectRecipeIdentity(identity, resolutionContext, skillRecipeNamespaces, skillInventory, registryStatus);
     }
+    const skillRecipeComponents = skillInventory.components.map((component) => ({
+        identity: component.identity,
+        source_kind: "active_skill_component",
+        skill: component.skill,
+        stem: component.stem,
+        imports: component.imports,
+    }));
+    const skillRecipeComponentDiagnostics = skillInventory.rejected.map((diagnostic) => ({
+        error: portableSkillRecipeDiagnosticReason(diagnostic, skillRecipeNamespaces),
+        ...(diagnostic.file
+            ? {
+                file: portableSkillRecipePath(diagnostic.file, diagnostic.skill, skillRecipeNamespaces),
+            }
+            : {}),
+        skill: diagnostic.skill,
+        ...(diagnostic.stem ? { stem: diagnostic.stem } : {}),
+    }));
     const discoverySummary = RecipesDiscovery.summarizeDiscovery(discovered);
     const summary = {
         ...discoverySummary,
+        ...(registryStatus
+            ? {
+                ...registryStatus,
+                watched_root: "~/.pi/agent/recipes",
+            }
+            : {}),
         active: Array.isArray(discoverySummary.active)
             ? discoverySummary.active.map((entry) => ({
                 ...entry,
@@ -204,6 +328,7 @@ function inspectRecipes(view, deps, context) {
             : discoverySummary.active,
         skill_recipe_components: skillRecipeComponents,
         skill_recipe_component_diagnostics: skillRecipeComponentDiagnostics,
+        skill_recipe_catalog_partial: skillInventory.partial,
         active_skill_recipe_identities: Object.keys(skillRecipeNamespaces).sort(),
         skill_recipe_namespace_diagnostics: Object.entries(skillRecipeNamespaces)
             .filter(([, roots]) => roots.length > 1)
@@ -303,20 +428,58 @@ function inspectTool(name, view, deps) {
         throw new Error("inspect tool:<name> supports view=status or view=schema.");
     }
     const tool = deps.getTool?.(name);
-    if (!tool)
-        throw new Error(`registered tool not found: ${name}`);
+    const status = deps.getToolStatus?.(name);
+    if (!tool && !status) {
+        throw new Error(`Registered tool not found: ${name}. Next: inspect target=recipes view=doctor; do not substitute spawn for tool invocation.`);
+    }
+    if (view === "schema" && !tool) {
+        throw new Error(`Tool "${name}" is registered but its callable schema is unavailable; callable_now=${String(status?.callable_now ?? false)}, activation_boundary=${String(status?.activation_boundary ?? "host_registration")}. Next: inspect target=tool:${name} view=status.`);
+    }
     return {
         name,
-        description: tool.description,
-        parameters: tool.parameters,
-        promptSnippet: tool.promptSnippet,
+        ...(view === "status" ? status : {}),
+        ...(tool
+            ? {
+                description: tool.description,
+                parameters: tool.parameters,
+                promptSnippet: tool.promptSnippet,
+            }
+            : {}),
     };
 }
 function compactResult(target, view, details) {
     if (target === "runtime")
         return compactRuntime(view, details);
+    if (target === "recipes" && typeof details.identity === "string") {
+        const lines = [
+            `recipes doctor identity=${details.identity} skill_active=${String(details.skill_active)} resolvable=${String(details.resolvable)} catalog_partial=${String(details.catalog_partial)} component_status=${String(details.component_status)}`,
+            ...(details.source_location
+                ? [`source=${String(details.source_location)}`]
+                : []),
+            `resolution_generation=${String(details.resolution_generation)}`,
+            ...(details.rejected_reason
+                ? [`rejected_reason=${String(details.rejected_reason)}`]
+                : []),
+            ...(details.next_actions ?? []).map((action) => `next=${String(action)}`),
+        ];
+        return `\n${lines.join("\n")}`;
+    }
     if (target === "recipes")
         return ToolsResponse.compactRecipeRegistry(details);
+    if (target.startsWith("tool:") && view === "status") {
+        const required = Array.isArray(details.required_args)
+            ? details.required_args.map(String).join(",") || "none"
+            : "unknown";
+        const optional = Array.isArray(details.optional_args)
+            ? details.optional_args.map(String).join(",") || "none"
+            : "unknown";
+        const next = Array.isArray(details.next_actions) && details.next_actions.length > 0
+            ? String(details.next_actions[0])
+            : details.callable_now === true
+                ? `call tool ${target.slice(5)}`
+                : `register_tool name=${target.slice(5)} update=true`;
+        return `\ntool=${target.slice(5)} source=${String(details.source ?? "unknown")} callable_now=${String(details.callable_now ?? false)} activation_boundary=${String(details.activation_boundary ?? "unknown")} required=${required} optional=${optional} launch_kind=${String(details.launch_kind ?? "none")} spawn_calls=${Number(details.spawn_calls ?? 0)} tool_calls=${Number(details.tool_calls ?? 0)} next=${next}`;
+    }
     if (target.startsWith("tool:"))
         return `\ntool=${target.slice(5)} view=${view}`;
     return `\nrun=${target.slice(4)} view=${view}`;
@@ -327,6 +490,7 @@ export function createInspectToolDefinition(deps = {}) {
         label: "Inspect",
         description: "Inspect a Run's Recipe, Trace, or Control evidence, or runtime/recipe/tool diagnostics.",
         parameters: Schema.objectSchema({
+            identity: Schema.stringSchema("Optional canonical <skill>/<recipe> identity for focused Recipe doctor diagnosis."),
             lines: Schema.stringSchema("Bounded item count for Trace or recent Controls."),
             source: Schema.stringSchema("Optional Trace source: all, lifecycle, control, process, agent, artifact, or runtime."),
             status: Schema.stringSchema("Optional runtime Run status filter."),
@@ -343,7 +507,7 @@ export function createInspectToolDefinition(deps = {}) {
                 details = inspectRuntime(view, input, ctx, deps);
             }
             else if (target === "recipes") {
-                details = inspectRecipes(view, deps, ctx);
+                details = inspectRecipes(view, input, deps, ctx);
             }
             else {
                 const run = parseRunTarget(target);

package/dist/lib/tools-local.d.ts

@@ -6,9 +6,9 @@
 import * as ModelContext from "./model-context.ts";
 import type { RegisteredTool } from "./config.ts";
 import * as Execution from "./execution.ts";
-import * as RecipesReferences from "./recipes-references.ts";
+import type * as RecipeResolution from "./recipes-context.ts";
 export interface RuntimeToolContext extends ModelContext.CurrentModelContext {
-    activeSkillRecipeContext?: RecipesReferences.ActiveSkillRecipeContext;
+    recipeResolutionContext?: RecipeResolution.RecipeResolutionContext;
     cwd: string;
     sessionManager?: {
         getSessionId?: () => string;

package/dist/lib/tools-local.js

@@ -44,7 +44,8 @@ function shouldAddRuntimeToolUsageHint(error) {
     return (/^Argument \S+ must /.test(message) || /^Missing .* value: /.test(message));
 }
 function formatRuntimeToolUsageHint(cfg, required, includeRunId) {
-    const optional = cfg.args.filter((arg) => !required.includes(arg));
+    const optional = cfg.args.filter((arg) => !RecipesReferences.isRuntimeOwnedRecipeInput(arg) &&
+        !required.includes(arg));
     const exampleDefaults = {
         ...Schema.getExplicitToolArgDefaults(cfg.recipe?.args),
         ...cfg.defaults,
@@ -115,6 +116,8 @@ export function createRuntimeToolDefinition(cfg, exec) {
             ? new Set(cfg.args.filter((arg) => !Object.hasOwn(cfg.defaults, arg)))
             : Schema.getRequiredToolArgNames(requiredTemplateConfig);
     for (const arg of cfg.args) {
+        if (RecipesReferences.isRuntimeOwnedRecipeInput(arg))
+            continue;
         paramSchema[arg] = typedArgSchema(arg, cfg.argTypes?.[arg]);
         if (requiredArgs.has(arg))
             required.push(arg);
@@ -160,7 +163,7 @@ export function createRuntimeToolDefinition(cfg, exec) {
                         tool: cfg.name,
                         policy_values: ModelContext.withCurrentModelValues({ ...(cfg.recipe?.values ?? {}), ...values }, ctx),
                         values: resolveRecipeToolValues(cfg, values, ctx),
-                    }, ctx.cwd, { skillContext: ctx.activeSkillRecipeContext });
+                    }, ctx.cwd, { skillContext: ctx.recipeResolutionContext?.activeSkills });
                     return {
                         content: [
                             {

package/dist/lib/tools-register.js

@@ -24,7 +24,9 @@ export function createRegisterToolDefinition(deps) {
             args: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.args),
             async: booleanSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.async),
             description: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.description),
+            defaults: looseObjectSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.defaults),
             draft: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.draft),
+            from: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.from),
             name: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.name),
             template: unionSchema([
                 stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.template),
@@ -33,7 +35,6 @@ export function createRegisterToolDefinition(deps) {
                 nullSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.templateNull),
             ]),
             update: booleanSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.update),
-            values: looseObjectSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.values),
         }, []),
         execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => Registry.executeRegisterTool(params, ctx, deps),
     };

package/dist/lib/tools-response.js

@@ -91,6 +91,8 @@ export function compactAsyncRunStatus(value) {
     const result = asRecord(status.result);
     const run = String(status.run ?? "<unknown>");
     const tokens = [`run=${run}`, `status=${String(status.status ?? "unknown")}`];
+    if (status.launch_kind)
+        tokens.push(`launch_kind=${String(status.launch_kind)}`);
     tokens.push(...compactModelPolicy(status.model_policy ?? progress.model_policy));
     if (status.tool)
         tokens.push(`tool=${String(status.tool)}`);
@@ -202,6 +204,9 @@ export function recipeRegistryNextActions(summary, view) {
     if (view === "doctor" && typeof topAction.action === "string") {
         actions.push(String(topAction.action));
     }
+    if (summary.skill_recipe_catalog_partial === true) {
+        actions.push("inspect target=recipes view=imports verbose=true");
+    }
     if (drafts.length > 0) {
         actions.push("inspect target=recipes view=summary verbose=true");
         const firstPath = typeof drafts[0]?.path === "string" ? drafts[0].path : undefined;
@@ -226,12 +231,13 @@ export function compactRecipeRegistry(summary) {
     const recommendations = Array.isArray(summary.recommendations)
         ? summary.recommendations.length
         : 0;
+    const skillCatalogPartial = summary.skill_recipe_catalog_partial === true;
     const currentPolicy = Array.isArray(summary.active)
         ? summary.active.filter((entry) => entry.current_policy).length
         : 0;
     const nextActions = Array.isArray(summary.next_actions)
         ? summary.next_actions
         : [];
-    return `\nrecipes active=${active} drafts=${drafts} shadowed=${shadowed} invalid=${invalid} disabled=${disabled} current_policy=${currentPolicy} recommendations=${recommendations} diagnostics=${diagnostics}${compactNextActions(nextActions)}`;
+    return `\nrecipes active=${active} drafts=${drafts} shadowed=${shadowed} invalid=${invalid} disabled=${disabled} current_policy=${currentPolicy} skill_catalog_partial=${skillCatalogPartial} recommendations=${recommendations} diagnostics=${diagnostics}${compactNextActions(nextActions)}`;
 }
 export const DEFAULT_INSPECT_LINES = Limits.DEFAULT_INSPECT_LINES;

package/dist/lib/tools-spawn.d.ts

@@ -4,9 +4,9 @@
  * Owns the public spawn execution path for run-backed actors
  */
 import * as ModelContext from "./model-context.ts";
-import * as RecipesReferences from "./recipes-references.ts";
+import type * as RecipeResolution from "./recipes-context.ts";
 export interface SpawnToolContext extends ModelContext.CurrentModelContext {
-    activeSkillRecipeContext?: RecipesReferences.ActiveSkillRecipeContext;
+    recipeResolutionContext?: RecipeResolution.RecipeResolutionContext;
     cwd: string;
     sessionManager?: {
         getSessionId?: () => string;

package/dist/lib/tools-spawn.js

@@ -111,7 +111,7 @@ export function createSpawnToolDefinition() {
                         artifacts: input.artifacts,
                     }
                     : {}),
-            }, ctx.cwd, { skillContext: ctx.activeSkillRecipeContext });
+            }, ctx.cwd, { skillContext: ctx.recipeResolutionContext?.activeSkills });
             const draftRecipe = writeSpawnDraftRecipe(input, meta);
             const nextActions = ToolsResponse.runNextActions(meta.run);
             const details = {

package/dist/lib/tools.d.ts

@@ -15,8 +15,11 @@ export interface CoreActorToolDefinitionDeps<TContext extends RuntimeToolContext
     configPath: string;
     getActiveTools: () => string[];
     getRuntimeTool: (name: string) => unknown;
+    getRuntimeToolStatus: (name: string) => Record<string, unknown> | undefined;
     handleRuntimeControl?: (action: string, input: unknown) => Record<string, unknown>;
-    registryRuntime: Pick<RegisterToolRuntimeDeps<TContext>, "getToolNameBlocker" | "getTools" | "notify" | "registerRuntimeTool">;
+    registryRuntime: Pick<RegisterToolRuntimeDeps<TContext>, "getToolNameBlocker" | "getTools" | "notify" | "registerRuntimeTool"> & {
+        getStatus(): import("./runtime.ts").RecipeRegistryStatus;
+    };
     setActiveTools: (toolNames: string[]) => void;
 }
 export declare function resolveActiveRuntimeTool(name: string, activeTools: Pick<Map<string, unknown>, "has">, getDefinition: (name: string) => unknown): unknown;

package/dist/lib/tools.js

@@ -41,6 +41,8 @@ export function createCoreActorToolDefinitions(deps) {
         }),
         ToolsInspect.createInspectToolDefinition({
             getTool: (name) => deps.getRuntimeTool(name),
+            getToolStatus: deps.getRuntimeToolStatus,
+            registryStatus: deps.registryRuntime.getStatus,
         }),
     ];
 }

package/dist/scripts/conformance.mjs

@@ -12,6 +12,7 @@ import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const conformanceSuites = [
+  "tests/agent-journeys.test.ts",
   "tests/control.test.ts",
   "tests/runs-controls.test.ts",
   "tests/runs-trace.test.ts",