@llblab/pi-actors 0.56.0 → 0.57.0

package/lib/tools-message.ts

@@ -17,7 +17,54 @@ function asRecord(value: unknown): Record<string, unknown> {
     : {};
 }
 
-const controlField = ToolsResponse.formatMarkdownField;
+const CONTROL_BUDGET = Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1;
+
+type ControlDocument = Record<string, unknown>;
+type ControlPart = { full: ControlDocument; selected: ControlDocument };
+
+function controlMetadata(value: ControlDocument): string {
+  return (ToolsResponse.renderYamlMetadata(value, CONTROL_BUDGET) as
+    Extract<ToolsResponse.YamlMetadataRendering, { state: "available" }>).text;
+}
+
+/** One opaque selected scalar as a whole value or an explicit whole-field omission, never a clip. */
+function controlSelected(key: string, value: string): ControlPart {
+  return ToolsResponse.selectYamlField(key, value, CONTROL_BUDGET);
+}
+
+/** Compiler-selected option strings stay a native sequence; malformed selections stay unavailable. */
+function controlChoices(options: { key: "supported_actions" | "available_actions"; values: readonly string[] }): ControlPart {
+  const key = options.key, values = options.values;
+  // Values were selected by the original string filter, not a new action grammar.
+  const wellFormed = values.every((value) => typeof value === "string" && value.isWellFormed());
+  const omitted: ControlDocument = { [key]: wellFormed ? "[omitted]" : "[unavailable]",
+    [key + "_omission"]: { reason: wellFormed ? "response_too_large" : "malformed_selected_text",
+      shown: 0, omitted: values.length, total: values.length } };
+  const full: ControlDocument = !wellFormed ? omitted : values.length ? { [key]: [...values] } : { [key]: "none" };
+  const complete = ToolsResponse.renderYamlMetadata(full, CONTROL_BUDGET);
+  return { full, selected: complete.state === "available" && Buffer.byteLength(complete.text) <= Buffer.byteLength(controlMetadata(omitted)) ? full : omitted };
+}
+
+/** Grow whole selected fields in priority order while the complete document still fits. */
+function controlDocument(render: () => ControlDocument, order: readonly ControlPart[]): string {
+  return ToolsResponse.growYamlDocument(render, order, CONTROL_BUDGET);
+}
+
+/** Only producer-known read-only inspect literals become typed next; other advice stays opaque content. */
+function controlNextPart(action: string): ControlPart {
+  const inspect = /^inspect target=([^\s]+) view=([^\s]+)$/u.exec(action);
+  if (inspect) {
+    return ToolsResponse.selectYamlNode("next", { tool: "inspect", target: inspect[1], view: inspect[2] }, CONTROL_BUDGET);
+  }
+  const wellFormed = action.isWellFormed();
+  const omitted: ControlDocument = { next: { instruction: wellFormed ? "[omitted]" : "[unavailable]",
+    instruction_omission: { reason: wellFormed ? "response_too_large" : "malformed_selected_text", shown: 0, omitted: 1, total: 1 } } };
+  const full: ControlDocument = wellFormed ? { next: { instruction: action } } : omitted;
+  const complete = wellFormed ? ToolsResponse.renderYamlMetadata(full, CONTROL_BUDGET) : undefined;
+  const selected = complete?.state === "available" && Buffer.byteLength(complete.text) <= Buffer.byteLength(controlMetadata(omitted))
+    ? full : omitted;
+  return { full, selected };
+}
 
 /** Only the four compiler-owned guard sites below; never wraps dispatch/dependency errors. */
 function controlGuardText(
@@ -26,37 +73,12 @@ function controlGuardText(
   options?: { key: "supported_actions" | "available_actions"; values: readonly string[] },
 ): string {
   const key = request.target === "runtime" ? "target" : "run";
-  const identity = controlField(key, request.target === "runtime" ? request.target : request.target.slice(4));
-  const omittedIdentity = `- ${key}: [omitted]\n- ${key}_omission:\n  - reason: response_too_large\n  - shown: 0\n  - omitted: 1\n  - total: 1`;
-  const fixed = [controlField("action", request.action), controlField("result", result)];
-  let fullOptions = "", omittedOptions = "";
-  if (options) {
-    const rows: string[] = [];
-    let malformed = false;
-    // Values were selected by the original string filter, not by a new action grammar.
-    for (let index = 0; index < options.values.length; index++) {
-      const value = options.values[index];
-      if (!value.isWellFormed()) { malformed = true; break; }
-      rows.push("  - " + value.replaceAll(/\r\n|\r|\n/gu, newline => newline + "    "));
-    }
-    omittedOptions = `- ${options.key}: [${malformed ? "unavailable" : "omitted"}]\n- ${options.key}_omission:\n  - reason: ${malformed ? "malformed_selected_text" : "response_too_large"}\n  - shown: 0\n  - omitted: ${options.values.length}\n  - total: ${options.values.length}`;
-    fullOptions = malformed ? omittedOptions : rows.length ? `- ${options.key}:\n${rows.join("\n")}` : controlField(options.key, "none");
-  }
-  // Start with the shorter complete-or-omitted rendering: adding an omission scaffold must
-  // never manufacture overflow when the complete small field would fit. Then grow only.
-  let selectedIdentity = Buffer.byteLength(identity) <= Buffer.byteLength(omittedIdentity) ? identity : omittedIdentity;
-  let selectedOptions = Buffer.byteLength(fullOptions) <= Buffer.byteLength(omittedOptions) ? fullOptions : omittedOptions;
-  const render = (target: string, choices: string) => ToolsResponse.withLeadingLineBreak(
-    [target, ...fixed, ...(options ? [choices] : [])].join("\n"));
-  if (Buffer.byteLength(render(identity, selectedOptions)) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES) selectedIdentity = identity;
-  if (options && Buffer.byteLength(render(selectedIdentity, fullOptions)) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES) selectedOptions = fullOptions;
-  return render(selectedIdentity, selectedOptions);
-}
-
-function controlNext(action: string): string {
-  const inspect = /^inspect target=([^\s]+) view=([^\s]+)$/u.exec(action);
-  return inspect ? ToolsResponse.formatInspectNextAction(inspect[1], inspect[2])
-    : "- next:\n" + controlField("instruction", action, 1);
+  const identity = controlSelected(key, request.target === "runtime" ? request.target : request.target.slice(4));
+  const choices = options ? controlChoices(options) : undefined;
+  const render = (): ControlDocument => ({ ...identity.selected, action: request.action, result,
+    ...(choices ? choices.selected : {}) });
+  // Whole identity first, then the complete option sequence: the shorter seed must never manufacture overflow.
+  return ToolsResponse.withLeadingLineBreak(controlDocument(render, choices ? [identity, choices] : [identity]));
 }
 
 /** Pure first-layer copy; legacy stopped/killed flags are not scope-closure proof. */
@@ -64,32 +86,40 @@ export function compactControlResult(
   request: Control.ControlRequest,
   result: Record<string, unknown>,
 ): string {
-  const fields = [request.target.startsWith("run:") ? controlField("run", request.target.slice(4)) : controlField("target", request.target),
-    controlField("action", request.action)];
+  const key = request.target.startsWith("run:") ? "run" : "target";
+  const identity = controlSelected(key, key === "run" ? request.target.slice(4) : request.target);
+  const facts: ControlDocument = {};
   if (result.stopped === false || result.archived === false || result.pruned === false) {
-    fields.push(controlField("result", "not applied"));
-    if (typeof result.reason === "string") fields.push(controlField("reason", result.reason));
-    const observed = asRecord(result.status);
-    if (result.reason === "not running" && typeof observed.status === "string") fields.push(controlField("state", observed.status));
+    facts.result = "not applied";
   } else if (request.action === "kill" && result.stopped === true) {
-    fields.push(controlField("result", "kill attempted"), controlField("termination", "unconfirmed"));
+    facts.result = "kill attempted";
+    facts.termination = "unconfirmed";
   } else if (result.archived === true) {
-    fields.push(controlField("result", "archived"));
+    facts.result = "archived";
   } else if (result.pruned === true) {
-    fields.push(controlField("result", "pruned"));
+    facts.result = "pruned";
   } else if (result.delivery === "queued" || result.delivery === "delivered") {
-    fields.push(controlField("delivery", result.delivery), controlField("handling", "unconfirmed"));
+    facts.delivery = result.delivery;
+    facts.handling = "unconfirmed";
   } else {
-    fields.push(controlField(typeof result.delivery === "string" ? "delivery" : "result",
-      typeof result.delivery === "string" ? result.delivery : typeof result.status === "string" ? result.status : "accepted"));
-    if (typeof result.reason === "string") fields.push(controlField("reason", result.reason));
+    facts[typeof result.delivery === "string" ? "delivery" : "result"] =
+      typeof result.delivery === "string" ? result.delivery : typeof result.status === "string" ? result.status : "accepted";
   }
-  if (typeof result.control_id === "string") fields.push(controlField("control_id", result.control_id));
+  const notApplied = result.stopped === false || result.archived === false || result.pruned === false;
+  const reason = typeof result.reason === "string" ? controlSelected("reason", result.reason) : undefined;
+  const observed = asRecord(result.status);
+  const state = notApplied && result.reason === "not running" && typeof observed.status === "string"
+    ? controlSelected("state", observed.status) : undefined;
+  const controlId = typeof result.control_id === "string" ? controlSelected("control_id", result.control_id) : undefined;
   const actions = Array.isArray(result.next_actions) ? result.next_actions
     : request.target.startsWith("run:") ? runNextActions(request.target.slice(4), result) : [];
   const next = actions.find((action): action is string => typeof action === "string" && action.length > 0);
-  if (next) fields.push(controlNext(next));
-  return ToolsResponse.withLeadingLineBreak(fields.join("\n"));
+  const nextPart = next === undefined ? undefined : controlNextPart(next);
+  const parts = [identity, ...(reason ? [reason] : []), ...(state ? [state] : []), ...(controlId ? [controlId] : []), ...(nextPart ? [nextPart] : [])];
+  const render = (): ControlDocument => ({ ...identity.selected, action: request.action, ...facts,
+    ...(reason ? reason.selected : {}), ...(state ? state.selected : {}), ...(controlId ? controlId.selected : {}),
+    ...(nextPart ? nextPart.selected : {}) });
+  return ToolsResponse.withLeadingLineBreak(controlDocument(render, parts));
 }
 
 function runNextActions(run: string, result: Record<string, unknown>): string[] {
@@ -228,16 +258,13 @@ export function createControlToolDefinition<TContext = unknown>(
             );
           } catch (cause) {
             // Admission-era correlation is not current reply-scope proof after an awaited dispatch.
-            const summary = [controlField("action", request.action), controlField("result", "request failed"),
-              controlField("delivery", "unconfirmed"), controlField("handling", "unconfirmed"),
-              controlField("warning", "Effects may already exist.\nDo not repeat automatically."),
-              controlNext("inspect target=runtime view=runs")].join("\n");
-            // Reserve both line breaks; display one whole caller-owned id or explicit whole-id omission.
-            const identity = controlField("run", run);
-            const target = Buffer.byteLength(identity) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES - Buffer.byteLength(summary) - 2
-              ? identity
-              : "- run: [omitted]\n- run_omission:\n  - reason: response_too_large\n  - shown: 0\n  - omitted: 1\n  - total: 1";
-            throw new Error(ToolsResponse.withLeadingLineBreak(target + "\n" + summary), { cause });
+            // Display one whole caller-owned id or an explicit whole-id omission; the warning stays literal.
+            const identity = controlSelected("run", run);
+            const next = controlNextPart("inspect target=runtime view=runs");
+            const render = (): ControlDocument => ({ ...identity.selected, action: request.action,
+              result: "request failed", delivery: "unconfirmed", handling: "unconfirmed",
+              warning: "Effects may already exist.\nDo not repeat automatically.", ...next.selected });
+            throw new Error(ToolsResponse.withLeadingLineBreak(controlDocument(render, [identity])), { cause });
           }
         }
         // A refused identity change must not publish the replacement's status, even in verbose/details.

