@llblab/pi-actors 0.46.0 → 0.46.1

package/lib/registry.ts

@@ -10,9 +10,15 @@ import { dirname, join, relative, resolve } from "node:path";
 import * as CommandTemplates from "./command-templates.ts";
 import * as Config from "./config.ts";
 import * as ExecutionOutput from "./execution-output.ts";
-import { withFileMutationLock, writeJsonAtomic } from "./file-state.ts";
+import {
+  withFileMutationLock,
+  writeJsonAtomic,
+  writeTextAtomic,
+} from "./file-state.ts";
 import * as Identity from "./identity.ts";
 import * as Paths from "./paths.ts";
+import * as RecipesContext from "./recipes-context.ts";
+import * as RecipesDiscovery from "./recipes-discovery.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import * as Schema from "./schema.ts";
 
@@ -28,16 +34,24 @@ export interface RegisterToolInput {
 }
 
 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 {
@@ -56,7 +70,14 @@ export interface RegisterToolRuntimeDeps<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;
 }
@@ -139,8 +160,8 @@ function promoteDraftRecipe<TContext>(
       ),
     );
   }
-  const config = RecipesReferences.readResolvedRecipeConfig(draftPath);
-  if (!config) {
+  const raw = RecipesReferences.readRawRecipeConfig(draftPath);
+  if (!raw) {
     const reason = RecipesReferences.diagnoseRawRecipeConfigFailure(draftPath);
     throw new Error(
       ExecutionOutput.formatToolText(
@@ -148,20 +169,35 @@ function promoteDraftRecipe<TContext>(
       ),
     );
   }
-  const promoted = buildConfig(
-    name,
+  const authoredRecipe = buildAuthoredRecipe(
     {
       ...input,
-      description: input.description ?? config.description,
-      template: 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,
   );
-  const raw = RecipesReferences.readRawRecipeConfig(draftPath)!;
+  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");
@@ -185,18 +221,12 @@ function promoteDraftRecipe<TContext>(
 
 function persistToolRecipe<TContext>(
   deps: RegisterToolRuntimeDeps<TContext>,
-  cfg: Config.RegisteredTool,
+  name: string,
+  recipe: Record<string, unknown>,
 ): string {
-  const path = getToolRecipePath(deps, cfg.name);
+  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;
 }
 
@@ -238,18 +268,27 @@ function deleteTool<TContext>(
 function readAuthoritativeStoredTool<TContext>(
   deps: RegisterToolRuntimeDeps<TContext>,
   name: string,
-): { exists: boolean; tool?: Config.RegisteredTool } {
+): {
+  bytes?: string;
+  exists: boolean;
+  recipe?: Record<string, unknown>;
+  tool?: Config.RegisteredTool;
+} {
   const path = getToolRecipePath(deps, name);
   if (!existsSync(path)) return { exists: false };
   try {
+    const bytes = readFileSync(path, "utf8");
+    const recipe = JSON.parse(bytes);
     const normalized = Config.normalizeStoredTool(
       name,
-      JSON.parse(readFileSync(path, "utf8")),
+      recipe,
       deps.reservedToolNames,
     );
-    if (!normalized.cfg) return { exists: true };
+    if (!normalized.cfg) return { bytes, exists: true, recipe };
     return {
+      bytes,
       exists: true,
+      recipe,
       tool: { ...normalized.cfg, sourcePath: path },
     };
   } catch {
@@ -285,11 +324,31 @@ function getInputTemplate(
   );
 }
 
-function buildConfig(
-  name: string,
+function getRegistrationResolutionContext<TContext>(
+  ctx: TContext,
+  deps: RegisterToolRuntimeDeps<TContext>,
+): RecipesContext.RecipeResolutionContext {
+  if (
+    ctx &&
+    typeof ctx === "object" &&
+    "recipeResolutionContext" in ctx
+  ) {
+    const resolutionContext = (ctx as {
+      recipeResolutionContext?: RecipesContext.RecipeResolutionContext;
+    }).recipeResolutionContext;
+    if (resolutionContext) return resolutionContext;
+  }
+  return RecipesContext.createEmptyRecipeResolutionContext(
+    "offline-register-tool",
+    getRecipeRoot(deps),
+  );
+}
+
+function buildAuthoredRecipe(
   input: RegisterToolInput,
   existing: Config.RegisteredTool | undefined,
-): Config.RegisteredTool {
+  existingRecipe: Record<string, unknown> | undefined,
+): Record<string, unknown> {
   const explicitArgs =
     input.args === undefined
       ? undefined
@@ -311,68 +370,29 @@ function buildConfig(
     );
   }
   const finalTemplate =
-    template === undefined || template === "" ? existing?.template : template;
+    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: RecipesReferences.TemplateRecipeConfig | undefined = 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: CommandTemplates.CommandTemplateConfig =
-    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: Record<string, unknown> = {
+    ...(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<TContext>(
@@ -416,47 +436,118 @@ function executeRegisterToolUnlocked<TContext>(
       ),
     );
   }
-  const cfg = buildConfig(name, input, existing);
-  let recipePath: string;
+  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:
+    | {
+        active_tool: boolean;
+        activation: "current_session" | "unverified";
+        callable_now: boolean;
+        host_registered: boolean;
+      }
+    | undefined;
+  let cfg: Config.RegisteredTool;
   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) {
+    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(
-        `Failed to persist tool recipe: ${error instanceof Error ? error.message : String(error)}`,
+        `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");
+  deps.notify(ctx, `Tool activated: ${name}`, "info");
   const templateWarnings = CommandTemplates.getCommandTemplateWarnings(
-    typeof cfg.template === "object" && !Array.isArray(cfg.template)
-      ? cfg.template
-      : { template: cfg.template! },
+    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}`,
+          `${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/lib/runtime.ts

@@ -10,7 +10,9 @@ import { basename, dirname } from "node:path";
 import * as Config from "./config.ts";
 import type { RegisteredToolExec } from "./execution.ts";
 import * as Paths from "./paths.ts";
+import type { RecipeResolutionContext } from "./recipes-context.ts";
 import * as RecipesDiscovery from "./recipes-discovery.ts";
+import * as RecipesUsage from "./recipes-usage.ts";
 import * as ToolsLocal from "./tools-local.ts";
 
 export interface RuntimeContext {
@@ -20,11 +22,19 @@ export interface RuntimeContext {
   };
 }
 
+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;
@@ -32,16 +42,32 @@ export interface ToolRegistryRuntimeDeps {
   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 {
@@ -55,6 +81,14 @@ export function createAutoToolsRuntime(
   const tools = new Map<string, Config.RegisteredTool>();
   const runtimeToolFingerprints = new Map<string, string>();
   const runtimeTools = new Set<string>();
+  const recipeRoot = deps.recipeRoot ?? Paths.getRecipeRoot();
+  const status: RecipeRegistryStatus = {
+    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: RuntimeContext,
     message: string,
@@ -90,12 +124,30 @@ export function createAutoToolsRuntime(
       deps.getActiveTools().filter((name) => !staleSet.has(name)),
     );
   }
-  function registerRuntimeTool(cfg: Config.RegisteredTool) {
+  function activationFor(name: string): RuntimeToolActivation {
+    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: Config.RegisteredTool): RuntimeToolActivation {
     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: string): boolean {
     if (warning.includes(" shadows ")) return false;
@@ -137,11 +189,18 @@ export function createAutoToolsRuntime(
     }
     return `${lines.join("\n")}\n`;
   }
-  function loadTools(ctx: RuntimeContext) {
+  function loadTools(
+    ctx: RuntimeContext,
+    resolutionContext?: RecipeResolutionContext,
+  ) {
     const warnings: string[] = [];
-    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();
@@ -164,28 +223,59 @@ export function createAutoToolsRuntime(
       }
       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;
+      return {
+        ...activationFor(name),
+        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 interface RecipeToolReloadWatcherDeps {
   exists?: (path: string) => boolean;
+  getResolutionContext?: () => RecipeResolutionContext | undefined;
   recipeRoot?: string;
   watchPath?: typeof watch;
 }
 
 export function createRecipeToolReloadWatcher(
-  runtime: Pick<ToolRegistryRuntime, "loadTools">,
+  runtime: Pick<ToolRegistryRuntime, "loadTools"> &
+    Partial<Pick<ToolRegistryRuntime, "setWatchStatus">>,
   deps: RecipeToolReloadWatcherDeps = {},
 ): RecipeToolReloadWatcher {
   const pathExists = deps.exists ?? existsSync;
@@ -194,6 +284,8 @@ export function createRecipeToolReloadWatcher(
   let rootWatcher: FSWatcher | undefined;
   let parentWatcher: FSWatcher | undefined;
   let failureNotified = false;
+  const setWatchStatus = (watchStatus: RecipeRegistryStatus["watch_status"]): void =>
+    runtime.setWatchStatus?.(watchStatus);
   const close = (): void => {
     const closingRoot = rootWatcher;
     rootWatcher = undefined;
@@ -203,10 +295,12 @@ export function createRecipeToolReloadWatcher(
     closingParent?.close();
     if (reloadTimeout) clearTimeout(reloadTimeout);
     reloadTimeout = undefined;
+    setWatchStatus("closed");
   };
   const notifyFailure = (ctx: RuntimeContext): void => {
     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",
@@ -216,7 +310,7 @@ export function createRecipeToolReloadWatcher(
     failureNotified = false;
     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?.();
@@ -245,6 +339,7 @@ export function createRecipeToolReloadWatcher(
         scheduleReload(ctx);
       });
       parentWatcher = watcher;
+      setWatchStatus("watching_parent");
       watcher.on("error", () => {
         if (parentWatcher !== watcher) return;
         parentWatcher = undefined;
@@ -274,6 +369,7 @@ export function createRecipeToolReloadWatcher(
         scheduleReload(ctx);
       });
       rootWatcher = watcher;
+      setWatchStatus("watching_root");
       watcher.on("error", () => {
         if (rootWatcher !== watcher) return;
         rootWatcher = undefined;