@llblab/pi-kit 0.1.0

package/node_modules/@llblab/pi-actors/dist/lib/tools-local.js

@@ -0,0 +1,191 @@
+/**
+ * Local tool definition behavior
+ * Zones: user recipe tools, generated schemas, async recipe launch
+ * Owns wrapping saved local capabilities as executable pi tools
+ */
+import * as AsyncRuns from "./async-runs.js";
+import * as ModelContext from "./model-context.js";
+import * as Execution from "./execution.js";
+import * as Prompts from "./prompts.js";
+import * as RecipesReferences from "./recipes-references.js";
+import * as RecipesUsage from "./recipes-usage.js";
+import * as Schema from "./schema.js";
+import * as ToolsResponse from "./tools-response.js";
+function getRunOwnerId(ctx) {
+    return ctx.sessionManager?.getSessionId?.();
+}
+function typedArgSchema(arg, type) {
+    const description = !type || type.kind === "string"
+        ? `Argument: ${arg}`
+        : type.kind === "path"
+            ? `Path argument: ${arg}`
+            : `${type.kind[0].toUpperCase()}${type.kind.slice(1)} argument: ${arg}`;
+    return Schema.typedArgSchema(description, type);
+}
+function sampleValueForArg(arg, type, defaults) {
+    if (Object.hasOwn(defaults, arg))
+        return defaults[arg];
+    if (!type || type.kind === "string")
+        return `<${arg}>`;
+    if (type.kind === "path")
+        return `./${arg}`;
+    if (type.kind === "int")
+        return 1;
+    if (type.kind === "number")
+        return 1.5;
+    if (type.kind === "bool")
+        return true;
+    if (type.kind === "array")
+        return [`<${arg}>`];
+    return type.values[0] ?? `<${arg}>`;
+}
+function shouldAddRuntimeToolUsageHint(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return (/^Argument \S+ must /.test(message) || /^Missing .* value: /.test(message));
+}
+function formatRuntimeToolUsageHint(cfg, required, includeRunId) {
+    const optional = cfg.args.filter((arg) => !RecipesReferences.isRuntimeOwnedRecipeInput(arg) &&
+        !required.includes(arg));
+    const exampleDefaults = {
+        ...Schema.getExplicitToolArgDefaults(cfg.recipe?.args),
+        ...cfg.defaults,
+        ...(cfg.recipe?.values ?? {}),
+    };
+    const example = {};
+    for (const arg of required)
+        example[arg] = sampleValueForArg(arg, cfg.argTypes?.[arg], exampleDefaults);
+    for (const arg of optional)
+        example[arg] = sampleValueForArg(arg, cfg.argTypes?.[arg], exampleDefaults);
+    if (includeRunId)
+        example.run_id = `${cfg.name}-1`;
+    const lines = [
+        `Expected call shape for ${cfg.name}:`,
+        `${cfg.name}(${JSON.stringify(example, null, 2)})`,
+    ];
+    if (required.length)
+        lines.push(`Required: ${required.join(", ")}`);
+    if (optional.length || includeRunId)
+        lines.push(`Optional: ${[...optional, ...(includeRunId ? ["run_id"] : [])].join(", ")}`);
+    return lines.join("\n");
+}
+function resolveRecipeToolValues(cfg, callerValues, ctx) {
+    const recipeRuntimeValues = {
+        ...(cfg.recipe?.recipe_dir
+            ? { recipe_dir: cfg.recipe.recipe_dir }
+            : {}),
+        ...(cfg.recipe?.skill_dir ? { skill_dir: cfg.recipe.skill_dir } : {}),
+    };
+    return Schema.normalizeRuntimeValues(ModelContext.withCurrentModelValues({
+        ...Schema.getExplicitToolArgDefaults(cfg.recipe?.args),
+        ...cfg.defaults,
+        ...(cfg.recipe?.values ?? {}),
+        ...callerValues,
+        ...recipeRuntimeValues,
+    }, ctx), cfg.argTypes);
+}
+function formatRuntimeToolArgumentError(cfg, error, required, includeRunId) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!shouldAddRuntimeToolUsageHint(error))
+        return error instanceof Error ? error : new Error(message);
+    return new Error(`Invalid arguments for tool "${cfg.name}": ${message}\n\n${formatRuntimeToolUsageHint(cfg, required, includeRunId)}`);
+}
+export function createRuntimeToolDefinition(cfg, exec) {
+    const paramSchema = {};
+    const required = [];
+    const isRecipe = RecipesReferences.isRecipeTool(cfg.template, cfg.recipe);
+    const isAsyncRecipe = cfg.recipe
+        ? cfg.recipe.async === true
+        : RecipesReferences.isAsyncRecipeReference(cfg.template);
+    const isSingletonRecipe = cfg.recipe?.singleton === true;
+    const recipeTemplate = cfg.recipe?.template ?? RecipesReferences.getRecipeTemplate(cfg.template);
+    const requiredTemplate = recipeTemplate ?? cfg.template;
+    const requiredTemplateConfig = typeof requiredTemplate === "object" && !Array.isArray(requiredTemplate)
+        ? {
+            ...requiredTemplate,
+            args: cfg.args,
+            defaults: { ...(requiredTemplate.defaults ?? {}), ...cfg.defaults },
+        }
+        : {
+            args: cfg.args,
+            defaults: cfg.defaults,
+            template: requiredTemplate,
+        };
+    const recipeInlineDefaults = Schema.getExplicitToolArgDefaults(cfg.recipe?.args);
+    const requiredArgs = isRecipe && cfg.storedArgs !== undefined
+        ? new Set(cfg.args.filter((arg) => !Object.hasOwn(cfg.defaults, arg) &&
+            !Object.hasOwn(recipeInlineDefaults, arg)))
+        : !cfg.recipe && RecipesReferences.isRecipeReference(cfg.template) && !recipeTemplate
+            ? 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);
+    }
+    if (isAsyncRecipe && !isSingletonRecipe)
+        paramSchema.run_id = Schema.stringSchema("Optional run id override for this async template recipe invocation.");
+    if (isAsyncRecipe) {
+        paramSchema.transport_context = Schema.looseObjectSchema("Optional originating transport route preserved for detached terminal follow-up.");
+    }
+    return {
+        name: cfg.name,
+        label: cfg.name,
+        description: cfg.description,
+        parameters: Schema.objectSchema(paramSchema, required),
+        promptSnippet: isRecipe
+            ? Prompts.formatRecipeToolPromptSnippet(cfg.recipe?.name ?? String(cfg.template), isAsyncRecipe)
+            : Prompts.formatRegisteredToolPromptSnippet(cfg.template),
+        async execute(toolCallId, params, signal, _onUpdate, ctx) {
+            try {
+                if (cfg.sourcePath &&
+                    !RecipesUsage.recordRecipeLaunch(cfg.sourcePath, new Date(), "tool")) {
+                    throw new Error(`Recipe launch rejected because its source changed during activation: ${cfg.sourcePath}. Reload recipe tools and retry.`);
+                }
+                if (isAsyncRecipe) {
+                    const input = params;
+                    const { run_id, transport_context, ...values } = input;
+                    const base = cfg.recipe ? cfg.recipe : { file: String(cfg.template) };
+                    const runId = isSingletonRecipe
+                        ? undefined
+                        : typeof run_id === "string" && run_id.trim()
+                            ? run_id.trim()
+                            : `${cfg.name}-${Date.now()}`;
+                    const meta = AsyncRuns.startRun({
+                        ...base,
+                        launch_source: "tool",
+                        launch_correlation: { tool_call_id: toolCallId },
+                        ...(transport_context &&
+                            typeof transport_context === "object" &&
+                            !Array.isArray(transport_context)
+                            ? {
+                                transport_context: transport_context,
+                            } : {}),
+                        ownerId: getRunOwnerId(ctx),
+                        run_id: runId,
+                        tool: cfg.name,
+                        policy_values: ModelContext.withCurrentModelValues({ ...(cfg.recipe?.values ?? {}), ...values }, ctx),
+                        values: resolveRecipeToolValues(cfg, values, ctx),
+                    }, ctx.cwd, { skillContext: ctx.recipeResolutionContext?.activeSkills });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: ToolsResponse.compactAsyncRunStatus(meta),
+                            },
+                        ],
+                        details: meta,
+                    };
+                }
+                if (isRecipe && recipeTemplate) {
+                    return await Execution.executeRegisteredTool({ ...cfg, template: recipeTemplate }, resolveRecipeToolValues(cfg, params, ctx), exec, ctx.cwd, signal);
+                }
+                return await Execution.executeRegisteredTool(cfg, Schema.normalizeRuntimeValues(ModelContext.withCurrentModelValues(params, ctx), cfg.argTypes), exec, ctx.cwd, signal);
+            }
+            catch (error) {
+                throw formatRuntimeToolArgumentError(cfg, error, required, isAsyncRecipe && !isSingletonRecipe);
+            }
+        },
+    };
+}