package/lib/tools-response.ts

@@ -84,6 +84,69 @@ export function renderYamlMetadata(value: unknown, byteBudget: number): YamlMeta
   }
 }
 
+export type YamlPart = { full: Record<string, unknown>; selected: Record<string, unknown> };
+
+/** One selected metadata node, kept whole or covered by a field/group omission. */
+export function selectYamlNode(key: string, value: unknown, byteBudget: number, total = 1): YamlPart {
+  const full = { [key]: value };
+  const complete = renderYamlMetadata(full, byteBudget);
+  const invalid = complete.state === "unavailable" && complete.reason === "metadata_invalid";
+  const omitted = { [key]: invalid ? "[unavailable]" : "[omitted]",
+    [key + "_omission"]: { reason: invalid ? "invalid_selected_metadata" : "response_too_large", shown: 0, omitted: total, total } };
+  const fallback = renderYamlMetadata(omitted, byteBudget);
+  // Seed the shorter complete-or-omitted form: omission scaffolding must never manufacture overflow.
+  const selected = complete.state === "available" && fallback.state === "available" &&
+    Buffer.byteLength(complete.text) <= Buffer.byteLength(fallback.text) ? full : omitted;
+  return { full: invalid ? omitted : full, selected };
+}
+
+/** Opaque selected text or string sequence; malformed selections stay unavailable without repair. */
+export function selectYamlField(key: string, value: string | readonly string[], byteBudget: number): YamlPart {
+  const values = typeof value === "string" ? [value] : value;
+  if (values.every(item => item.isWellFormed()))
+    return selectYamlNode(key, typeof value === "string" ? value : [...value], byteBudget, typeof value === "string" ? 1 : value.length);
+  const total = typeof value === "string" ? 1 : value.length;
+  const omitted = { [key]: "[unavailable]",
+    [key + "_omission"]: { reason: "malformed_selected_text", shown: 0, omitted: total, total } };
+  return { full: omitted, selected: omitted };
+}
+
+/** Grow whole selected fields in priority order while the complete document still fits. */
+export function growYamlDocument(
+  render: () => Record<string, unknown>,
+  order: readonly YamlPart[],
+  byteBudget: number,
+): string {
+  const fits = () => renderYamlMetadata(render(), byteBudget).state === "available";
+  for (const part of order) {
+    if (part.selected === part.full) continue;
+    const previous = part.selected;
+    part.selected = part.full;
+    if (!fits()) part.selected = previous;
+  }
+  const rendered = renderYamlMetadata(render(), byteBudget);
+  if (rendered.state !== "available")
+    throw new Error("Selected YAML metadata document is unavailable: " + rendered.reason);
+  return rendered.text;
+}
+
+/** Uncapped UI-only flat metadata; never borrow a model-output allowance for notices. */
+export function formatYamlNotice(value: Record<string, string | number | boolean>): string {
+  const selected: Record<string, unknown> = {};
+  for (const [key, field] of Object.entries(value)) {
+    if (typeof field === "string" && !field.isWellFormed()) {
+      selected[key] = "[unavailable]";
+      selected[key + "_omission"] = { reason: "malformed_selected_text", shown: 0, omitted: 1, total: 1 };
+    } else selected[key] = field;
+  }
+  return yamlMetadataText(selected).replace(/\n$/u, "");
+}
+
+/** Close one rendered YAML header; a separate opaque body gets exactly one delimiter pair. */
+export function frameMetadataDocument(header: string, body?: string): string {
+  return body === undefined ? header : `---\n${header}---\n${body}`;
+}
+
 export function formatMarkdownField(key: string, value: string, depth = 0): string {
   const indent = "  ".repeat(depth);
   return /[\r\n]/u.test(value)
@@ -463,6 +526,28 @@ export function recipeRegistryNextActions(
   return [...new Set(actions)].slice(0, 4);
 }
 
+/** Compact metadata-only document text: one leading LF, no trailing LF, shared emitter budget. */
+export function compactYamlDocument(value: Record<string, unknown>): string {
+  const text = growYamlDocument(() => value, [], Limits.RUN_DELIVERY_MODEL_MAX_BYTES);
+  return `\n${text.replace(/\n$/u, "")}`;
+}
+
+/** Only the closed read-only Recipe inspect literals become typed next; other advice stays opaque content. */
+export function nextActionMetadata(action: string, byteBudget: number): YamlPart {
+  const recognized = [
+    ["inspect target=recipes view=doctor", "doctor", false],
+    ["inspect target=recipes view=imports verbose=true", "imports", true],
+    ["inspect target=recipes view=summary verbose=true", "summary", true],
+  ] as const;
+  const match = recognized.find(([literal]) => literal === action);
+  if (match) {
+    const typed = { next: { tool: "inspect", target: "recipes", view: match[1], ...(match[2] ? { verbose: true } : {}) } };
+    return { full: typed, selected: typed };
+  }
+  const instruction = selectYamlField("instruction", action, byteBudget);
+  return { full: { next: instruction.full }, selected: { next: instruction.selected } };
+}
+
 /** Only these existing read-only inspection hints become action nodes; other advice stays content. */
 export function formatInspectionHint(action: string): string {
   if (action === "inspect target=recipes view=doctor") return formatInspectNextAction("recipes", "doctor");
@@ -474,21 +559,11 @@ export function formatInspectionHint(action: string): string {
 export function compactRecipeRegistry(
   summary: Record<string, unknown>,
 ): string {
-  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 count = (key: string, source: unknown) => Array.isArray(source) ? source.length : 0;
+  const active = count("active", summary.active), shadowed = count("shadowed", summary.shadowed);
+  const invalid = count("invalid", summary.invalid), disabled = count("disabled", summary.disabled);
+  const diagnostics = count("diagnostics", summary.diagnostics), drafts = count("drafts", summary.drafts);
+  const recommendations = count("recommendations", summary.recommendations);
   const skillCatalogPartial = summary.skill_recipe_catalog_partial === true;
   const currentPolicy = Array.isArray(summary.active)
     ? (summary.active as Array<Record<string, unknown>>).filter(
@@ -498,11 +573,13 @@ export function compactRecipeRegistry(
   const nextActions = Array.isArray(summary.next_actions)
     ? (summary.next_actions as string[])
     : [];
-  const fields = [formatMarkdownField("recipes", "registry"), ...Object.entries({ active, drafts, shadowed, invalid, disabled,
-    current_policy: currentPolicy, skill_catalog_partial: skillCatalogPartial, recommendations, diagnostics })
-    .map(([key, value]) => formatMarkdownField(key, String(value)))];
-  if (nextActions.length) fields.push(formatInspectionHint(nextActions[0]));
-  return "\n" + fields.join("\n");
+  const hint = nextActions.length ? nextActionMetadata(nextActions[0]!, Limits.RUN_DELIVERY_MODEL_MAX_BYTES) : undefined;
+  const render = (): Record<string, unknown> => ({ recipes: "registry", active, drafts, shadowed, invalid, disabled,
+    current_policy: currentPolicy, skill_catalog_partial: skillCatalogPartial, recommendations, diagnostics,
+    ...(hint ? hint.selected : {}) });
+  return hint
+    ? `\n${growYamlDocument(render, [hint], Limits.RUN_DELIVERY_MODEL_MAX_BYTES).replace(/\n$/u, "")}`
+    : compactYamlDocument(render());
 }
 
 export const DEFAULT_INSPECT_LINES = Limits.DEFAULT_INSPECT_LINES;

package/lib/tools-spawn.ts

@@ -84,21 +84,28 @@ function writeSpawnDraftRecipe(
 
 /** Compiler-owned pre-launch diagnostics only; selected caller values are not admitted Run ids. */
 function spawnGuardText(kind: "state_dir" | "namespace" | "id", value?: string): string {
-  const field = ToolsResponse.formatMarkdownField;
   const facts = kind === "state_dir"
-    ? [field("result", "unsupported field"), field("reason", "Run state is runtime-owned; run:<id> remains addressable and retention-safe.")]
-    : [field("result", kind === "namespace" ? "unsupported Run target" : "invalid Run target"), field("accepted_format", "run:<id>"),
-      ...(kind === "id" ? [field("id_rule", "nonempty ASCII letters, digits, underscore, dot or hyphen")] : [])];
-  const render = (selected?: string) => ToolsResponse.withLeadingLineBreak(
-    [field("field", kind === "state_dir" ? "state_dir" : "as"), ...(selected === undefined ? [] : [selected]), ...facts].join("\n"));
-  if (value === undefined) return render();
-  const wellFormed = value.isWellFormed();
-  if (wellFormed) {
-    const complete = render(field("value", value));
-    if (Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES) return complete;
+    ? { result: "unsupported field", reason: "Run state is runtime-owned; run:<id> remains addressable and retention-safe." }
+    : { result: kind === "namespace" ? "unsupported Run target" : "invalid Run target", accepted_format: "run:<id>",
+        ...(kind === "id" ? { id_rule: "nonempty ASCII letters, digits, underscore, dot or hyphen" } : {}) };
+  // Measure the shared emitter's own projection: an unfit selected value must become an omission, not a clip.
+  const render = (selected?: Record<string, unknown>): string | undefined => {
+    const rendered = ToolsResponse.renderYamlMetadata({ field: kind === "state_dir" ? "state_dir" : "as", ...(selected ?? {}), ...facts },
+      Limits.RUN_DELIVERY_MODEL_MAX_BYTES);
+    return rendered.state === "available"
+      ? ToolsResponse.withLeadingLineBreak(ToolsResponse.frameMetadataDocument(rendered.text))
+      : undefined;
+  };
+  const required = (selected?: Record<string, unknown>) => render(selected) ?? render()!;
+  const wellFormed = value !== undefined && value.isWellFormed();
+  if (value !== undefined && wellFormed) {
+    const complete = render({ value });
+    if (complete !== undefined && Buffer.byteLength(complete) <= Limits.RUN_DELIVERY_MODEL_MAX_BYTES) return complete;
   }
+  if (value === undefined) return required();
   const reason = wellFormed ? "response_too_large" : "malformed_selected_text";
-  return render(`- value: [${reason === "response_too_large" ? "omitted" : "unavailable"}]\n- value_omission:\n  - reason: ${reason}\n  - shown: 0\n  - omitted: 1\n  - total: 1`);
+  return required({ value: reason === "response_too_large" ? "[omitted]" : "[unavailable]",
+    value_omission: { reason, shown: 0, omitted: 1, total: 1 } });
 }
 
 function runIdFromTarget(target: string | undefined): string | undefined {

package/package.json

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

package/skills/actors/SKILL.md

@@ -78,11 +78,11 @@ Four locally authored Control guard errors use caller target/action/result recor
 
 Local spawn guards identify unsupported state_dir or invalid as with field/result and the selected caller value, not an admitted Run. Whole values fit16KiB or show field omission; malformed text is unavailable, not repaired. The host may reject unsupported state_dir by its own schema before the facade, so not every SDK validation error has AX text. This adds no launch, no-effects receipt, retry permission, generated identity or change to Recipe/session/post-launch failures.
 
-Successful normal register_tool receipts now use flat tool/result/source/callable_now fields and actual argument/warning sequences. A non-template source stays one exact literal; complete warnings take priority under16KiB, and whole-field/list omissions count only selected metadata, not hidden chars. Call advice remains opaque instruction, not automatic invocation; an unverified registration keeps its existing read-only tool-status next. Persistence is not callability: rely on the existing activation evidence, never substitute spawn or infer fresh host readiness from this layout. Transaction/errors/list/delete/draft and saved messages are not restyled by this slice.
+Fresh source normal register_tool receipts use bare block-YAML tool/result/source/callable_now fields and native argument/warning sequences, including empty argument lists. Normal callability remains Boolean and a non-template source stays one exact safely quoted scalar; complete warnings take priority under16KiB, and whole-field/list omissions count only selected metadata, not hidden chars. Call advice remains opaque instruction, not automatic invocation; an unverified registration keeps its existing read-only tool-status next. Persistence is not callability: rely on the existing activation evidence, never substitute spawn or infer fresh host readiness from this layout. Transaction/errors/list/delete/draft and saved messages are not restyled by this slice.
 
-Registry name listings now show the same selected sorted names as one list with coverage; an overlarge whole group is omitted rather than mislabeled empty, and malformed text is unavailable without repair. Counts describe selected names, not active/callable or the complete loaded-host registry. Deletion returns tool/result and preserves the manual reload note as opaque instruction: neither a current-map miss nor returned deletion proves full host removal or authorizes automatic reload/retry. Existing partial-effect exceptions and machine details remain unchanged.
+Fresh source registry listings and deletion receipts use bare block YAML. Listings preserve the same selected sorted names as a native sequence with coverage; empty selection is `[]`, an overlarge whole group is explicitly omitted rather than mislabeled empty, and malformed text is unavailable without repair. Counts describe selected names, not active/callable or the complete loaded-host registry. Deletion returns tool/result and preserves the manual reload note as opaque instruction: neither a current-map miss nor returned deletion proves full host removal or authorizes automatic reload/retry. Existing partial-effect exceptions and machine details remain unchanged. Combined compiled/package acceptance and loaded-host observation remain separate; an older runtime can still return the prior flat-list text.
 
-Draft-promotion success uses the same field grammar only for its original selected name/new-update/source=draft/callable display and one prior hint. It adds no default/body/argument/path or activation facts and does not become an ordinary registration transaction. A zero, opaque legacy display or unavailable field is not permission to infer readiness or repair callability. Whole scalar/action omissions stay explicit; invocation advice is content and only the existing read-only status hint may be typed. Promotion callbacks/display can still fail after writes with original errors; no automatic rollback/retry/reload follows.
+Fresh source draft-promotion success uses bare block YAML only for its original selected name/new-update/source=draft/callable display and one prior hint. The selected callable display remains a string, including quoted "false", "true" or "0", not reconstructed Boolean readiness. It adds no default/body/argument/path or activation facts and does not become an ordinary registration transaction. A zero, opaque legacy display or unavailable field is not permission to infer readiness or repair callability. Whole scalar/action omissions stay explicit; invocation advice is content and only the existing read-only status hint may be typed. Promotion callbacks/display can still fail after writes with original errors; no automatic rollback/retry/reload follows.
 
 Local register_tool source-mode refusals now identify field/result and actual replacement/reference/source-mode/inherited-field choices. Existing correction advice is instruction content, not automatic retry/update or a no-effects receipt. Supplied values are not echoed. The host owns clone/coercion/schema behavior before the facade, so use the actual outcome rather than assuming every wrong-typed request reaches a local AX guard. Other registry errors and all existing activation/transaction contracts remain unchanged.
 

package/skills/actors/references/diagnostics.md

@@ -6,9 +6,12 @@ Preserve the intended logical identity and diagnose through public pi-actors sur
 
 ```text
 inspect target=recipes view=status
+inspect target=recipes view=summary
 inspect target=recipes view=doctor identity=<skill>/<recipe>
 ```
 
+`summary` and `registry` name the same inspection path: identical facts, details and rendering for identical `verbose` input, so only `verbose` selects compact text versus structured output. The compact label still reports `recipes: registry`, and that label is not a separate view to request. Unsupported-view refusals list the actual accepted view names.
+
 Compact Recipe/Run/tool replies use flat AX fields without changing their existing evidence or authorization. Required/optional tool arguments are sequences, with none distinct from unknown. Focused source_location remains one exact literal value. Run compact replies still identify only run/view: request verbose for structured evidence, and tool schema remains structured even without verbose. Compact text selects at most one existing hint; only exact read-only recipes doctor/imports/summary inspection literals become typed next nodes. Other advice stays instruction content with its original Markdown, never executable metadata or authority to rerun work/register a tool. The full original next_actions array remains in details; do not infer callability from an advisory string.
 
 Use the focused doctor form for one intended identity. It reports active-Skill ownership, exact resolvability, partial-catalog state, component status, portable source location, resolution generation, any rejection, and bounded next actions. Use the unfiltered doctor only for catalog-wide diagnosis. A partial catalog does not imply every exact component is unavailable. If the owning Skill is inactive, report that blocker rather than locating and running its helper manually.