@llblab/pi-actors 0.56.0 → 0.57.0

package/dist/lib/registry.js

@@ -21,18 +21,18 @@ function textContent(text) {
     return { type: "text", text };
 }
 function registryListText(rows) {
-    const coverage = (shown, reason) => "\n- registered_tools_coverage:" +
-        (reason ? `\n  - reason: ${reason}` : "") + `\n  - shown: ${shown}\n  - omitted: ${rows.length - shown}\n  - total: ${rows.length}`;
+    const budget = Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1;
+    const coverage = (shown, reason) => ({ ...(reason ? { reason } : {}), shown, omitted: rows.length - shown, total: rows.length });
     const malformed = rows.some(row => !row.isWellFormed());
     if (!malformed) {
-        // Rows already contain the old compiler-owned bullet and selected key coercion.
-        const body = rows.length ? "- registered_tools:\n" + rows.map(row => "  " + row.replaceAll(/\r\n|\r|\n/gu, newline => newline + "    ")).join("\n")
-            : "- registered_tools: none";
-        const complete = body + coverage(rows.length);
-        if (Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            return complete;
+        // Remove only the compiler prefix after the original key coercion and join.
+        const complete = ToolsResponse.renderYamlMetadata({ registered_tools: rows.map(row => row.slice(2)), registered_tools_coverage: coverage(rows.length) }, budget);
+        if (complete.state === "available")
+            return complete.text;
     }
-    return `- registered_tools: [${malformed ? "unavailable" : "omitted"}]` + coverage(0, malformed ? "malformed_selected_text" : "response_too_large");
+    const fallback = ToolsResponse.renderYamlMetadata({ registered_tools: malformed ? "[unavailable]" : "[omitted]", registered_tools_coverage: coverage(0, malformed ? "malformed_selected_text" : "response_too_large") }, budget);
+    // Fixed keys/reasons and finite array-length counts are bounded far below budget.
+    return fallback.text;
 }
 function listTools(deps) {
     const names = [...deps.getTools().keys()].sort();
@@ -82,15 +82,35 @@ function registrationNextActions(tool, source, callableNow) {
             : [recipeDoctorAction(source)]),
     ];
 }