package/node_modules/@llblab/pi-actors/dist/lib/tools-message.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Public Control facade under the stable `message` tool name.
+ * Zones: Control request validation, Run/runtime dispatch, compact receipts
+ * Owns public Control execution; journaling, delivery, and lifecycle mutation stay in Run domains.
+ */
+export interface ControlToolDeps {
+    handleRuntimeControl?: (action: string, input: unknown) => Record<string, unknown>;
+}
+export declare function createControlToolDefinition<TContext = unknown>(deps?: ControlToolDeps): any;

package/node_modules/@llblab/pi-actors/dist/lib/tools-message.js

@@ -0,0 +1,139 @@
+/**
+ * Public Control facade under the stable `message` tool name.
+ * Zones: Control request validation, Run/runtime dispatch, compact receipts
+ * Owns public Control execution; journaling, delivery, and lifecycle mutation stay in Run domains.
+ */
+import * as AsyncRuns from "./async-runs.js";
+import * as Control from "./control.js";
+import * as Schema from "./schema.js";
+import * as ToolsAccess from "./tools-access.js";
+import * as ToolsResponse from "./tools-response.js";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function compactControlResult(request, result) {
+    const tokens = [
+        `target=${request.target}`,
+        `action=${request.action}`,
+        `status=${String(result.delivery ?? result.status ?? (result.stopped === true ? "handled" : "accepted"))}`,
+    ];
+    if (result.control_id)
+        tokens.push(`control=${String(result.control_id)}`);
+    if (result.reason)
+        tokens.push(`reason=${String(result.reason).replaceAll(/\s+/g, "_")}`);
+    if (Array.isArray(result.next_actions) && result.next_actions.length > 0) {
+        tokens.push(`next=${result.next_actions
+            .map((action) => action.replaceAll(/\s+/g, "_"))
+            .join("|")}`);
+    }
+    return `\n${tokens.join(" ")}`;
+}
+function runNextActions(run, result) {
+    if (result.delivery === "queued" || result.delivery === "delivered") {
+        return [`inspect target=run:${run} view=control`];
+    }
+    if (result.stopped === true)
+        return [`inspect target=run:${run} view=control`];
+    return [];
+}
+export function createControlToolDefinition(deps = {}) {
+    return {
+        name: "message",
+        label: "Control",
+        description: "Apply one Control action to an existing Run or the pi-actors runtime.",
+        parameters: Schema.objectSchema({
+            target: Schema.stringSchema("Run target run:<id>, or literal runtime."),
+            action: Schema.stringSchema("Lowercase ASCII Control action, at most 64 characters."),
+            input: Schema.unionSchema([
+                Schema.stringSchema("Optional Control input string; serialized JSON must fit 380 bytes."),
+                Schema.looseObjectSchema("Optional structured Control input; serialized JSON must fit 380 bytes."),
+                Schema.arraySchema("Optional structured Control input array; serialized JSON must fit 380 bytes."),
+            ]),
+            verbose: Schema.booleanSchema("Return full JSON instead of compact text."),
+        }, ["target", "action"]),
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const request = Control.normalizeControlRequest(params);
+            let result;
+            if (request.target === "runtime") {
+                if (request.action !== "review.retry" && request.action !== "review.reset") {
+                    throw new Error(`unsupported runtime Control action: ${request.action}; use review.retry or review.reset`);
+                }
+                if (!deps.handleRuntimeControl) {
+                    throw new Error("runtime Control is unavailable");
+                }
+                result = deps.handleRuntimeControl(request.action, request.input);
+            }
+            else {
+                const run = request.target.slice(4);
+                const status = ToolsAccess.assertRunAccessibleToContext(run, ctx);
+                const runInstanceId = typeof status.run_instance_id === "string"
+                    ? status.run_instance_id
+                    : undefined;
+                if (!runInstanceId)
+                    throw new Error(`Run generation unavailable: ${run}`);
+                if (request.action === "kill") {
+                    result = AsyncRuns.killRun(run, {
+                        ...(typeof status.ownerId === "string"
+                            ? { ownerId: status.ownerId }
+                            : {}),
+                        runInstanceId,
+                    });
+                }
+                else if (request.action === "archive") {
+                    result = AsyncRuns.archiveRun(run, {
+                        ...(typeof status.ownerId === "string"
+                            ? { ownerId: status.ownerId }
+                            : {}),
+                        runInstanceId,
+                    });
+                }
+                else if (request.action === "prune") {
+                    const input = asRecord(request.input);
+                    result = AsyncRuns.pruneRun(run, {
+                        preserveArtifacts: input.preserve_artifacts === true ||
+                            input.preserveArtifacts === true,
+                    }, {
+                        ...(typeof status.ownerId === "string"
+                            ? { ownerId: status.ownerId }
+                            : {}),
+                        runInstanceId,
+                    });
+                }
+                else {
+                    const declared = Array.isArray(status.control)
+                        ? status.control.filter((action) => typeof action === "string")
+                        : [];
+                    if (!declared.includes(request.action)) {
+                        throw new Error(`undeclared Run Control action: ${request.action}; available=${declared.join(",") || "none"}`);
+                    }
+                    result = await AsyncRuns.sendRunControl(run, {
+                        action: request.action,
+                        ...(request.input !== undefined ? { input: request.input } : {}),
+                        run_instance_id: runInstanceId,
+                    }, {
+                        ...(typeof status.ownerId === "string"
+                            ? { ownerId: status.ownerId }
+                            : {}),
+                    });
+                }
+                const nextActions = runNextActions(run, result);
+                if (nextActions.length > 0)
+                    result = { ...result, next_actions: nextActions };
+            }
+            const response = { control: request, result };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: request.verbose === true
+                            ? ToolsResponse.jsonText(response)
+                            : compactControlResult(request, result),
+                    },
+                ],
+                details: response,
+            };
+        },
+    };
+}

