@llblab/pi-actors 0.46.0 → 0.46.1

package/lib/tools-inspect.ts

@@ -5,7 +5,7 @@
  */
 
 import { statSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, relative } from "node:path";
 
 import * as AsyncRuns from "./async-runs.ts";
 import * as ControlProjection from "./control-projection.ts";
@@ -13,12 +13,14 @@ import * as Inspector from "./inspector.ts";
 import * as Limits from "./limits.ts";
 import { computeRunControlCapacity } from "./run-evidence-policy.ts";
 import * as Paths from "./paths.ts";
+import type * as RecipeResolution from "./recipes-context.ts";
 import * as RecipesDiscovery from "./recipes-discovery.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import * as ReviewDiagnostics from "./review-diagnostics.ts";
 import * as RunsControls from "./runs-controls.ts";
 import * as RunControlDelivery from "./runs-control-delivery.ts";
 import * as RunsTrace from "./runs-trace.ts";
+import * as Runtime from "./runtime.ts";
 import * as RuntimeIdentity from "./runtime-identity.ts";
 import * as RuntimeTriage from "./runtime-triage.ts";
 import * as Schema from "./schema.ts";
@@ -32,8 +34,10 @@ const maybeJsonText = ToolsResponse.maybeJsonText;
 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;
 }
 
 function runtimeStatus(): Record<string, unknown> {
@@ -191,6 +195,19 @@ function inspectRuntime(
   throw new Error("inspect runtime supports view=status, view=runs, or view=triage.");
 }
 
+function portableSkillRecipePath(
+  file: string,
+  skill: string,
+  namespaces: Record<string, string[]>,
+): string {
+  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 inspectRecipes(
   view: string,
   deps: InspectToolDeps,
@@ -214,37 +231,52 @@ function inspectRecipes(
   const discovered = RecipesDiscovery.discoverRecipeSources([
     { root: recipeRoot, defaultTool: true, mutableUsage: true },
   ]);
-  const skillContext =
-    context && typeof context === "object" && "activeSkillRecipeContext" in context
+  const resolutionContext =
+    context && typeof context === "object" && "recipeResolutionContext" in context
       ? (context as {
-          activeSkillRecipeContext?: RecipesReferences.ActiveSkillRecipeContext;
-        }).activeSkillRecipeContext
+          recipeResolutionContext?: RecipeResolution.RecipeResolutionContext;
+        }).recipeResolutionContext
       : undefined;
   const activeSkillContext =
-    skillContext ?? RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT;
+    resolutionContext?.activeSkills ??
+    RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT;
   const skillRecipeNamespaces = RecipesReferences.getActiveSkillRecipeNamespaces(
     activeSkillContext,
   );
-  let skillRecipeComponents: Array<Record<string, unknown>> = [];
-  const skillRecipeComponentDiagnostics: Array<Record<string, unknown>> = [];
-  try {
-    skillRecipeComponents = RecipesReferences.listActiveSkillRecipeComponents(
-      activeSkillContext,
-    ).map((component) => ({
-      identity: component.identity,
-      source_kind: "active_skill_component",
-      skill: component.skill,
-      stem: component.stem,
-      imports: component.imports,
-    }));
-  } catch (error) {
-    skillRecipeComponentDiagnostics.push({
-      error: error instanceof Error ? error.message : String(error),
-    });
-  }
+  const skillInventory =
+    RecipesReferences.inventoryActiveSkillRecipeComponents(activeSkillContext);
+  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: diagnostic.reason,
+      ...(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,
+    ...(deps.registryStatus
+      ? {
+          ...deps.registryStatus(),
+          watched_root: "~/.pi/agent/recipes",
+        }
+      : {}),
     active: Array.isArray(discoverySummary.active)
       ? discoverySummary.active.map((entry) => ({
           ...(entry as Record<string, unknown>),
@@ -253,6 +285,7 @@ function inspectRecipes(
       : 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)
@@ -369,6 +402,7 @@ function inspectTool(
   if (!tool) throw new Error(`registered tool not found: ${name}`);
   return {
     name,
+    ...(view === "status" ? deps.getToolStatus?.(name) : {}),
     description: tool.description,
     parameters: tool.parameters,
     promptSnippet: tool.promptSnippet,

package/lib/tools-local.ts

@@ -10,6 +10,7 @@ import * as ModelContext from "./model-context.ts";
 import type { RegisteredTool } from "./config.ts";
 import * as Execution from "./execution.ts";
 import * as Prompts from "./prompts.ts";
+import type * as RecipeResolution from "./recipes-context.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import * as RecipesUsage from "./recipes-usage.ts";
 import * as Schema from "./schema.ts";
@@ -18,7 +19,7 @@ import * as ToolsResponse from "./tools-response.ts";
 type JsonSchema = Schema.JsonSchema;
 
 export interface RuntimeToolContext extends ModelContext.CurrentModelContext {
-  activeSkillRecipeContext?: RecipesReferences.ActiveSkillRecipeContext;
+  recipeResolutionContext?: RecipeResolution.RecipeResolutionContext;
   cwd: string;
   sessionManager?: { getSessionId?: () => string };
 }
@@ -67,7 +68,11 @@ function formatRuntimeToolUsageHint(
   required: string[],
   includeRunId: boolean,
 ): string {
-  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,
@@ -176,6 +181,7 @@ export function createRuntimeToolDefinition(
         ? 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);
   }
@@ -244,7 +250,7 @@ export function createRuntimeToolDefinition(
               values: resolveRecipeToolValues(cfg, values, ctx),
             },
             ctx.cwd,
-            { skillContext: ctx.activeSkillRecipeContext },
+            { skillContext: ctx.recipeResolutionContext?.activeSkills },
           );
           return {
             content: [

package/lib/tools-response.ts

@@ -106,6 +106,8 @@ export function compactAsyncRunStatus(value: unknown): string {
   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)}`);
   if (status.recipe) tokens.push(`recipe=${String(status.recipe)}`);

package/lib/tools-spawn.ts

@@ -11,13 +11,14 @@ import * as AsyncRuns from "./async-runs.ts";
 import { withFileMutationLock } from "./file-state.ts";
 import * as ModelContext from "./model-context.ts";
 import * as Paths from "./paths.ts";
+import type * as RecipeResolution from "./recipes-context.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import * as RecipesUsage from "./recipes-usage.ts";
 import * as Schema from "./schema.ts";
 import * as ToolsResponse from "./tools-response.ts";
 
 export interface SpawnToolContext extends ModelContext.CurrentModelContext {
-  activeSkillRecipeContext?: RecipesReferences.ActiveSkillRecipeContext;
+  recipeResolutionContext?: RecipeResolution.RecipeResolutionContext;
   cwd: string;
   sessionManager?: { getSessionId?: () => string };
 }
@@ -184,7 +185,7 @@ export function createSpawnToolDefinition<
             : {}),
         },
         ctx.cwd,
-        { skillContext: ctx.activeSkillRecipeContext },
+        { skillContext: ctx.recipeResolutionContext?.activeSkills },
       );
       const draftRecipe = writeSpawnDraftRecipe(input, meta);
       const nextActions = ToolsResponse.runNextActions(meta.run);

package/lib/tools.ts

@@ -25,6 +25,7 @@ export interface CoreActorToolDefinitionDeps<
   configPath: string;
   getActiveTools: () => string[];
   getRuntimeTool: (name: string) => unknown;
+  getRuntimeToolStatus: (name: string) => Record<string, unknown> | undefined;
   handleRuntimeControl?: (
     action: string,
     input: unknown,
@@ -32,7 +33,7 @@ export interface CoreActorToolDefinitionDeps<
   registryRuntime: Pick<
     RegisterToolRuntimeDeps<TContext>,
     "getToolNameBlocker" | "getTools" | "notify" | "registerRuntimeTool"
-  >;
+  > & { getStatus(): import("./runtime.ts").RecipeRegistryStatus };
   setActiveTools: (toolNames: string[]) => void;
 }
 
@@ -78,6 +79,8 @@ export function createCoreActorToolDefinitions<
     }),
     ToolsInspect.createInspectToolDefinition<TContext>({
       getTool: (name) => deps.getRuntimeTool(name),
+      getToolStatus: deps.getRuntimeToolStatus,
+      registryStatus: deps.registryRuntime.getStatus,
     }),
   ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-actors",
-  "version": "0.46.0",
+  "version": "0.46.1",
   "private": false,
   "description": "Local Actor Kernel for Pi",
   "keywords": [

package/skills/actors/SKILL.md

@@ -19,9 +19,9 @@ Use the swarm skill separately for decomposition, quorum design, reviewer lenses
 - `spawn`: create one Run from a Recipe or inline command template.
 - `message`: send one actor-local Control to `run:<id>`, or the reserved review actions to `runtime`.
 - `inspect`: inspect `run:<id>`, `runtime`, `recipes`, or `tool:<name>`.
-- `register_tool`: persist a trusted capability; it does not address a running actor.
+- `register_tool`: persist a trusted capability; it does not address a running actor. Trust current-session callability only when its result says `callable_now: true`.
 
-A Run target exposes exactly three inspect views: `recipe`, `trace`, and `control`.
+A Run target exposes exactly three inspect views: `recipe`, `trace`, and `control`. Spawning a user Recipe is still a Recipe launch (`launch_kind: "spawn"`), not evidence that its registered tool was exposed or invoked; registered-tool execution reports `launch_kind: "tool"`, and `inspect target=tool:<name> view=status` separates both usage counts.
 
 ## Recipe
 
@@ -29,7 +29,7 @@ A Recipe defines execution. It may declare named typed args, inline fallbacks, c
 
 Do not declare Control for ordinary one-shot work. Runtime lifecycle actions such as `kill` stay runtime-owned and must not appear in Recipe Control declarations. Imported Recipes act as local definitions inside one Run; they do not create nested Runs unless execution explicitly spawns them.
 
-Prefer maintained Skill-owned Recipes over ad hoc wrappers. Skill Recipe identity is `<active Skill name>/<Recipe filename stem>`; Recipe files have no top-level `name`. `SKILL.md` `name` is Pi host metadata matching its directory, not an additional pi-actors identity field. Use `<skill>/<recipe>` for an exact direct component or an explicit `.json` / `.md` path. Entry paths resolve from invocation `cwd`; relative imports resolve from the importing Recipe directory. File-backed Recipes own `{recipe_dir}` and Skill Recipes own `{skill_dir}`; callers never pass or override these origins. Skill Recipes are components, not automatic tools. Keep model, thinking, mission, concurrency, quorum, and timeout choices caller-owned unless a Recipe documents a stable policy.
+Prefer maintained Skill-owned Recipes over ad hoc wrappers. Skill Recipe identity is `<active Skill name>/<Recipe filename stem>`; Recipe files have no top-level `name`. `SKILL.md` `name` is Pi host metadata matching its directory, not an additional pi-actors identity field. Use `<skill>/<recipe>` for an exact direct component or an explicit `.json` / `.md` path. Entry paths resolve from invocation `cwd`; relative imports resolve from the importing Recipe directory. File-backed Recipes own `{recipe_dir}` and Skill Recipes own `{skill_dir}`; callers never pass or override these origins. Skill Recipes are components, not automatic tools. A rejected component makes catalog inspection partial without blocking exact resolution of unrelated valid components in the same live session context. Keep model, thinking, mission, concurrency, quorum, and timeout choices caller-owned unless a Recipe documents a stable policy.
 
 ## Trace