@llblab/pi-actors 0.35.0 → 0.37.0

package/dist/lib/recipes-references.js

@@ -40,19 +40,43 @@ function recipeNameFiles(value) {
         return [trimmed];
     return [`${trimmed}.json`, `${trimmed}.md`];
 }
-function resolveRecipeImportPath(value, currentRecipeRoot) {
+function recipeCandidatePaths(value, currentRecipeRoot) {
     if (!isBareRecipeName(value))
-        return resolveRecipePath(value, currentRecipeRoot);
+        return [resolveRecipePath(value, currentRecipeRoot)];
     const roots = [
         Paths.getRecipeRoot(),
         currentRecipeRoot,
         Paths.getPackagedRecipeRoot(),
     ];
-    const candidates = [
+    return [
         ...new Set(roots.flatMap((root) => recipeNameFiles(value).map((file) => resolve(root, file)))),
     ];
+}
+function resolveRecipeImportPath(value, currentRecipeRoot) {
+    const candidates = recipeCandidatePaths(value, currentRecipeRoot);
     return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
 }
+export function resolveRecipeReferencePath(value, currentRecipeRoot = Paths.getRecipeRoot()) {
+    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;
+}
 export function getRecipePath(value, recipeRoot = Paths.getRecipeRoot()) {
     if (typeof value !== "string")
         return undefined;
@@ -61,20 +85,7 @@ export function getRecipePath(value, recipeRoot = Paths.getRecipeRoot()) {
         return undefined;
     if (trimmed.endsWith(".json") || trimmed.endsWith(".md"))
         return resolveRecipePath(trimmed, recipeRoot);
-    const jsonPath = resolveRecipePath(trimmed, recipeRoot);
-    const mdPath = resolveRecipePath(`${trimmed}.md`, recipeRoot);
-    const path = existsSync(jsonPath) ? jsonPath : mdPath;
-    if (!existsSync(path))
-        return undefined;
-    try {
-        const raw = readRawRecipeConfig(path);
-        return raw && typeof raw === "object" && Object.hasOwn(raw, "template")
-            ? path
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
+    return resolveRecipeReferencePath(trimmed, recipeRoot);
 }
 function isImportNode(value) {
     if (!isRecord(value) || Object.hasOwn(value, "template"))
@@ -344,7 +355,7 @@ export function getRecipeIdFromPath(file) {
     return basename(file, extname(file));
 }
 function readRecipeConfig(value) {
-    const path = getRecipePath(value);
+    const path = resolveRecipeReferencePath(value);
     return path ? readResolvedRecipeConfig(path) : undefined;
 }
 function isRecord(value) {
@@ -483,6 +494,7 @@ function mergeDefaults(...items) {
 function applyDefaultsToTemplate(template, defaults, overrides) {
     const cleanOverrides = { ...overrides };
     delete cleanOverrides.name;
+    delete cleanOverrides.template;
     delete cleanOverrides.values;
     if (typeof template === "object" && !Array.isArray(template)) {
         return {
@@ -509,6 +521,56 @@ function withActorRecipeContext(value, context) {
     }
     return { actorRecipeContext: context, template: value };
 }
+function loadDelegatedRecipe(value, currentRecipeFile, stack, options) {
+    const path = resolveRecipeReferencePath(value, dirname(currentRecipeFile));
+    if (!path)
+        return undefined;
+    const config = readResolvedRecipeConfig(path, [...stack, currentRecipeFile], options);
+    if (!config)
+        throw new Error(`Template recipe must define template: ${path}`);
+    if (config.disabled === true)
+        throw new Error(`Template recipe is disabled: ${path}`);
+    return config;
+}
+function applyDelegatedRecipeToNode(delegated, overrides = {}) {
+    return applyDefaultsToTemplate(delegated.template, delegated.values, overrides);
+}
+function expandRecipeDelegations(value, currentRecipeFile, stack, options = {}) {
+    if (typeof value === "string") {
+        const delegated = loadDelegatedRecipe(value, currentRecipeFile, stack, options);
+        return delegated ? applyDelegatedRecipeToNode(delegated) : value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => expandRecipeDelegations(item, currentRecipeFile, stack, options));
+    }
+    const record = value;
+    if (typeof record.template === "string") {
+        const delegated = loadDelegatedRecipe(record.template, currentRecipeFile, stack, options);
+        if (delegated)
+            return applyDelegatedRecipeToNode(delegated, record);
+    }
+    if (Array.isArray(record.template)) {
+        return {
+            ...record,
+            template: record.template.map((item) => expandRecipeDelegations(item, currentRecipeFile, stack, options)),
+        };
+    }
+    if (record.template && typeof record.template === "object") {
+        return {
+            ...record,
+            template: expandRecipeDelegations(record.template, currentRecipeFile, stack, options),
+        };
+    }
+    return value;
+}
+function getDirectDelegatedRecipe(value, currentRecipeFile, stack, options = {}) {
+    if (typeof value === "string")
+        return loadDelegatedRecipe(value, currentRecipeFile, stack, options);
+    if (!Array.isArray(value) && typeof value.template === "string") {
+        return loadDelegatedRecipe(value.template, currentRecipeFile, stack, options);
+    }
+    return undefined;
+}
 function expandImportNodes(value, imports, options = {}) {
     if (typeof value === "string")
         return value;
@@ -585,7 +647,14 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
     const template = getRecipeCommandTemplate(substituted);
     if (!template)
         return undefined;
-    const expandedTemplate = expandImportNodes(template, imports, options);
+    const expandedImportsTemplate = expandImportNodes(template, imports, options);
+    const delegated = getDirectDelegatedRecipe(expandedImportsTemplate, path, stack, options);
+    const expandedTemplate = delegated
+        ? applyDelegatedRecipeToNode(delegated, typeof expandedImportsTemplate === "object" &&
+            !Array.isArray(expandedImportsTemplate)
+            ? expandedImportsTemplate
+            : {})
+        : expandRecipeDelegations(expandedImportsTemplate, path, stack, options);
     const recipeName = getRecipeIdFromPath(path);
     const templateWithContext = options.includeActorRecipeContext
         ? withActorRecipeContext(expandedTemplate, {
@@ -595,33 +664,50 @@ 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 artifactSource = isRecord(substituted.artifacts)
+        ? substituted.artifacts
+        : delegated?.artifacts;
+    const mailboxSource = isRecord(substituted.mailbox)
+        ? substituted.mailbox
+        : delegated?.mailbox;
     return {
         name: recipeName,
         ...(typeof substituted.description === "string" &&
             substituted.description.trim()
             ? { description: substituted.description.trim() }
-            : {}),
+            : typeof delegated?.description === "string"
+                ? { description: delegated.description }
+                : {}),
         ...(typeof substituted.disabled === "boolean"
             ? { disabled: substituted.disabled }
-            : {}),
+            : typeof delegated?.disabled === "boolean"
+                ? { disabled: delegated.disabled }
+                : {}),
         ...(substituted.async === true
             ? { async: true }
             : substituted.async === false
                 ? { async: false }
-                : {}),
+                : delegated?.async === true
+                    ? { async: true }
+                    : delegated?.async === false
+                        ? { async: false }
+                        : {}),
         ...(typeof substituted.state_dir === "string"
             ? { state_dir: substituted.state_dir }
-            : {}),
+            : typeof delegated?.state_dir === "string"
+                ? { state_dir: delegated.state_dir }
+                : {}),
         ...(Object.keys(imports).length > 0
             ? { imports: getRecipeImports(raw) }
             : {}),
         template: templateWithContext,
         ...(Array.isArray(substituted.args)
             ? { args: substituted.args }
-            : {}),
-        ...(isRecord(substituted.defaults)
-            ? { defaults: substituted.defaults }
-            : {}),
+            : Array.isArray(delegated?.args)
+                ? { args: delegated.args }
+                : {}),
+        ...(mergedDefaults ? { defaults: mergedDefaults } : {}),
         ...(typeof substituted.parallel === "boolean"
             ? { parallel: substituted.parallel }
             : {}),
@@ -643,30 +729,31 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
         ...(typeof substituted.output === "string"
             ? { output: substituted.output }
             : {}),
-        ...(isRecord(substituted.artifacts)
+        ...(isRecord(artifactSource)
             ? {
-                artifacts: Object.fromEntries(Object.entries(substituted.artifacts).filter((entry) => typeof entry[1] === "string")),
+                artifacts: Object.fromEntries(Object.entries(artifactSource).filter((entry) => typeof entry[1] === "string")),
             }
             : {}),
-        ...(isRecord(substituted.mailbox)
+        ...(isRecord(mailboxSource)
             ? {
                 mailbox: {
-                    ...(Array.isArray(substituted.mailbox.accepts)
+                    ...(Array.isArray(mailboxSource.accepts)
                         ? {
-                            accepts: substituted.mailbox.accepts.filter((value) => typeof value === "string" ||
+                            accepts: mailboxSource.accepts.filter((value) => typeof value === "string" ||
                                 (isRecord(value) && typeof value.type === "string")),
                         }
                         : {}),
-                    ...(Array.isArray(substituted.mailbox.emits)
+                    ...(Array.isArray(mailboxSource.emits)
                         ? {
-                            emits: substituted.mailbox.emits.filter((value) => typeof value === "string" ||
+                            emits: mailboxSource.emits.filter((value) => typeof value === "string" ||
                                 (isRecord(value) && typeof value.type === "string")),
                         }
                         : {}),
                 },
             }
             : {}),
-        ...(substituted.retire_when === "children_terminal"
+        ...(substituted.retire_when === "children_terminal" ||
+            delegated?.retire_when === "children_terminal"
             ? { retire_when: "children_terminal" }
             : {}),
         ...(typeof substituted.retry === "number" ||

package/dist/lib/registry.d.ts

@@ -39,7 +39,7 @@ export interface RegisterToolResult {
 export interface RegisterToolRuntimeDeps<TContext> {
     configPath: string;
     recipeRoot?: string;
-    getExternalToolConflict: (name: string) => string | undefined;
+    getToolNameBlocker: (name: string) => string | undefined;
     getTools: () => Map<string, Config.RegisteredTool>;
     getActiveTools: () => string[];
     notify: (ctx: TContext, message: string, type: "info" | "warning" | "error") => void;

package/dist/lib/registry.js

@@ -51,9 +51,9 @@ function promoteDraftRecipe(name, input, ctx, deps) {
     const targetPath = getToolRecipePath(deps, name);
     const tools = deps.getTools();
     const existing = tools.get(name);
-    const conflict = deps.getExternalToolConflict(name);
-    if (conflict)
-        throw new Error(ExecutionOutput.formatToolText(conflict));
+    const blocker = deps.getToolNameBlocker(name);
+    if (blocker)
+        throw new Error(ExecutionOutput.formatToolText(blocker));
     if ((existing || existsSync(targetPath)) && !input.update) {
         throw new Error(ExecutionOutput.formatToolText(`Tool "${name}" already registered. Use update=true to overwrite.`));
     }
@@ -238,9 +238,9 @@ export async function executeRegisterTool(params, ctx, deps) {
         return deleteTool(name, ctx, deps);
     const tools = deps.getTools();
     const existing = tools.get(name);
-    const conflict = deps.getExternalToolConflict(name);
-    if (conflict)
-        throw new Error(ExecutionOutput.formatToolText(conflict));
+    const blocker = deps.getToolNameBlocker(name);
+    if (blocker)
+        throw new Error(ExecutionOutput.formatToolText(blocker));
     if (existing && !input.update) {
         throw new Error(ExecutionOutput.formatToolText(`Tool "${name}" already registered. Use update=true to overwrite.`));
     }

package/dist/lib/runtime-notifier.js

@@ -74,6 +74,7 @@ export function createFileRuntimeNotifier(stateDir, options = {}) {
         subscribe: (actor, onWake, subscribeOptions = {}) => {
             mkdirSync(dirname(file), { recursive: true });
             let position = options.replay || !existsSync(file) ? 0 : statSync(file).size;
+            let pending = "";
             let closed = false;
             const reconcile = (reason) => {
                 if (closed)
@@ -89,11 +90,15 @@ export function createFileRuntimeNotifier(stateDir, options = {}) {
                 if (closed || !existsSync(file))
                     return;
                 const buffer = readFileSync(file);
-                if (position > buffer.length)
+                if (position > buffer.length) {
                     position = 0;
-                const chunk = buffer.subarray(position).toString("utf8");
+                    pending = "";
+                }
+                const chunk = pending + buffer.subarray(position).toString("utf8");
                 position = buffer.length;
-                for (const line of chunk.split("\n")) {
+                const lines = chunk.split("\n");
+                pending = chunk.endsWith("\n") ? "" : (lines.pop() ?? "");
+                for (const line of lines) {
                     if (!line.trim())
                         continue;
                     const event = parseRuntimeWakeEventLine(line);

package/dist/lib/runtime.d.ts

@@ -1,7 +1,7 @@
 /**
  * Tool registry runtime coordinator
  * Zones: runtime coordination, registry loading, pi tools
- * Owns persisted tool loading, conflict detection, runtime registration, and warning notification
+ * Owns persisted tool loading, reserved-name guards, runtime registration, and warning notification
  */
 import * as Config from "./config.ts";
 import type { RegisteredToolExec } from "./execution.ts";
@@ -12,22 +12,18 @@ export interface RuntimeContext {
         notify(message: string, type?: "info" | "warning" | "error"): void;
     };
 }
-export interface ToolInfoLike {
-    name: string;
-}
 export interface ToolRegistryRuntimeDeps {
     configPath: string;
     exec: RegisteredToolExec;
     packagedRecipeRoot?: string;
     recipeRoot?: string;
     getActiveTools?: () => string[];
-    getAllTools: () => ToolInfoLike[];
     registerTool: (definition: ReturnType<typeof ToolsLocal.createRuntimeToolDefinition>) => void;
     reservedToolNames: Set<string>;
     setActiveTools?: (toolNames: string[]) => void;
 }
 export interface ToolRegistryRuntime {
-    getExternalToolConflict(name: string): string | undefined;
+    getToolNameBlocker(name: string): string | undefined;
     getTools(): Map<string, Config.RegisteredTool>;
     loadTools(ctx: RuntimeContext): void;
     notify(ctx: RuntimeContext, message: string, type: "info" | "warning" | "error"): void;

package/dist/lib/runtime.js

@@ -1,7 +1,7 @@
 /**
  * Tool registry runtime coordinator
  * Zones: runtime coordination, registry loading, pi tools
- * Owns persisted tool loading, conflict detection, runtime registration, and warning notification
+ * Owns persisted tool loading, reserved-name guards, runtime registration, and warning notification
  */
 import { existsSync, watch } from "node:fs";
 import * as Paths from "./paths.js";
@@ -15,12 +15,9 @@ export function createAutoToolsRuntime(deps) {
         if (ctx.hasUI)
             ctx.ui.notify(message, type);
     }
-    function getExternalToolConflict(name) {
-        if (runtimeTools.has(name))
-            return undefined;
-        const existing = deps.getAllTools().find((tool) => tool.name === name);
-        return existing
-            ? `Tool "${name}" is already registered outside pi-actors.`
+    function getToolNameBlocker(name) {
+        return deps.reservedToolNames.has(name)
+            ? `Reserved tool name: ${name}`
             : undefined;
     }
     function getToolFingerprint(cfg) {
@@ -55,6 +52,8 @@ export function createAutoToolsRuntime(deps) {
         runtimeToolFingerprints.set(cfg.name, fingerprint);
     }
     function isStartupActionableRegistryWarning(warning) {
+        if (warning.includes(" shadows "))
+            return false;
         if (warning.includes("invokes bash;") &&
             warning.includes("trusted executable content"))
             return false;
@@ -104,9 +103,9 @@ export function createAutoToolsRuntime(deps) {
         }
         deactivateMissingRuntimeTools(new Set(tools.keys()));
         for (const cfg of tools.values()) {
-            const conflict = getExternalToolConflict(cfg.name);
-            if (conflict) {
-                warnings.push(conflict);
+            const blocker = getToolNameBlocker(cfg.name);
+            if (blocker) {
+                warnings.push(blocker);
                 continue;
             }
             registerRuntimeTool(cfg);
@@ -117,7 +116,7 @@ export function createAutoToolsRuntime(deps) {
         }
     }
     return {
-        getExternalToolConflict,
+        getToolNameBlocker,
         getTools: () => tools,
         loadTools,
         notify,

package/dist/lib/tools-inspect.js

@@ -212,6 +212,170 @@ function getPiActorsRuntimeStatus() {
 function compactPiActorsRuntimeStatus(status) {
     return `\npi-actors version=${String(status.version)} mode=${String(status.mode)} path=${String(status.package_root)} entrypoint=${String(status.entrypoint)}${status.git_commit ? ` git=${String(status.git_commit)}` : ""}`;
 }
+function isStaleClaim(message, now) {
+    if (message.status !== "claimed")
+        return false;
+    const claimedAt = Date.parse(String(message.claimed_at ?? ""));
+    return Number.isFinite(claimedAt) && now - claimedAt > 5 * 60 * 1000;
+}
+function getRunTriageSignals(runs) {
+    const now = Date.now();
+    const staleClaims = [];
+    const attentionMessages = [];
+    for (const run of runs) {
+        const stateDir = String(run.state_dir ?? "");
+        const runId = String(run.run ?? "");
+        if (!stateDir)
+            continue;
+        try {
+            for (const message of AsyncRuns.readRunInboxMessages(stateDir, 200)) {
+                if (!isStaleClaim(message, now))
+                    continue;
+                staleClaims.push({
+                    run: runId,
+                    id: message.id,
+                    claimed_at: message.claimed_at,
+                    claimed_by: message.claimed_by,
+                    type: message.type,
+                });
+            }
+        }
+        catch { }
+        try {
+            for (const event of AsyncRuns.readRunEvents(stateDir, 80)) {
+                if (event.metadata?.requires_response !== true)
+                    continue;
+                attentionMessages.push({
+                    run: runId,
+                    id: event.id,
+                    summary: event.summary,
+                    type: event.type ?? event.event,
+                });
+            }
+        }
+        catch { }
+    }
+    return { attention_messages: attentionMessages, stale_claims: staleClaims };
+}
+function isTriageHighRiskRecipe(recipe) {
+    if (recipe.tool !== true)
+        return false;
+    const labels = Array.isArray(recipe.risk_labels)
+        ? recipe.risk_labels.map((label) => String(label))
+        : [];
+    return labels.some((label) => label !== "risk.long_running");
+}
+function getPiActorsTriage(ctx, deps) {
+    const runtime = getPiActorsRuntimeStatus();
+    const currentSession = ToolsAccess.getContextSessionId(ctx);
+    const allRuns = AsyncRuns.listRuns().map((run) => AsyncRuns.getRunStatus(String(run.state_dir)));
+    const visibleRuns = currentSession
+        ? allRuns.filter((run) => !run.ownerId || run.ownerId === currentSession)
+        : allRuns;
+    const activeRuns = visibleRuns.filter((run) => run.status === "running");
+    const failedRuns = visibleRuns.filter((run) => run.status === "failed");
+    const otherRuns = currentSession
+        ? allRuns.filter((run) => run.ownerId && run.ownerId !== currentSession)
+        : [];
+    const recipeRoot = deps.recipeRoot ?? Paths.getRecipeRoot();
+    const discovered = RecipesDiscovery.discoverRecipeSources([
+        { root: recipeRoot, defaultTool: true, mutableUsage: true },
+        { root: deps.packagedRecipeRoot ?? Paths.getPackagedRecipeRoot() },
+    ]);
+    const recipeSummary = {
+        ...RecipesDiscovery.summarizeDiscovery(discovered),
+        drafts: RecipesDiscovery.listDraftRecipes(join(recipeRoot, "drafts")),
+    };
+    const activeRecipes = Array.isArray(recipeSummary.active)
+        ? recipeSummary.active
+        : [];
+    const highRiskRecipes = activeRecipes.filter(isTriageHighRiskRecipe);
+    const signals = getRunTriageSignals(visibleRuns);
+    const attentionMessages = signals.attention_messages;
+    const staleClaims = signals.stale_claims;
+    const invalidRecipes = Array.isArray(recipeSummary.invalid)
+        ? recipeSummary.invalid
+        : [];
+    const remediations = Array.isArray(recipeSummary.remediations)
+        ? recipeSummary.remediations
+        : [];
+    const drafts = Array.isArray(recipeSummary.drafts)
+        ? recipeSummary.drafts
+        : [];
+    const nextActions = [
+        invalidRecipes.length || remediations.length
+            ? "inspect target=recipes view=doctor"
+            : "",
+        drafts.length ? "inspect target=recipes view=summary verbose=true" : "",
+        failedRuns[0]?.run
+            ? `inspect target=run:${String(failedRuns[0].run)} view=tail lines=80`
+            : "",
+        attentionMessages[0]?.run
+            ? `inspect target=run:${String(attentionMessages[0].run)} view=messages`
+            : "",
+        activeRuns.length
+            ? "inspect target=session:all view=runs status=active"
+            : "",
+    ].filter(Boolean);
+    return {
+        runtime,
+        current_session: currentSession ?? null,
+        active_runs: activeRuns.map((run) => ({
+            run: run.run,
+            ownerId: run.ownerId,
+            recipe: run.recipe,
+            status: run.status,
+        })),
+        other_session_runs: otherRuns.length,
+        invalid_recipes: invalidRecipes,
+        blocking_recipes: remediations.filter((item) => String(item.kind ?? "").startsWith("blocking_")),
+        high_risk_recipes: highRiskRecipes.map((recipe) => ({
+            id: recipe.id,
+            path: recipe.path,
+            risk_labels: recipe.risk_labels,
+        })),
+        draft_recipes: drafts,
+        stale_claims: staleClaims,
+        recent_failed_runs: failedRuns.slice(0, 5).map((run) => ({
+            run: run.run,
+            recipe: run.recipe,
+            status: run.status,
+        })),
+        attention_messages: attentionMessages.slice(-10),
+        next_actions: [...new Set(nextActions)].slice(0, 5),
+    };
+}
+function compactPiActorsTriage(summary) {
+    const runtime = asRecord(summary.runtime);
+    const activeRuns = Array.isArray(summary.active_runs)
+        ? summary.active_runs.length
+        : 0;
+    const invalidRecipes = Array.isArray(summary.invalid_recipes)
+        ? summary.invalid_recipes.length
+        : 0;
+    const blockingRecipes = Array.isArray(summary.blocking_recipes)
+        ? summary.blocking_recipes.length
+        : 0;
+    const highRiskRecipes = Array.isArray(summary.high_risk_recipes)
+        ? summary.high_risk_recipes.length
+        : 0;
+    const drafts = Array.isArray(summary.draft_recipes)
+        ? summary.draft_recipes.length
+        : 0;
+    const staleClaims = Array.isArray(summary.stale_claims)
+        ? summary.stale_claims.length
+        : 0;
+    const failedRuns = Array.isArray(summary.recent_failed_runs)
+        ? summary.recent_failed_runs.length
+        : 0;
+    const attention = Array.isArray(summary.attention_messages)
+        ? summary.attention_messages.length
+        : 0;
+    const nextActions = Array.isArray(summary.next_actions)
+        ? summary.next_actions
+        : [];
+    return `\ntriage version=${String(runtime.version ?? "unknown")} mode=${String(runtime.mode ?? "unknown")} active_runs=${activeRuns} other_runs=${String(summary.other_session_runs ?? 0)} invalid_recipes=${invalidRecipes} blocking_recipes=${blockingRecipes} high_risk_recipes=${highRiskRecipes} drafts=${drafts} stale_claims=${staleClaims} failed_runs=${failedRuns} attention=${attention}${ToolsResponse.compactNextActions(nextActions)}`;
+}
 function compactToolActor(name, tool) {
     const parameters = asRecord(tool.parameters);
     const required = Array.isArray(parameters.required)
@@ -314,15 +478,19 @@ export function createInspectToolDefinition(deps = {}) {
             }
             if (address.kind === "tool" && address.value) {
                 if (address.value === "pi-actors") {
-                    if (view !== "status") {
-                        throw new Error("inspect tool:pi-actors supports view=status.");
+                    if (view !== "status" && view !== "triage") {
+                        throw new Error("inspect tool:pi-actors supports view=status or view=triage.");
                     }
-                    const details = getPiActorsRuntimeStatus();
+                    const details = view === "triage"
+                        ? getPiActorsTriage(ctx, deps)
+                        : getPiActorsRuntimeStatus();
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: maybeJsonText(details, input.verbose === true, compactPiActorsRuntimeStatus(details)),
+                                text: maybeJsonText(details, input.verbose === true, view === "triage"
+                                    ? compactPiActorsTriage(details)
+                                    : compactPiActorsRuntimeStatus(details)),
                             },
                         ],
                         details,

package/dist/lib/tools-response.js

@@ -143,15 +143,23 @@ export function compactRecipeDoctor(summary) {
     const recommendations = Array.isArray(summary.recommendations)
         ? summary.recommendations
         : [];
+    const riskSummary = Array.isArray(summary.risk_summary)
+        ? summary.risk_summary
+        : [];
     const counts = { error: 0, info: 0, warning: 0 };
     for (const detail of details) {
         const severity = String(detail.severity ?? "info");
         if (severity === "error" || severity === "warning" || severity === "info")
             counts[severity] += 1;
     }
+    const riskCount = riskSummary.reduce((total, item) => total + Number(item.count ?? 0), 0);
+    const topRisks = riskSummary
+        .slice(0, 4)
+        .map((item) => `${String(item.label)}:${String(item.count ?? 0)}`)
+        .join(",");
     const topAction = asRecord(summary.top_action);
     const lines = [
-        `recipes doctor errors=${counts.error} warnings=${counts.warning} info=${counts.info} actions=${remediations.length} recommendations=${recommendations.length}`,
+        `recipes doctor errors=${counts.error} warnings=${counts.warning} info=${counts.info} actions=${remediations.length} recommendations=${recommendations.length} risks=${riskCount}${topRisks ? ` top_risks=${topRisks}` : ""}`,
     ];
     if (Object.keys(topAction).length > 0) {
         const action = compactPreview(topAction.action, Limits.DOCTOR_ACTION_PREVIEW_CHARS);
@@ -162,7 +170,10 @@ export function compactRecipeDoctor(summary) {
         const blocked = item.blocked_fallback
             ? ` blocked=${compactPreview(item.blocked_fallback, Limits.DOCTOR_ACTION_PREVIEW_CHARS)}`
             : "";
-        lines.push(`${String(item.severity ?? "info")} kind=${String(item.kind ?? "inspect")} id=${String(item.id ?? "root")}${blocked} action=${action ?? "inspect"}`);
+        const labels = Array.isArray(item.risk_labels)
+            ? ` labels=${item.risk_labels.map(String).slice(0, 4).join(",")}`
+            : "";
+        lines.push(`${String(item.severity ?? "info")} kind=${String(item.kind ?? "inspect")} id=${String(item.id ?? "root")}${blocked}${labels} action=${action ?? "inspect"}`);
     }
     const nextActions = Array.isArray(summary.next_actions)
         ? summary.next_actions

package/dist/lib/tools.d.ts

@@ -15,7 +15,7 @@ export interface CoreActorToolDefinitionDeps<TContext extends RuntimeToolContext
     configPath: string;
     getActiveTools: () => string[];
     getRuntimeTool: (name: string) => unknown;
-    registryRuntime: Pick<RegisterToolRuntimeDeps<TContext>, "getExternalToolConflict" | "getTools" | "notify" | "registerRuntimeTool">;
+    registryRuntime: Pick<RegisterToolRuntimeDeps<TContext>, "getToolNameBlocker" | "getTools" | "notify" | "registerRuntimeTool">;
     setActiveTools: (toolNames: string[]) => void;
 }
 export declare const RESERVED_TOOL_NAMES: Set<string>;

package/dist/lib/tools.js

@@ -25,7 +25,7 @@ export function createCoreActorToolDefinitions(deps) {
         ToolsRegister.createRegisterToolDefinition({
             configPath: deps.configPath,
             getActiveTools: deps.getActiveTools,
-            getExternalToolConflict: deps.registryRuntime.getExternalToolConflict,
+            getToolNameBlocker: deps.registryRuntime.getToolNameBlocker,
             getTools: deps.registryRuntime.getTools,
             notify: deps.registryRuntime.notify,
             registerRuntimeTool: deps.registryRuntime.registerRuntimeTool,