+const REGISTRY_METADATA_BUDGET = Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1;
+/** Bare block-YAML registry document; builders own whole-value/omission policy and the byte budget. */
+function registryMetadataText(value) {
+    return ToolsResponse.renderYamlMetadata(value, REGISTRY_METADATA_BUDGET).text;
+}
+/** One opaque selected scalar as a whole value or an explicit whole-field omission, never a clip. */
+function registrySelected(key, value) {
+    return ToolsResponse.selectYamlField(key, value, REGISTRY_METADATA_BUDGET);
+}
+/** Grow whole selected fields in priority order while the complete document still fits. */
+function growRegistryDocument(render, order) {
+    return ToolsResponse.growYamlDocument(render, order, REGISTRY_METADATA_BUDGET);
+}
 /** Read-time text only: callers supply the original post-activation selections, not live ports. */
 function registrationReceiptText(data) {
-    const field = ToolsResponse.formatMarkdownField;
-    const omission = (key, count, malformed) => `- ${key}: [${malformed ? "unavailable" : "omitted"}]\n- ${key}_omission:\n  - reason: ${malformed ? "malformed_selected_text" : "response_too_large"}\n  - shown: 0\n  - omitted: ${count}\n  - total: ${count}`;
-    const part = (full, omitted) => ({ full, selected: Buffer.byteLength(full) <= Buffer.byteLength(omitted) ? full : omitted });
-    const scalar = (key, value, literal = false) => {
+    const budget = Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1;
+    const renderPart = (value) => ToolsResponse.renderYamlMetadata(value, budget);
+    const omission = (key, count, malformed) => ({
+        [key]: malformed ? "[unavailable]" : "[omitted]",
+        [key + "_omission"]: { reason: malformed ? "malformed_selected_text" : "response_too_large", shown: 0, omitted: count, total: count },
+    });
+    const part = (full, omitted) => {
+        const complete = renderPart(full), fallback = renderPart(omitted);
+        return { full, selected: complete.state === "available" && fallback.state === "available" && Buffer.byteLength(complete.text) <= Buffer.byteLength(fallback.text) ? full : omitted };
+    };
+    const scalar = (key, value) => {
         const wellFormed = value.isWellFormed();
         const omitted = omission(key, 1, !wellFormed);
-        return part(wellFormed ? field(key, literal ? ToolsResponse.formatLiteralBlock(value) : value) : omitted, omitted);
+        return part(wellFormed ? { [key]: value } : omitted, omitted);
     };
     const sequence = (key, values) => {
         const rows = [];
@@ -101,34 +121,34 @@ function registrationReceiptText(data) {
                 malformed = true;
                 break;
             }
-            rows.push("  - " + value.replaceAll(/\r\n|\r|\n/gu, newline => newline + "    "));
+            rows.push(value);
         }
         const omitted = omission(key, values.length, malformed);
-        return part(malformed ? omitted : rows.length ? `- ${key}:\n${rows.join("\n")}` : field(key, "none"), omitted);
+        return part(malformed ? omitted : { [key]: rows }, omitted);
     };
     const tool = scalar("tool", data.tool);
-    const source = scalar("source", data.source, data.source !== "template");
+    const source = scalar("source", data.source);
     const required = sequence("required_args", data.required), optional = sequence("optional_args", data.optional);
     const warnings = data.warnings.length ? sequence("warnings", data.warnings) : undefined;
     const nextWellFormed = data.next.isWellFormed();
     const omittedNext = omission("next_action", 1, !nextWellFormed);
     // This producer knows only its existing status hint; invocation advice stays opaque.
     const next = part(nextWellFormed
-        ? data.callable ? field("instruction", data.next) : ToolsResponse.formatInspectNextAction(`tool:${data.tool}`, "status")
+        ? data.callable ? { instruction: data.next } : { next: { tool: "inspect", target: `tool:${data.tool}`, view: "status" } }
         : omittedNext, omittedNext);
-    const render = () => [tool.selected, field("result", data.result), source.selected, field("callable_now", data.callable ? "true" : "false"),
-        ...(data.boundary === undefined ? [] : [field("activation_boundary", data.boundary)]), required.selected, optional.selected,
-        ...(warnings ? [warnings.selected] : []), next.selected].join("\n");
+    const render = () => renderPart({ ...tool.selected, result: data.result, ...source.selected, callable_now: data.callable,
+        ...(data.boundary === undefined ? {} : { activation_boundary: data.boundary }), ...required.selected, ...optional.selected,
+        ...(warnings ? warnings.selected : {}), ...next.selected });
     // Preserve complete safety notes before large argument lists; all seeds are monotone.
     for (const current of [...(warnings ? [warnings] : []), tool, source, next, required, optional]) {
         if (current.selected === current.full)
             continue;
         const previous = current.selected;
         current.selected = current.full;
-        if (Buffer.byteLength(render()) > Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
+        if (render().state !== "available")
             current.selected = previous;
     }
-    return render();
+    return render().text;
 }
 function registryNoticeText(kind, name) {
     const report = { activated: "Tool activated", promoted: "Promoted draft recipe", deleted: "Deleted tool" }[kind];
@@ -137,78 +157,33 @@ function registryNoticeText(kind, name) {
     return ToolsResponse.formatMarkdownField("report", report) + "\n" + selected;
 }
 function registrationTransactionFailureText(stage, generation, summary, error) {
-    const field = ToolsResponse.formatMarkdownField;
-    const part = (key, value) => {
-        const wellFormed = value.isWellFormed();
-        const omitted = `- ${key}: [${wellFormed ? "omitted" : "unavailable"}]\n- ${key}_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`;
-        const full = wellFormed ? field(key, value) : omitted;
-        return { full, selected: Buffer.byteLength(full) <= Buffer.byteLength(omitted) ? full : omitted };
-    };
-    const selectedGeneration = part("resolution_generation", generation);
-    const selectedSummary = part("active_skills_summary", summary);
-    const selectedError = part("error", error);
-    const render = () => [field("result", "Tool registration transaction failed."), field("stage", stage),
-        selectedGeneration.selected, selectedSummary.selected, selectedError.selected].join("\n");
+    const selectedGeneration = registrySelected("resolution_generation", generation);
+    const selectedSummary = registrySelected("active_skills_summary", summary);
+    const selectedError = registrySelected("error", error);
+    const render = () => ({ result: "Tool registration transaction failed.", stage,
+        ...selectedGeneration.selected, ...selectedSummary.selected, ...selectedError.selected });
     // Keep a fitting surfaced error before large optional resolution metadata.
-    for (const current of [selectedError, selectedGeneration, selectedSummary]) {
-        if (current.selected === current.full)
-            continue;
-        const previous = current.selected;
-        current.selected = current.full;
-        if (Buffer.byteLength(render()) > Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            current.selected = previous;
-    }
-    return render();
+    return growRegistryDocument(render, [selectedError, selectedGeneration, selectedSummary]);
 }
 function candidateAdmissionFailureText(data) {
-    const field = ToolsResponse.formatMarkdownField;
-    const part = (key, value, literal = false) => {
-        const wellFormed = value.isWellFormed();
-        const omitted = `- ${key}: [${wellFormed ? "omitted" : "unavailable"}]\n- ${key}_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`;
-        const full = wellFormed ? field(key, literal ? ToolsResponse.formatLiteralBlock(value) : value) : omitted;
-        return { full, selected: Buffer.byteLength(full) <= Buffer.byteLength(omitted) ? full : omitted };
-    };
-    const diagnostics = part("diagnostics_summary", data.diagnostics);
-    const source = data.kind === "source" ? part("source", data.source, true) : undefined;
-    const summary = data.kind === "source" ? part("active_skills_summary", data.summary) : undefined;
-    const instruction = data.kind === "source" ? part("instruction", data.instruction) : undefined;
-    const render = () => [field("field", "recipe"), ...(source ? [source.selected] : []),
-        field("result", data.kind === "source" ? "Recipe source validation failed." : "Tool recipe validation failed."),
-        diagnostics.selected, ...(summary ? [summary.selected] : []), ...(instruction ? [instruction.selected] : [])].join("\n");
+    const diagnostics = registrySelected("diagnostics_summary", data.diagnostics);
+    const source = data.kind === "source" ? registrySelected("source", data.source) : undefined;
+    const summary = data.kind === "source" ? registrySelected("active_skills_summary", data.summary) : undefined;
+    const instruction = data.kind === "source" ? registrySelected("instruction", data.instruction) : undefined;
+    const render = () => ({ field: "recipe", ...(source ? source.selected : {}),
+        result: data.kind === "source" ? "Recipe source validation failed." : "Tool recipe validation failed.",
+        ...diagnostics.selected, ...(summary ? summary.selected : {}), ...(instruction ? instruction.selected : {}) });
     // Preserve fitting diagnostics before large optional source/context/advice fields.
-    for (const current of [diagnostics, source, summary, instruction]) {
-        if (!current || current.selected === current.full)
-            continue;
-        const previous = current.selected;
-        current.selected = current.full;
-        if (Buffer.byteLength(render()) > Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            current.selected = previous;
-    }
-    return render();
+    return growRegistryDocument(render, [diagnostics, ...(source ? [source] : []), ...(summary ? [summary] : []), ...(instruction ? [instruction] : [])]);
 }
 function sourceNormalizationFailureText(source, reason, summary, instruction) {
-    const field = ToolsResponse.formatMarkdownField;
-    const part = (key, value, literal = false) => {
-        const wellFormed = value.isWellFormed();
-        const omitted = `- ${key}: [${wellFormed ? "omitted" : "unavailable"}]\n- ${key}_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`;
-        const full = wellFormed ? field(key, literal ? ToolsResponse.formatLiteralBlock(value) : value) : omitted;
-        return { full, selected: Buffer.byteLength(full) <= Buffer.byteLength(omitted) ? full : omitted };
-    };
-    const selectedSource = part("source", source, true);
-    const selectedReason = part("reason", reason);
-    const selectedSummary = part("active_skills_summary", summary);
-    const selectedInstruction = part("instruction", instruction);
-    const render = () => [field("field", "from"), selectedSource.selected, field("result", "Recipe source is invalid."),
-        selectedReason.selected, selectedSummary.selected, selectedInstruction.selected].join("\n");
-    for (const current of [selectedSource, selectedReason, selectedSummary, selectedInstruction]) {
-        if (current.selected === current.full)
-            continue;
-        const previous = current.selected;
-        current.selected = current.full;
-        if (Buffer.byteLength(render()) > Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            current.selected = previous;
-    }
-    return render();
+    const selectedSource = registrySelected("source", source);
+    const selectedReason = registrySelected("reason", reason);
+    const selectedSummary = registrySelected("active_skills_summary", summary);
+    const selectedInstruction = registrySelected("instruction", instruction);
+    const render = () => ({ field: "from", ...selectedSource.selected, result: "Recipe source is invalid.",
+        ...selectedReason.selected, ...selectedSummary.selected, ...selectedInstruction.selected });
+    return growRegistryDocument(render, [selectedSource, selectedReason, selectedSummary, selectedInstruction]);
 }
 function activeSkillSummary(resolutionContext) {
     const names = Object.keys(RecipesReferences.getActiveSkillRecipeNamespaces(resolutionContext.activeSkills))
@@ -217,17 +192,11 @@ function activeSkillSummary(resolutionContext) {
     return names.length > 0 ? names.join(", ") : "<none>";
 }
 function draftPathFailureText(kind, reference) {
-    const key = kind === "root" ? "allowed_root" : "path";
-    const render = (selected) => "- field: draft\n" + selected + (kind === "root"
-        ? "\n- result: Draft must be under the allowed root.\n- instruction: Use inspect target=recipes view=summary to list drafts."
-        : "\n- result: Draft not found.");
-    const wellFormed = reference.isWellFormed();
-    if (wellFormed) {
-        const complete = render(ToolsResponse.formatMarkdownField(key, ToolsResponse.formatLiteralBlock(reference)));
-        if (Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            return complete;
-    }
-    return render(`- ${key}: [${wellFormed ? "omitted" : "unavailable"}]\n- ${key}_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`);
+    const selected = registrySelected(kind === "root" ? "allowed_root" : "path", reference);
+    const render = () => ({ field: "draft", ...selected.selected,
+        result: kind === "root" ? "Draft must be under the allowed root." : "Draft not found.",
+        ...(kind === "root" ? { instruction: "Use inspect target=recipes view=summary to list drafts." } : {}) });
+    return growRegistryDocument(render, [selected]);
 }
 function assertDraftPath(deps, draft) {
     const draftRoot = resolve(getRecipeRoot(deps), "drafts");
@@ -244,50 +213,42 @@ function assertDraftPath(deps, draft) {
     return path;
 }
 function draftReceiptText(result, tool, callable, next) {
-    const field = ToolsResponse.formatMarkdownField;
+    const budget = Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1;
+    const renderPart = (value) => ToolsResponse.renderYamlMetadata(value, budget);
     const part = (key, value, rendered) => {
         const wellFormed = value.isWellFormed();
-        const omitted = `- ${key}: [${wellFormed ? "omitted" : "unavailable"}]\n- ${key}_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`;
+        const omitted = { [key]: wellFormed ? "[omitted]" : "[unavailable]",
+            [key + "_omission"]: { reason: wellFormed ? "response_too_large" : "malformed_selected_text", shown: 0, omitted: 1, total: 1 } };
         const full = wellFormed ? rendered : omitted;
-        return { full, selected: Buffer.byteLength(full) <= Buffer.byteLength(omitted) ? full : omitted };
+        const complete = renderPart(full), fallback = renderPart(omitted);
+        return { full, selected: complete.state === "available" && fallback.state === "available" && Buffer.byteLength(complete.text) <= Buffer.byteLength(fallback.text) ? full : omitted };
     };
-    const identity = part("tool", tool, field("tool", tool));
-    const flag = part("callable_now", callable, field("callable_now", callable));
+    const identity = part("tool", tool, { tool });
+    const flag = part("callable_now", callable, { callable_now: callable });
     // Only this producer's exact canonical read-only status hint is typed, never body advice.
     const status = /^inspect target=(tool:[a-z][a-z0-9_]{0,63}) view=status$/u.exec(next);
-    const hint = part("next_action", next, status ? ToolsResponse.formatInspectNextAction(status[1], "status") : field("instruction", next));
-    const render = () => [identity.selected, field("result", result), field("source", "draft"), flag.selected, hint.selected].join("\n");
+    const hint = part("next_action", next, status ? { next: { tool: "inspect", target: status[1], view: "status" } } : { instruction: next });
+    const render = () => renderPart({ ...identity.selected, result, source: "draft", ...flag.selected, ...hint.selected });
     for (const current of [identity, flag, hint]) {
         if (current.selected === current.full)
             continue;
         const previous = current.selected;
         current.selected = current.full;
-        if (Buffer.byteLength(render()) > Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
+        if (render().state !== "available")
             current.selected = previous;
     }
-    return render();
+    return render().text;
 }
 function duplicateRegistrationText(value) {
-    const render = (selected) => "- field: name\n" + selected + "\n- result: Tool already registered.\n- instruction: Use update=true to overwrite.";
-    const wellFormed = value.isWellFormed();
-    if (wellFormed) {
-        const complete = render(ToolsResponse.formatMarkdownField("value", value));
-        if (Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            return complete;
-    }
-    return render(`- value: [${wellFormed ? "omitted" : "unavailable"}]\n- value_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`);
+    const selected = registrySelected("value", value);
+    const render = () => ({ field: "name", ...selected.selected,
+        result: "Tool already registered.", instruction: "Use update=true to overwrite." });
+    return growRegistryDocument(render, [selected]);
 }
 function draftRecipeFailureText(key, value) {
-    const header = "- field: draft\n- result: Draft recipe is invalid.";
-    if (value === undefined)
-        return header;
-    const wellFormed = value.isWellFormed();
-    if (wellFormed) {
-        const complete = header + "\n" + ToolsResponse.formatMarkdownField(key, value);
-        if (Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            return complete;
-    }
-    return header + `\n- ${key}: [${wellFormed ? "omitted" : "unavailable"}]\n- ${key}_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`;
+    const selected = value === undefined ? undefined : registrySelected(key, value);
+    const render = () => ({ field: "draft", result: "Draft recipe is invalid.", ...(selected ? selected.selected : {}) });
+    return growRegistryDocument(render, selected ? [selected] : []);
 }
 function promoteDraftRecipe(name, input, ctx, deps) {
     const draftPath = assertDraftPath(deps, String(input.draft ?? ""));
@@ -358,17 +319,17 @@ function persistToolRecipe(deps, name, recipe) {
     return path;
 }
 function registryDeletionText(name, result) {
-    const field = ToolsResponse.formatMarkdownField;
-    const facts = [field("result", result), ...(result === "deleted"
-            ? [field("instruction", "Reload to remove it from the complete registry.")] : [])];
-    const render = (identity) => [identity, ...facts].join("\n");
+    const budget = Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1;
+    const facts = { result, ...(result === "deleted" ? { instruction: "Reload to remove it from the complete registry." } : {}) };
     const wellFormed = name.isWellFormed();
     if (wellFormed) {
-        const complete = render(field("tool", name));
-        if (Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            return complete;
+        const complete = ToolsResponse.renderYamlMetadata({ tool: name, ...facts }, budget);
+        if (complete.state === "available")
+            return complete.text;
     }
-    return render(`- tool: [${wellFormed ? "omitted" : "unavailable"}]\n- tool_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`);
+    const fallback = ToolsResponse.renderYamlMetadata({ tool: wellFormed ? "[omitted]" : "[unavailable]", tool_omission: { reason: wellFormed ? "response_too_large" : "malformed_selected_text", shown: 0, omitted: 1, total: 1 }, ...facts }, budget);
+    // Fixed metadata is well formed and bounded far below budget.
+    return fallback.text;
 }
 function deleteTool(name, ctx, deps) {
     const tools = deps.getTools();
@@ -428,7 +389,9 @@ function assertTemplateIsNotNestedRecipe(value) {
         looksLikeRecipeReference(record.template) &&
         (Object.keys(record).length === 1 ||
             ["artifacts", "async", "control", "description", "imports", "values"].some((key) => Object.hasOwn(record, key)))) {
-        throw new Error(ExecutionOutput.formatToolText("- field: template\n- result: Nested Recipe-shaped templates are not a register_tool source mode.\n- instruction: retry with from=<skill>/<recipe> and defaults={...}."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "template",
+            result: "Nested Recipe-shaped templates are not a register_tool source mode.",
+            instruction: "retry with from=<skill>/<recipe> and defaults={...}." })));
     }
 }
 function getInputTemplate(value) {
@@ -442,14 +405,15 @@ function getInputTemplate(value) {
             template: value,
         });
         if (steps.length === 0)
-            throw new Error(ExecutionOutput.formatToolText("- field: template\n- result: Tool template sequence is empty."));
+            throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "template", result: "Tool template sequence is empty." })));
         return value;
     }
     if (value && typeof value === "object") {
         CommandTemplates.expandCommandTemplateConfigs(value);
         return value;
     }
-    throw new Error(ExecutionOutput.formatToolText("- field: template\n- result: unsupported template type\n- supported_types:\n  - string\n  - object\n  - sequence"));
+    throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "template", result: "unsupported template type",
+        supported_types: ["string", "object", "sequence"] })));
 }
 function getRegistrationResolutionContext(ctx, deps) {
     const runtimeContext = deps.getRecipeResolutionContext?.();
@@ -466,7 +430,7 @@ function normalizeDefaults(value) {
     if (value === undefined)
         return undefined;
     if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error(ExecutionOutput.formatToolText("- field: defaults\n- result: Tool defaults must be an object."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "defaults", result: "Tool defaults must be an object." })));
     }
     return { ...value };
 }