package/node_modules/@llblab/pi-actors/dist/lib/tools-register.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public register_tool behavior
+ * Zones: runtime tool registration, tool registry mutation, register_tool schema
+ * Owns the public register_tool definition that persists local agent capabilities
+ */
+import * as Registry from "./registry.ts";
+import * as Schema from "./schema.ts";
+export type RegisterToolInput = Registry.RegisterToolInput;
+export type RegisterToolRuntimeDeps<TContext> = Registry.RegisterToolRuntimeDeps<TContext>;
+export declare function createRegisterToolDefinition<TContext>(deps: RegisterToolRuntimeDeps<TContext>): {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: Schema.JsonSchema;
+    execute: (_toolCallId: string, params: unknown, _signal: AbortSignal | undefined, _onUpdate: unknown, ctx: TContext) => Promise<Registry.RegisterToolResult>;
+};

package/node_modules/@llblab/pi-actors/dist/lib/tools-register.js

@@ -0,0 +1,41 @@
+/**
+ * Public register_tool behavior
+ * Zones: runtime tool registration, tool registry mutation, register_tool schema
+ * Owns the public register_tool definition that persists local agent capabilities
+ */
+import * as Prompts from "./prompts.js";
+import * as Registry from "./registry.js";
+import * as Schema from "./schema.js";
+const stringSchema = Schema.stringSchema;
+const booleanSchema = Schema.booleanSchema;
+const nullSchema = Schema.nullSchema;
+const arraySchema = Schema.arraySchema;
+const unionSchema = Schema.unionSchema;
+const objectSchema = Schema.objectSchema;
+const looseObjectSchema = Schema.looseObjectSchema;
+export function createRegisterToolDefinition(deps) {
+    return {
+        name: "register_tool",
+        label: "Register Tool",
+        description: Prompts.REGISTER_TOOL_DESCRIPTION,
+        promptSnippet: Prompts.REGISTER_TOOL_PROMPT_SNIPPET,
+        promptGuidelines: Prompts.REGISTER_TOOL_GUIDELINES,
+        parameters: objectSchema({
+            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),
+                looseObjectSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.template),
+                arraySchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.templateArray),
+                nullSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.templateNull),
+            ]),
+            update: booleanSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.update),
+        }, []),
+        execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => Registry.executeRegisterTool(params, ctx, deps),
+    };
+}