@@ -498,13 +462,17 @@ function buildAuthoredRecipe(input, existing, existingRecipe) {
     const from = typeof input.from === "string" ? input.from.trim() : "";
     const description = (input.description ?? existing?.description ?? "").trim();
     if (!description && !from) {
-        throw new Error(ExecutionOutput.formatToolText("- field: description\n- result: Tool description is required for command-template registration."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "description",
+            result: "Tool description is required for command-template registration." })));
     }
     const inputDefaults = normalizeDefaults(input.defaults);
     if (from) {
         const runtimeOwnedDefault = Object.keys(inputDefaults ?? {}).find((key) => RecipesReferences.isRuntimeOwnedRecipeInput(key));
         if (runtimeOwnedDefault) {
-            throw new Error(ExecutionOutput.formatToolText(`- field: defaults\n- key: ${runtimeOwnedDefault}\n- result: Tool defaults cannot set runtime-owned input.\n- instruction: remove that default and retry register_tool; the runtime supplies it.`));
+            throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "defaults",
+                ...registrySelected("key", runtimeOwnedDefault).selected,
+                result: "Tool defaults cannot set runtime-owned input.",
+                instruction: "remove that default and retry register_tool; the runtime supplies it." })));
         }
         const authored = {
             ...(description ? { description } : {}),
@@ -520,13 +488,13 @@ function buildAuthoredRecipe(input, existing, existingRecipe) {
     }
     const template = getInputTemplate(input.template);
     if (template === null) {
-        throw new Error(ExecutionOutput.formatToolText("- field: template\n- result: Tool template cannot be null here."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "template", result: "Tool template cannot be null here." })));
     }
     const finalTemplate = template === undefined || template === ""
         ? existingRecipe?.template ?? existing?.template
         : template;
     if (!finalTemplate) {
-        throw new Error(ExecutionOutput.formatToolText("- field: template\n- result: Tool template is required."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "template", result: "Tool template is required." })));
     }
     const authored = {
         ...(existingRecipe ?? {}),
@@ -554,33 +522,38 @@ function buildAuthoredRecipe(input, existing, existingRecipe) {
 function assertRegisterToolInputModes(input) {
     const record = input;
     if (Object.hasOwn(record, "values")) {
-        throw new Error(ExecutionOutput.formatToolText("- field: values\n- result: register_tool values was removed.\n- replacement_fields:\n  - defaults\n  - from\n- instruction: retry register_tool with defaults for caller inputs, or use from=<skill>/<recipe> for maintained composition."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "values", result: "register_tool values was removed.",
+            replacement_fields: ["defaults", "from"],
+            instruction: "retry register_tool with defaults for caller inputs, or use from=<skill>/<recipe> for maintained composition." })));
     }
     const fromProvided = Object.hasOwn(record, "from");
     if (fromProvided &&
         (typeof input.from !== "string" || input.from.trim().length === 0)) {
-        throw new Error(ExecutionOutput.formatToolText("- field: from\n- result: Tool from must be a non-empty Recipe reference.\n- reference_forms:\n  - <skill>/<recipe>\n  - explicit .json path\n  - explicit .md path\n- instruction: retry register_tool with from=<skill>/<recipe> or an explicit .json/.md path."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "from",
+            result: "Tool from must be a non-empty Recipe reference.",
+            reference_forms: ["<skill>/<recipe>", "explicit .json path", "explicit .md path"],
+            instruction: "retry register_tool with from=<skill>/<recipe> or an explicit .json/.md path." })));
     }
     const draftProvided = typeof input.draft === "string" && input.draft.trim().length > 0;
     const templateProvided = Object.hasOwn(record, "template");
     const modeCount = Number(fromProvided) + Number(draftProvided) + Number(templateProvided);
     if (modeCount > 1) {
-        throw new Error(ExecutionOutput.formatToolText("- result: Use exactly one register_tool source mode.\n- source_modes:\n  - from\n  - template\n  - draft\n- instruction: remove the extra source fields and retry register_tool."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ result: "Use exactly one register_tool source mode.",
+            source_modes: ["from", "template", "draft"],
+            instruction: "remove the extra source fields and retry register_tool." })));
     }
     if (fromProvided &&
         (Object.hasOwn(record, "args") || Object.hasOwn(record, "async"))) {
-        throw new Error(ExecutionOutput.formatToolText("- field: from\n- result: register_tool from inherits args and async behavior.\n- inherited_fields:\n  - args\n  - async\n- instruction: retry register_tool with from and optional defaults only; omit args and async."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "from",
+            result: "register_tool from inherits args and async behavior.",
+            inherited_fields: ["args", "async"],
+            instruction: "retry register_tool with from and optional defaults only; omit args and async." })));
     }
 }
 function reservedRegistrationNameText(value) {
-    const render = (selected) => "- field: name\n" + selected + "\n- result: Reserved tool name.";
-    const wellFormed = value.isWellFormed();
-    if (wellFormed) {
-        const complete = render(ToolsResponse.formatMarkdownField("value", value));
-        if (Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1)
-            return complete;
-    }
-    return render(`- value: [${wellFormed ? "omitted" : "unavailable"}]\n- value_omission:\n  - reason: ${wellFormed ? "response_too_large" : "malformed_selected_text"}\n  - shown: 0\n  - omitted: 1\n  - total: 1`);
+    const selected = registrySelected("value", value);
+    const render = () => ({ field: "name", ...selected.selected, result: "Reserved tool name." });
+    return growRegistryDocument(render, [selected]);
 }
 function executeRegisterToolUnlocked(params, ctx, deps) {
     const rawInput = params && typeof params === "object"
@@ -592,7 +565,7 @@ function executeRegisterToolUnlocked(params, ctx, deps) {
         return listTools(deps);
     const name = Identity.normalizeToolName(input.name);
     if (!name)
-        throw new Error(ExecutionOutput.formatToolText("- field: name\n- result: Invalid tool name."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ field: "name", result: "Invalid tool name." })));
     if (deps.reservedToolNames.has(name)) {
         throw new Error(ExecutionOutput.formatToolText(reservedRegistrationNameText(`${name}`)));
     }