package/node_modules/@llblab/pi-actors/dist/lib/tools-response.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Public tool response formatting
+ * Zones: compact text summaries, verbose JSON switching, next-action rendering
+ * Owns model-facing response helpers shared by public tool execution paths
+ */
+export declare function withLeadingLineBreak(text: string): string;
+export declare function spaceToolResult<T>(result: T): T;
+export declare function spaceToolError(error: unknown): unknown;
+export declare function asRecord(value: unknown): Record<string, unknown>;
+export declare function jsonText(value: unknown): string;
+export declare function compactPreview(value: unknown, maxLength?: number): string | undefined;
+export declare function compactNextActions(actions: string[]): string;
+export declare function runNextActions(run: unknown): string[];
+export declare function compactAsyncRunStatus(value: unknown): string;
+export declare function maybeJsonText(value: unknown, verbose: boolean | undefined, compact: string): string;
+export declare function compactRecipeImports(summary: Record<string, unknown>): string;
+export declare function compactRecipeDoctor(summary: Record<string, unknown>): string;
+export declare function recipeRegistryNextActions(summary: Record<string, unknown>, view: string): string[];
+export declare function compactRecipeRegistry(summary: Record<string, unknown>): string;
+export declare const DEFAULT_INSPECT_LINES = 40;

package/node_modules/@llblab/pi-actors/dist/lib/tools-response.js