@@ -630,7 +603,9 @@ function executeRegisterToolUnlocked(params, ctx, deps) {
         throw new Error(ExecutionOutput.formatToolText(duplicateRegistrationText(`${name}`)));
     }
     if (template === undefined && !input.from && !existing) {
-        throw new Error(ExecutionOutput.formatToolText("- result: New registration requires exactly one source mode.\n- source_modes:\n  - from\n  - template\n  - draft\n- instruction: retry register_tool with one source field."));
+        throw new Error(ExecutionOutput.formatToolText(registryMetadataText({ result: "New registration requires exactly one source mode.",
+            source_modes: ["from", "template", "draft"],
+            instruction: "retry register_tool with one source field." })));
     }
     const recipePath = getToolRecipePath(deps, name);
     const authoredRecipe = buildAuthoredRecipe(input, existing, authoritative.recipe);

package/dist/lib/run-ui-runtime.js

@@ -12,26 +12,21 @@ import * as Pi from "./pi.js";
 import * as RunDelivery from "./run-delivery.js";
 import * as RunDeliveryLineage from "./run-delivery-lineage.js";
 import * as RunIndex from "./runs-index.js";
-import { formatLiteralBlock, formatMarkdownField } from "./tools-response.js";
+import { formatYamlNotice } from "./tools-response.js";
 function formatSteerDiagnosticMessage(eventId, stage, message) {
-    const fields = [formatMarkdownField("event", eventId), formatMarkdownField("attention", "steer"),
-        formatMarkdownField("stage", stage), formatMarkdownField("result", stage === "admission" ? "remains retryable" : "request failed")];
-    if (stage === "delivery")
-        fields.push(formatMarkdownField("delivery", "unconfirmed"), formatMarkdownField("presentation", "unconfirmed"));
     let end = Math.min(message.length, 240);
     const last = message.charCodeAt(end - 1), next = message.charCodeAt(end);
     if (last >= 0xd800 && last <= 0xdbff && next >= 0xdc00 && next <= 0xdfff)
         end -= 1;
     const preview = message.slice(0, end), clipped = end < message.length;
-    if (Buffer.from(preview).toString("utf8") !== preview) {
-        fields.push(formatMarkdownField("diagnostic", "unavailable"), formatMarkdownField("diagnostic_reason", "malformed legacy preview"), formatMarkdownField("diagnostic_omission", "[omitted: unknown]"));
-    }
-    else {
-        fields.push(formatMarkdownField("diagnostic", preview + (clipped ? "…" : "")));
-        if (clipped)
-            fields.push(formatMarkdownField("diagnostic_omission", "[omitted: unknown]"));
-    }
-    return fields.join("\n");
+    // The 240-pair-aligned preview and its explicit unknown-loss marker are unchanged; only metadata is YAML.
+    const diagnostic = Buffer.from(preview).toString("utf8") !== preview
+        ? { diagnostic: "unavailable", diagnostic_reason: "malformed legacy preview", diagnostic_omission: "[omitted: unknown]" }
+        : { diagnostic: preview + (clipped ? "…" : ""), ...(clipped ? { diagnostic_omission: "[omitted: unknown]" } : {}) };
+    return formatYamlNotice({ event: eventId, attention: "steer", stage,
+        result: stage === "admission" ? "remains retryable" : "request failed",
+        ...(stage === "delivery" ? { delivery: "unconfirmed", presentation: "unconfirmed" } : {}),
+        ...diagnostic });
 }
 /** Transcript-only view of the exact delivered content; never re-read a Run or infer body labels. */
 export function registerRunCompletionRenderer(pi) {
@@ -162,8 +157,7 @@ export function createRunUiRuntime(deps) {
         }
         const message = error instanceof Error ? error.message : String(error);
         try {
-            expectedContext.ui.notify([formatMarkdownField("callback", label), formatMarkdownField("result", "failed"),
-                formatMarkdownField("diagnostic", message)].join("\n"), "error");
+            expectedContext.ui.notify(formatYamlNotice({ callback: label, result: "failed", diagnostic: message }), "error");
         }
         catch {
             /* stale context or unavailable UI */
@@ -327,9 +321,8 @@ export function createRunUiRuntime(deps) {
                 const key = `${batch.batch_id}:${evidence.status}:${evidence.reason ?? ""}`;
                 if (!completionDiagnostics.has(key)) {
                     completionDiagnostics.add(key);
-                    ctx.ui.notify("\n" + [formatMarkdownField("batch", batch.batch_id), formatMarkdownField("stage", "completion recovery"),
-                        formatMarkdownField("evidence", evidence.status), formatMarkdownField("phase", "pending"),
-                        formatMarkdownField("reason", evidence.reason ?? "conflicting session evidence")].join("\n"), "warning");
+                    ctx.ui.notify("\n" + formatYamlNotice({ batch: batch.batch_id, stage: "completion recovery",
+                        evidence: evidence.status, phase: "pending", reason: evidence.reason ?? "conflicting session evidence" }), "warning");
                 }
                 return true;
             }
@@ -413,9 +406,8 @@ export function createRunUiRuntime(deps) {
                     const key = `${steer.steer_id}:${evidence.status}:${evidence.reason ?? ""}`;
                     if (!steerDiagnostics.has(key)) {
                         steerDiagnostics.add(key);
-                        ctx.ui.notify([formatMarkdownField("event", steer.event_id), formatMarkdownField("attention", "steer"),
-                            formatMarkdownField("stage", "recovery"), formatMarkdownField("evidence", evidence.status),
-                            formatMarkdownField("phase", "queued"), formatMarkdownField("reason", evidence.reason ?? "conflicting session evidence")].join("\n"), "warning");
+                        ctx.ui.notify(formatYamlNotice({ event: steer.event_id, attention: "steer", stage: "recovery",
+                            evidence: evidence.status, phase: "queued", reason: evidence.reason ?? "conflicting session evidence" }), "warning");
                     }
                     continue;
                 }
@@ -681,11 +673,10 @@ export function createRunUiRuntime(deps) {
             if (teardown.failed === 0 || !ctx)
                 return;
             try {
-                ctx.ui.notify([formatMarkdownField("stage", "shutdown teardown"), formatMarkdownField("killed", String(teardown.killed)),
-                    formatMarkdownField("failed", String(teardown.failed)), formatMarkdownField("skipped", String(teardown.skipped)),
-                    formatMarkdownField("discovery_failed", String(teardown.discoveryFailed)),
-                    formatMarkdownField("summary", teardown.summaryPath == null ? "unavailable" : formatLiteralBlock(teardown.summaryPath)),
-                    formatMarkdownField("basis", "teardown report; not scope closure")].join("\n"), "warning");
+                ctx.ui.notify(formatYamlNotice({ stage: "shutdown teardown", killed: teardown.killed,
+                    failed: teardown.failed, skipped: teardown.skipped, discovery_failed: teardown.discoveryFailed,
+                    summary: teardown.summaryPath ?? "unavailable",
+                    basis: "teardown report; not scope closure" }), "warning");
             }
             catch {
                 /* stale shutdown context */