@@ -0,0 +1,243 @@
+/**
+ * Public tool response formatting
+ * Zones: compact text summaries, verbose JSON switching, next-action rendering
+ * Owns model-facing response helpers shared by public tool execution paths
+ */
+import * as Limits from "./limits.js";
+export function withLeadingLineBreak(text) {
+    return `\n${text.replace(/^\n+/, "")}`;
+}
+export function spaceToolResult(result) {
+    if (!result || typeof result !== "object")
+        return result;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return result;
+    return {
+        ...result,
+        content: content.map((item) => item &&
+            typeof item === "object" &&
+            item.type === "text" &&
+            typeof item.text === "string"
+            ? {
+                ...item,
+                text: withLeadingLineBreak(item.text),
+            }
+            : item),
+    };
+}
+export function spaceToolError(error) {
+    if (error instanceof Error) {
+        error.message = withLeadingLineBreak(error.message);
+        return error;
+    }
+    return new Error(withLeadingLineBreak(String(error)));
+}
+export function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function jsonText(value) {
+    return `\n${JSON.stringify(value, null, 2)}`;
+}
+export function compactPreview(value, maxLength = Limits.COMPACT_PREVIEW_CHARS) {
+    if (value === undefined)
+        return undefined;
+    const text = typeof value === "string" ? value : JSON.stringify(value, undefined, 0);
+    const compact = text.replaceAll(/\s+/g, "_");
+    return compact.length > maxLength
+        ? `${compact.slice(0, Math.max(0, maxLength - 1))}…`
+        : compact;
+}
+export function compactNextActions(actions) {
+    return actions.length
+        ? ` next=${actions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`
+        : "";
+}
+function formatFailureCount(value) {
+    return Array.isArray(value) ? value.length : undefined;
+}
+function compactPolicyAxis(label, value) {
+    const axis = asRecord(value);
+    const source = typeof axis.source === "string" ? axis.source : undefined;
+    if (!source || source === "unused")
+        return undefined;
+    const renderedValue = typeof axis.value === "string" && axis.value.trim()
+        ? `:${axis.value.trim()}`
+        : "";
+    return `${label}=${source}${renderedValue}`;
+}
+function compactModelPolicy(value) {
+    const policy = asRecord(value);
+    return [
+        compactPolicyAxis("model", policy.model),
+        compactPolicyAxis("thinking", policy.thinking),
+    ].filter((token) => Boolean(token));
+}
+export function runNextActions(run) {
+    const id = String(run ?? "").trim();
+    if (!id)
+        return [];
+    return [
+        `inspect target=run:${id} view=recipe`,
+        `inspect target=run:${id} view=trace`,
+        `inspect target=run:${id} view=control`,
+    ];
+}
+export function compactAsyncRunStatus(value) {
+    const status = asRecord(value);
+    const progress = asRecord(status.progress);
+    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)}`);
+    if (status.retire_when)
+        tokens.push(`retire_when=${String(status.retire_when)}`);
+    if (Number(status.pid) > 0)
+        tokens.push(`pid=${Number(status.pid)}`);
+    if (progress.phase && progress.phase !== status.status)
+        tokens.push(`phase=${String(progress.phase)}`);
+    if (Number(progress.activeSubagents) > 0)
+        tokens.push(`active=${Number(progress.activeSubagents)}`);
+    if (Number(progress.completed) > 0)
+        tokens.push(`completed=${Number(progress.completed)}`);
+    const failures = formatFailureCount(progress.failures);
+    if (failures !== undefined && failures > 0)
+        tokens.push(`failures=${failures}`);
+    if (result.code !== undefined)
+        tokens.push(`code=${String(result.code)}`);
+    if (result.killed === true)
+        tokens.push("killed=true");
+    const draftRecipe = status.draft_recipe;
+    if (draftRecipe)
+        tokens.push(`draft_recipe=${String(draftRecipe)}`);
+    const nextActions = runNextActions(run);
+    if (nextActions.length > 0)
+        tokens.push(`next=${nextActions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`);
+    return `\n${tokens.join(" ")}`;
+}
+export function maybeJsonText(value, verbose, compact) {
+    return verbose ? jsonText(value) : compact;
+}
+export function compactRecipeImports(summary) {
+    const active = Array.isArray(summary.active)
+        ? summary.active
+        : [];
+    const lines = active.flatMap((entry) => {
+        const imports = asRecord(entry.imports);
+        return Object.entries(imports).map(([alias, value]) => {
+            const binding = typeof value === "string" ? { from: value } : asRecord(value);
+            return `recipe=${String(entry.id ?? "<unknown>")} alias=${alias} from=${String(binding.from ?? value)}`;
+        });
+    });
+    return lines.length ? `\n${lines.join("\n")}` : "\n(no recipe imports)";
+}
+export function compactRecipeDoctor(summary) {
+    const details = Array.isArray(summary.diagnostic_details)
+        ? summary.diagnostic_details
+        : [];
+    const remediations = Array.isArray(summary.remediations)
+        ? summary.remediations
+        : [];
+    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} risks=${riskCount}${topRisks ? ` top_risks=${topRisks}` : ""}`,
+    ];
+    if (Object.keys(topAction).length > 0) {
+        const action = compactPreview(topAction.action, Limits.DOCTOR_ACTION_PREVIEW_CHARS);
+        lines.push(`top severity=${String(topAction.severity ?? "info")} kind=${String(topAction.kind ?? "inspect")} id=${String(topAction.id ?? "root")} action=${action ?? "inspect"}`);
+    }
+    for (const item of remediations.slice(0, 8)) {
+        const action = compactPreview(item.action, Limits.DOCTOR_ACTION_PREVIEW_CHARS);
+        const blocked = item.blocked_fallback
+            ? ` blocked=${compactPreview(item.blocked_fallback, Limits.DOCTOR_ACTION_PREVIEW_CHARS)}`
+            : "";
+        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
+        : [];
+    if (nextActions.length > 0)
+        lines[0] = `${lines[0]}${compactNextActions(nextActions)}`;
+    return `\n${lines.join("\n")}`;
+}
+export function recipeRegistryNextActions(summary, view) {
+    const actions = [];
+    const drafts = Array.isArray(summary.drafts)
+        ? summary.drafts
+        : [];
+    const invalid = Array.isArray(summary.invalid) ? summary.invalid.length : 0;
+    const diagnostics = Array.isArray(summary.diagnostics)
+        ? summary.diagnostics.length
+        : 0;
+    const topAction = asRecord(summary.top_action);
+    if (view !== "doctor" && (invalid > 0 || diagnostics > 0)) {
+        actions.push("inspect target=recipes view=doctor");
+    }
+    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;
+        if (firstPath)
+            actions.push(`spawn file=${firstPath}`);
+    }
+    return [...new Set(actions)].slice(0, 4);
+}
+export function compactRecipeRegistry(summary) {
+    const active = Array.isArray(summary.active) ? summary.active.length : 0;
+    const shadowed = Array.isArray(summary.shadowed)
+        ? summary.shadowed.length
+        : 0;
+    const invalid = Array.isArray(summary.invalid) ? summary.invalid.length : 0;
+    const disabled = Array.isArray(summary.disabled)
+        ? summary.disabled.length
+        : 0;
+    const diagnostics = Array.isArray(summary.diagnostics)
+        ? summary.diagnostics.length
+        : 0;
+    const drafts = Array.isArray(summary.drafts) ? summary.drafts.length : 0;
+    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} skill_catalog_partial=${skillCatalogPartial} recommendations=${recommendations} diagnostics=${diagnostics}${compactNextActions(nextActions)}`;
+}
+export const DEFAULT_INSPECT_LINES = Limits.DEFAULT_INSPECT_LINES;