@llblab/pi-actors 0.56.1 → 0.57.0

package/dist/lib/tools-message.js

@@ -14,82 +14,96 @@ function asRecord(value) {
         ? value
         : {};
 }
-const controlField = ToolsResponse.formatMarkdownField;
+const CONTROL_BUDGET = Limits.RUN_DELIVERY_MODEL_MAX_BYTES - 1;
+function controlMetadata(value) {
+    return ToolsResponse.renderYamlMetadata(value, CONTROL_BUDGET).text;
+}
+/** One opaque selected scalar as a whole value or an explicit whole-field omission, never a clip. */
+function controlSelected(key, value) {
+    return ToolsResponse.selectYamlField(key, value, CONTROL_BUDGET);
+}
+/** Compiler-selected option strings stay a native sequence; malformed selections stay unavailable. */
+function controlChoices(options) {
+    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 = { [key]: wellFormed ? "[omitted]" : "[unavailable]",
+        [key + "_omission"]: { reason: wellFormed ? "response_too_large" : "malformed_selected_text",
+            shown: 0, omitted: values.length, total: values.length } };
+    const full = !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, order) {
+    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) {
+    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 = { next: { instruction: wellFormed ? "[omitted]" : "[unavailable]",
+            instruction_omission: { reason: wellFormed ? "response_too_large" : "malformed_selected_text", shown: 0, omitted: 1, total: 1 } } };
+    const full = 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(request, result, options) {
     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 = [];
-        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, choices) => 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) {
-    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 = () => ({ ...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. */
 export function compactControlResult(request, result) {
-    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 = {};
     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) => 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 = () => ({ ...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, result) {
     if (result.stopped === true)
@@ -198,16 +212,13 @@ export function createControlToolDefinition(deps = {}) {
                     }
                     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 = () => ({ ...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/dist/lib/tools-response.d.ts

@@ -13,6 +13,20 @@ export type YamlMetadataRendering = {
 };
 /** Pure selected-metadata formatting, not admission or authority. */
 export declare function renderYamlMetadata(value: unknown, byteBudget: number): YamlMetadataRendering;
+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 declare function selectYamlNode(key: string, value: unknown, byteBudget: number, total?: number): YamlPart;
+/** Opaque selected text or string sequence; malformed selections stay unavailable without repair. */
+export declare function selectYamlField(key: string, value: string | readonly string[], byteBudget: number): YamlPart;
+/** Grow whole selected fields in priority order while the complete document still fits. */
+export declare function growYamlDocument(render: () => Record<string, unknown>, order: readonly YamlPart[], byteBudget: number): string;
+/** Uncapped UI-only flat metadata; never borrow a model-output allowance for notices. */
+export declare function formatYamlNotice(value: Record<string, string | number | boolean>): string;
+/** Close one rendered YAML header; a separate opaque body gets exactly one delimiter pair. */
+export declare function frameMetadataDocument(header: string, body?: string): string;
 export declare function formatMarkdownField(key: string, value: string, depth?: number): string;
 export declare function formatInspectNextAction(target: string, view: string, verbose?: boolean): string;
 export declare function formatLiteralBlock(value: string): string;
@@ -42,6 +56,10 @@ export declare function spawnMetadataText(value: unknown, verbose: boolean | und
 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[];
+/** Compact metadata-only document text: one leading LF, no trailing LF, shared emitter budget. */
+export declare function compactYamlDocument(value: Record<string, unknown>): string;
+/** Only the closed read-only Recipe inspect literals become typed next; other advice stays opaque content. */
+export declare function nextActionMetadata(action: string, byteBudget: number): YamlPart;
 /** Only these existing read-only inspection hints become action nodes; other advice stays content. */
 export declare function formatInspectionHint(action: string): string;
 export declare function compactRecipeRegistry(summary: Record<string, unknown>): string;

package/dist/lib/tools-response.js

@@ -101,6 +101,62 @@ export function renderYamlMetadata(value, byteBudget) {
         return { state: "unavailable", reason: "metadata_invalid" };
     }
 }
+/** One selected metadata node, kept whole or covered by a field/group omission. */
+export function selectYamlNode(key, value, byteBudget, total = 1) {
+    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, value, byteBudget) {
+    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, order, byteBudget) {
+    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) {
+    const selected = {};
+    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, body) {
+    return body === undefined ? header : `---\n${header}---\n${body}`;
+}
 export function formatMarkdownField(key, value, depth = 0) {
     const indent = "  ".repeat(depth);
     return /[\r\n]/u.test(value)
@@ -464,6 +520,26 @@ export function recipeRegistryNextActions(summary, view) {
     }
     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) {
+    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, byteBudget) {
+    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],
+    ];
+    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) {
     if (action === "inspect target=recipes view=doctor")
@@ -475,21 +551,11 @@ export function formatInspectionHint(action) {
     return formatMarkdownField("instruction", action);
 }
 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 count = (key, source) => 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.filter((entry) => entry.current_policy).length
@@ -497,11 +563,12 @@ export function compactRecipeRegistry(summary) {
     const nextActions = Array.isArray(summary.next_actions)
         ? summary.next_actions
         : [];
-    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 = () => ({ 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/dist/lib/tools-spawn.js

@@ -52,22 +52,29 @@ function writeSpawnDraftRecipe(input, meta) {
 }
 /** Compiler-owned pre-launch diagnostics only; selected caller values are not admitted Run ids. */
 function spawnGuardText(kind, value) {
-    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) => 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)
+        ? { 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) => {
+        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) => 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) {
     if (!target)

package/dist/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.

package/docs/README.md

@@ -20,6 +20,7 @@ Living index of all documentation in the `/docs` directory.
 
 - [windows-process-observation.md](./windows-process-observation.md) — User-approved recovery preparation: passing inert Windows x64 MI child experiment, reviewed unadmitted raw codec and artifact preparation contract; broader profile evidence, unsigned asset distribution and default activation remain separate gates
 - [run-supervision.md](./run-supervision.md) — Accepted future supervision contract and implemented AX/evidence slices, with same-logical-session file research and candidate-bound acceptance; the next selective AX/runtime release does not enable deadlines, independent owner-loss supervision or public completion streams
+- [inactive-foundations-inventory.md](./inactive-foundations-inventory.md) — Reachability and package evidence for packaged-but-unactivated supervision, stream-numbering and native foundations, distinguishing reviewed runtime dependencies from optional ones; no removal decision, nothing activated
 - [composition-transport.md](./composition-transport.md) — Recorded design intake: portable JSONL Recipe bundles and optional host CodeMode orchestration, with launch/outcome separation; bundle grammar and asset scope remain unadopted and outside the current UX/AX release
 
 ## Project Surfaces

package/docs/actor-inspector.md

@@ -104,7 +104,7 @@ Esc is the notification's only dismissal action. Action, confirmation, tab and s
 
 Both notification and Kill dialogs have a two-terminal-column left inset for content and one blank row above and below it. Their borders use borderAccent; keys use accent, descriptions use borderAccent and hint groups are separated by borderAccent frame segments, through the same formatter as the main Inspector. On the lowest available height, decorative blank rows yield to readable text, pinned safety and choices. Narrow confirmations may stack the two choices and wrap the pinned warning rather than clipping either. Both dialogs use the terminal's default background, not a pale theme fill or hard-coded black. Borders and foreground status colors remain; selected confirmation buttons retain their focus background. Popup composition masks only its own rectangle and never inserts a data row or shifts the document, stripes, selection or scroll. The last normal Inspector frame is frozen underneath the modal; resizing reuses those captured cells without new evidence reads. Closing resumes normal rendering/invalidation, not a renewed ownership/native guarantee.
 
-Only feedback from the existing Kill callback path pins closure: unconfirmed and No automatic retry outside the popup's scrollable text. This records entry into an action-port path, not native actuation or proven no effects. Local guards do not gain those action uncertainty labels. Routine cancellation is silent: Esc/n or Enter on Cancel closes the confirmation and immediately returns to the same Inspector, without a Notice or an extra dismissal. The popup exposes only the existing selected message, not raw Error/cause or lost180/160-unit tails. Fresh Kill producers now wrap selected values in AX action/result/state-or-diagnostic/closure records. Domain180-unit normalization/trim and overlay160-unit normalization/slice remain the source stages; their already discarded Markdown/tails/causes are not recovered. A pair crossing the prefix end retracts one code unit; a malformed selected preview is unavailable with unknown loss rather than repaired text. Dynamic legacy previews state unproven upstream completeness/privacy, never an exact private-tail count. Compiler refusals add no invented legacy omission. Message/result shape and actuation stay unchanged; saved journals are not rewritten. Source/installed tests cover full opaque access, narrow columns/low rows, scroll/return/selector behavior, no action replay, original Error.message observation and unchanged selected caught-error bytes. Actual operator-loaded colored-terminal/phone acceptance remains separate.
+Only feedback from the existing Kill callback path pins closure: unconfirmed and No automatic retry outside the popup's scrollable text. This records entry into an action-port path, not native actuation or proven no effects. Local guards do not gain those action uncertainty labels. Routine cancellation is silent: Esc/n or Enter on Cancel closes the confirmation and immediately returns to the same Inspector, without a Notice or an extra dismissal. The popup exposes only the existing selected message, not raw Error/cause or lost180/160-unit tails. Fresh Kill producers now wrap selected values in AX action/result/state-or-diagnostic/closure records. Domain180-unit normalization/trim and overlay160-unit normalization/slice remain the source stages; their already discarded Markdown/tails/causes are not recovered. A pair crossing the prefix end retracts one code unit; a malformed selected preview is unavailable with unknown loss rather than repaired text. Dynamic legacy previews state unproven upstream completeness/privacy, never an exact private-tail count. Compiler refusals add no invented legacy omission. Message/result shape and actuation stay unchanged; saved journals are not rewritten. Popup color recognition matches only the exact leading AX header pair: current producer results render failed/rejected as error and unavailable state-only results as warning, while authored text that merely contains those lines stays warning because no body label, message tail or legacy prose becomes an action, identity or closure fact. Source/installed tests cover full opaque access, narrow columns/low rows, scroll/return/selector behavior, no action replay, original Error.message observation and unchanged selected caught-error bytes, plus real producer-result classification for both colors and unanchored-lookalike rejection. Actual operator-loaded colored-terminal/phone acceptance remains separate.
 
 ## Kill confirmation
 
@@ -132,4 +132,4 @@ Run kill revalidates owner and generation through the canonical lifecycle path.
 
 ## Scope
 
-The Actor Inspector treats each Run as a concrete actor instance. It does not expose group conversations, peer addresses, routing, or communication topology. Use `inspect target=runtime view=status|runs|triage`, `inspect target=recipes view=status|summary|doctor|imports|reviews`, and `inspect target=tool:<name> view=status|schema` for non-Run management targets. See [Management Inspection](./inspection.md) for exact applicability and authorization boundaries.
+The Actor Inspector treats each Run as a concrete actor instance. It does not expose group conversations, peer addresses, routing, or communication topology. Use `inspect target=runtime view=status|runs|triage`, `inspect target=recipes view=status|summary|doctor|imports|reviews` (`registry` is the same view as `summary`), and `inspect target=tool:<name> view=status|schema` for non-Run management targets. See [Management Inspection](./inspection.md) for exact applicability and authorization boundaries.

package/docs/agent-experience.md

@@ -110,6 +110,14 @@ state: running
 launch_kind: spawn
 ```
 
+### Current rollout status
+
+Migrated owned projections emit block YAML (bare when metadata-only, one delimiter pair before a separate selected body): Control receipts, guards and the awaiting-dispatch notice; inspect refusals, compact Run/runtime/tool/Recipe success views and the explicit `tool:* view=schema` text; registry registration/listing/deletion/draft receipts and all locally authored refusals; registered-command success bodies and failure exit-status documents; the local usage/argument-repair heading; pre-launch spawn guards; runtime callback failure, completion recovery/acceptance, steer diagnostics and the shutdown teardown report; watcher and retirement notices; and fresh completion/attention captures.
+
+Deliberately still on their earlier layout: registry activation/promotion/deletion notices and runtime startup warnings (flat report/category fields, separately scoped), Inspector UI feedback and chrome (UI text whose recognition is verified separately, not model-facing metadata), and every retained historical completion/packet encoding, which replays its exact saved bytes. Machine `details`, verbose JSON, canonical journals and literal source files are not presentation targets.
+
+The rollout audit for this state found no second or missing host-separation blank line on a migrated model-facing path and no runtime-authored object dump or `- key:` pseudo-record left in the migrated set; the shared helpers `withLeadingLineBreak`, `formatToolText`, `compactYamlDocument` and `spaceToolError` are the single framing owners, guarded by `tests/tools-response.test.ts`. Loaded terminal/phone acceptance and any service-carrier change remain separate gates.
+
 ## Service Framing Is Not Authored Content
 
 The target readable runtime output contains no pi-actors HTML-comment transport framing. Audit each service field against actual consumers first: remove unnecessary fresh data rather than relocating the whole existing payload. If content-carried service data is necessary, prefer its minimum in the response's block-YAML header metadata, not an HTML tail. Separately review the actual Pi storage/model/UI path and preserve the required functions; the current mechanism is not itself a requirement. This does not adopt a new kernel interface or assert that hidden `details` alone is sufficient. Prove persisted replay, model-context acceptance/recovery, full-content binding, independent header/body boundaries, fallback and fixed budgets before switching.
@@ -192,7 +200,7 @@ The [runtime output projection map](output-projection-map.md) names the audited
 
 The prepared `tools-response.ts` `renderYamlMetadata` foundation uses the directly declared `yaml@2.9.0` public API for selected own-data mappings/sequences. It emits bare YAML without invocation spacing or body processing, preserves scalar types/strings and refuses unsupported or over-budget whole values. Its execution ceiling is 49,152 bytes and supported nesting is at most 64 levels; these are not caller allowances or drop-in compatibility for larger existing budgets. Preflight bounds scalar/node traversal, not atomic key enumeration or arbitrary Proxy execution. Focused parser/property and shared response-owner tests cover this foundation; compact asynchronous launch receipts are the first production caller. Other surfaces and loaded-host acceptance remain separately staged; full spawn-verbose shares the final YAML style without inheriting this bounded emitter's limits.
 
-The following is the current pre-unification implementation inventory, not a set of alternate adopted output styles. Existing flat records, literal JSON fields, verbose JSON and retained-layout HTML compiler frames remain code facts until their owned rollout changes; the target above does not restyle or relabel stored text. This standard spans surfaces, not a new library domain. Control compact-result/public-error remains locally implemented and source/npm verified using flat records, no duplicated run namespace, stage/reuse distinctions, typed selective inspect next nodes and opaque multiline values. Launch model/thinking groups use the concise `model` and `thinking` labels and preserve their actual source/value relationship; compact launch navigation now remains one whole native YAML value or explicit whole-row omission within16KiB including invocation-response spacing. Full spawn-verbose in source and normally built packages uses the legacy once-only JSON selection followed by clone-only YAML, without a new fixed byte/depth cap. Absent selected JSON, malformed selected text or recoverable post-selection failures withhold the whole projection with an attributable no-auto-repeat warning; original selection throws and structured details remain unchanged. Source/unit and installed compiled response checks, the strict ordinary-metadata source/packed completion journey, and all three source/packed navigation owners are accepted within their bounded domains. Native assertions remain indirect proof, not current global absence. Owning Skill byte parity does not establish a loaded-host change. The older field/inspect-action primitives remain with their unmigrated consumers; compact launch serialization now uses the YAML metadata primitive. Structured/verbose results, exact dispatch/private error causes and old completion handoff text retain their contracts. Fresh ordinary source completion admission captures canonical AX with the private completion_yaml_core_v1 layout: index-first YAML, independently rendered raw Markdown and cut-local [N characters omitted]. The minimal ordinary hint binds whole content to the YAML core, whose relative lengths derive header/body/marker boundaries without fresh HTML tails. Retained completion_frontmatter_v1 hints keep their complete ranges and original compiler frames; neither hint name is a public selector. Only valid compiler headers can hide whole reference/location rows. Markers remain literal and body-authored labels never become metadata/actions. Expansion and invalid/missing hints reveal full original text. These checks establish display consistency, not authentication, source/read scope or acceptance; display line-ending/tab handling never rewrites saved content. Routine state-equivalent summaries remain in the journal, not the new model content; meaningful summaries, loss/redaction/unavailability and reference coverage remain visible. Exact source/generation/parent bindings, whole references and fresh48KiB/64row limits include hidden technical data; retained codecs keep16KiB. The postprivacy byte budget is divided equally between candidate rows: roughly48KiB for one,24KiB each for two,16KiB each for three, less encoded service overhead. Whole admitted text uses result only when it fits without known upstream clipping; otherwise preview uses the safe prefix with exact retained-source omissions. There is no fixed16KiB result/2KiB preview cap and no render-time source IO or reallocation. Already-retained packets keep their exact captured bytes; pre-record messages keep the host renderer and retained record messages keep their original verified view. The Pi boundary recognizes the strict whole YAML core for ordinary source records, or original closed markers/anchored headers for retained captures, after private details are stripped, preserving exact owned-context acceptance without interpreting authored body labels. Actual actors guidance describes this implemented fresh-capture route; this is not a claim that a loaded host was reloaded. Fresh source urgent-steer captures use typed YAML metadata and a separate raw selected body before saving immutable envelope.content: complete final-message fitting and whole reference sequences retain16KiB/eight-slot bounds. Ordinary attention remains unbounded; bounded source/compiled/actual-default acceptance does not establish loaded-host acceptance. Existing envelopes are not reinterpreted, and no older new-message default remains. Fresh ordinary notify/followup uses one AX formatter in the existing sink: the same opaque checkpoint/body and whole first-eight reference projection, without borrowing steer's shared byte cap or changing routing. Committed history keeps its exact text; the retired presentation selector is not a compatibility API. Fresh read-time agent Trace preview leaves now also use boundary U+2026, exact admitted normalized-retained-turn omissions and separately unknown upstream loss, without changing the160UTF-16 source allowance, identifiers/chronology, detail/source data or public JSON schema. Malformed text is unknown, not repaired; no journal capture aspect is minted for a derived current read. New urgent admission/send/recovery diagnostics now also use event/attention/stage AX records, opaque raw240-unit previews and unknown loss while their persisted message-only evidence stays unchanged. A failed send leaves delivery/presentation unconfirmed, and unknown/conflicting queued recovery does not force replay. Fresh non-runtime explicit inspection also uses AX records: unchanged Run/view headers, tool activation/argument sequences and Recipe registry/focused-doctor facts, whole portable source literals and one selected hint. Only the three existing closed read-only Recipe inspect literals become typed next; other advisory strings remain opaque instruction values with full next_actions retained in unchanged details/verbose JSON. Existing body/scope/budget/default-status contracts stay independent. Compact runtime status/runs/triage now also presents only its existing facts/counts as AX fields, with full owned inventory independent from bounded verbose navigation and bounded triage rows. Core callback/completion/recovery/teardown notices use opaque fields and explicit receipt/report stages without altering their source, errors, acceptance or native authority. Producer-owned watcher/retirement notices now also use AX: whole literal paths and opaque diagnostics preserve raw signature/dedup/rearm behavior, while returned stop/reported cancellation/skip/failure remain non-closure reports with exact existing optional-notifier/error observation semantics. Inspector document/detail rendering now uses flat semantic fields, real sequence lists and opaque literal terminal values, with ephemeral compiler-label provenance instead of parsing authored colon/bullet lines as metadata. Separator-preserving native-column wrapping keeps whole text/references, source values, root stripes and existing identity/chronology/navigation/source bounds. Empty containers remain typed values; terminal line-ending/tab display policy does not rewrite source. Ten locally authored inspect refusals now also use AX fields and true supported-value sequences, preserving their original guards and Error/dependency behavior. Only the two already-guided tool failures retain typed read-only next actions. New local error text shares16KiB including public spacing; variable fields/actions are whole or explicitly counted omitted without shortening targets, reading raw private lengths or wrapping unowned exceptions. Session/source/dependency errors keep their separate owners and old catches rather than being globally restyled. Inspector Kill confirmation now also uses captured run/state/action AX fields with whole-value paging, while both choices and closure: unconfirmed remain pinned at narrow/low viewports. Read-only PgUp/PgDn preserves original Cancel/choice/confirmation/generation behavior and adds no actuation or source permission. Inspector Kill cancellation only closes the dialog; successful actions use the selected Run's visible status without a second Notice. Failures/refusals/uncertainty remain visible, and notifications on other surfaces are not suppressed. Remaining Inspector feedback shows the complete selected opaque message directly in a modal popup over unchanged data rows, without i prefix/command or another reader. Esc dismisses; only physical overflow scrolls within that same popup. Kill uses the same centered rectangle compositor. Both use terminal-default backgrounds rather than a theme fill, two-column left content insets and top/bottom blank spacing, plus the Inspector's shared frame/key/description color grammar. On space-constrained heights, safety/choices/readable text take priority over decorative blanks. They keep the captured underlay stable through resize/invalidation and resume ordinary refresh on close, without fresh evidence/native authority. Action-port feedback pins closure uncertainty/no automatic retry without inferring native effects from message text. Fresh Kill producers now use a shared pure selected-value AX formatter: domain180-unit normalization/trim and overlay160-unit normalization/slice remain, while a cut pair retracts one unit and malformed selected text is unknown/unavailable. Dynamic legacy values state upstream completeness/privacy unproven, with unknown local clipping markers rather than private-tail counts; compiler refusals add no fake loss. ok/callback/getter/coercion/error semantics and old success suppression stay unchanged, and the popup's anchored header recognition affects color only. This does not recover discarded Markdown/causes or create a saved capture version. Trace table rows now mark actual column/line gaps with native ellipsis while preserving full selected item/detail, and compact warning captions keep incomplete-history/non-lifetime/unavailable-rank meaning visible at narrow widths. This is UI preview loss only, not new source/private character counts, rank/identity changes or a generic selector/fit rewrite. Four locally authored Control pre-dispatch guards now also use caller target/action/result and actual supported/available-action sequences: whole target/list groups fit16KiB including public spacing or carry field/entry omission counts, while malformed selected text is unavailable without repair. Original guard/getter/join/coercion observations, plain Error/host-error behavior and all unowned/dispatch exceptions stay separate; no input/status/correlation/retry/no-effects or new dispatch authority follows. Three local spawn pre-launch guards now use field/result and opaque selected caller value rather than inventing an admitted Run: unsupported state_dir, missing run: namespace and invalid id. Whole valid-scalar values fit16KiB or are omitted; malformed selections are unavailable, without repair or source/private-tail counts. Original input/method/coercion/launch behavior stays separate. The real host still rejects unsupported state_dir through its own unchanged schema before the facade, so this does not claim all SDK validation errors are AX. Namespace/id guard errors retain real host isError behavior. Successful normal registration/update-or-persisted receipts now use original tool/outcome/source/callable facts, actual required/optional argument and warning lists, a whole fenced non-template source and one prior hint. Invocation advice stays opaque instruction; only the producer-known unverified tool-status hint is typed next. Complete safety warnings have first budget priority; all variable fields/groups/actions fit16KiB including public spacing or show whole selected-field/entry omission, with malformed selections unavailable without repair. Original post-effect warning/argument/coercion/boundary observations and all transaction/details/notify/error behavior remain. This is not new callability, host activation, rollback or invocation authority. Registry current-name listing and deletion returns now also use AX: original sorted/captured names are a whole selected group with shown/omitted/total coverage, never a new page/work quota or active/callable/global registry claim. Overlarge groups are wholly omitted and malformed groups unavailable without raw-key re-coercion or repair. Deletion keeps original selected tool/result and the exact operator reload note as opaque instruction; current-map not found stays a returned result, not a new error or orphan-file cleanup. Lookup/file/deactivation/notify/errors/details remain unchanged, including post-effect failures. Draft promotion success now also uses only its prior selected name/new-update/source=draft/exact callable display/first hint as AX. It does not inherit ordinary-registration args/warnings/boundary facts or change its admission/rollback policy. Original template String conversions remain after notify, including zero/object/Symbol behavior and post-effect failures. Whole scalars/actions fit16KiB or are explicitly omitted/unavailable; only the closed producer-known read-only status hint is typed, and invocation advice is opaque. Machine details/bytes and later activation observations remain unchanged. Four local registration source-mode errors now use only compiler-owned field/result records and actual replacement/reference-form/source-mode/inherited-field sequences, with previous correction advice as opaque instruction. No supplied source values, new helper/wrapper or changed guard/descriptor/getter/trim order. The host still owns cloning, coercion and schema validation: rejected extra/object fields need not reach these AX guards, while numeric input may normalize and preserve a non-error unnamed list result. This is not new schema, no-effects or automatic retry authority. Three ordinary name/source refusals now also use AX: invalid normalized name without raw caller echo, reserved selected-name value whole or explicitly omitted/unavailable, and missing source only for a new registration with actual source choices/opaque prior advice. Original normalization/reserved-set/resolution/lookup/blocker/fault order stays unchanged; empty-name listing, existing-tool update with retained source and dependency blocker text are not reinterpreted. SDK clone/coercion/schema remains separate. Ordinary and draft duplicate-registration refusals now show their original selected name whole/omitted/unavailable plus the original update advice as opaque instruction; distinct authoritative-file/Map/exists/blocker/update predicates and original single display coercion stay unchanged. No overwrite/retry, body-read or no-effects authority follows. Template-shape helper errors now also use fixed template/result records for nested Recipe objects, empty sequences and unsupported types, with actual supported-kind lists/opaque old correction and no supplied value echo. Getter/Array/reference/key/expand semantics and external errors stay exact; null/undefined/deletion/retained-source behavior and SDK coercion remain separate. Authored-Recipe non-object defaults, missing command description, null-at-authoring and missing-final-template constants now also use fixed field/result, without new value echoes or changes to args/from/description/default/retained-source order. Front deletion, inheritance and Schema/dependency errors keep separate ownership. The delegated runtime-owned-default-key refusal now shows only its original first selected key, defaults/result and opaque old correction. Full copy/find order, eight-name membership and the delegated-only condition remain; no all-key/value disclosure, early rejection optimization or new retry authority. Two draft-path refusals now show only their old captured allowed root or resolved path as complete dynamically fenced literals, or explicit whole-reference omission/unavailability under16KiB. Refused caller path stays undisplayed in root refusal; existing containment/exists/getter/error behavior and opaque prior advice are unchanged, not new absence/native proof. Public from-normalization refusal now also uses only its old displayed source/reason/legacy summary/doctor advice as AX, preserving inner errors, catch/coercion/method order and source/hint disagreement. Source is a whole literal; reason/summary preserve opaque Markdown, and advice is instruction content. Monotone whole-field omission/unavailability fits16KiB without parsing old summary text, adding causes/counts or widening source/catch authority. Normal candidate-admission refusal now also projects only its old source-conditional displayed source/joined diagnostics/legacy summary/advice, preserving branch/coercion/join and pre-Error order. Existing4096-unit upstream admission diagnostic clipping is not widened or repaired; selected summary fields are whole/omitted/unavailable under16KiB, with fitting diagnostics first. This adds no admission policy, full diagnostics/source proof or rollback/readiness authority. Draft raw/candidate invalid-Recipe errors now likewise expose only old optional reason/joined diagnostics with fixed draft/result, preserving separate read/diagnose, truthiness/coercion, Error-before-join and legacy diagnostic bounds. No new path/body, cause, reader, policy or retry follows; whole opaque values fit16KiB or are explicitly omitted/unavailable. Outer registration transaction errors now also project only old post-cleanup stage/resolution-generation/legacy summary/error, preserving cleanup and fallible template order exactly. Resolution generation is not a Run epoch; fitting surfaced error has budget priority and opaque inner rollback/advice text is not a new guarantee. No replay, extra cause/source read or changed transaction policy follows. Registry activation/promotion/deletion notices now also use report/tool AX fields for only old compiler report identity/name, preserving callback order/info type/faults and real hasUI gate. Report wording is not callable/full-host-removal proof. UI text stays literal with native wrapping; no borrowed model16KiB cap, whole well-formed values retained and malformed selected name unavailable. RPC delivery remains fire-and-forget, and loaded UI acceptance stays separate. Recipe registry watcher warning/refresh messages now also use report and opaque instruction constants only, preserving their distinct direct ctx.ui.notify calls (no added hasUI gate), failure dedup/pending-load/callback fault order and old default-root report rather than new verified metadata. Runtime startup warnings now also preserve true category sequences/singletons and whole opaque selected entries through the existing shared field primitive. Original suppression/classification/map/push/join/coercion precedes new projection from compiler-known slots, not parsed authored labels. Trailing LF/no UI cap remain; malformed selected warning is unavailable and old doctor advice is opaque instruction. Native Inspector Run controls retain their selection grammar rather than forced Markdown: producer-specific column gaps now carry ellipses, and complete selected_run_id context uses existing Recipe/Control literal documents, separately from authored fields. Generic fit/composition, source reads, keys and action targets remain unchanged; loaded colored-terminal/phone acceptance stays gated. Other errors/notifications/public owners remain separately scoped, with live client acceptance independent. Reuse the cohesive owner of each projection:
+The following is the current pre-unification implementation inventory, not a set of alternate adopted output styles. Existing flat records, literal JSON fields, verbose JSON and retained-layout HTML compiler frames remain code facts until their owned rollout changes; the target above does not restyle or relabel stored text. This standard spans surfaces, not a new library domain. Control compact-result/public-error is now bare block-YAML metadata with native option sequences, whole selected values or explicit omission records under the existing16KiB cap, no duplicated run namespace, stage/reuse distinctions, typed selective inspect next nodes and opaque advice scalars; verbose JSON remains the machine path. Launch model/thinking groups use the concise `model` and `thinking` labels and preserve their actual source/value relationship; compact launch navigation now remains one whole native YAML value or explicit whole-row omission within16KiB including invocation-response spacing. Full spawn-verbose in source and normally built packages uses the legacy once-only JSON selection followed by clone-only YAML, without a new fixed byte/depth cap. Absent selected JSON, malformed selected text or recoverable post-selection failures withhold the whole projection with an attributable no-auto-repeat warning; original selection throws and structured details remain unchanged. Source/unit and installed compiled response checks, the strict ordinary-metadata source/packed completion journey, and all three source/packed navigation owners are accepted within their bounded domains. Native assertions remain indirect proof, not current global absence. Owning Skill byte parity does not establish a loaded-host change. The older field/inspect-action primitives remain with their unmigrated consumers; compact launch serialization now uses the YAML metadata primitive. Structured/verbose results, exact dispatch/private error causes and old completion handoff text retain their contracts. Fresh ordinary source completion admission captures canonical AX with the private completion_yaml_core_v1 layout: index-first YAML, independently rendered raw Markdown and cut-local [N characters omitted]. The minimal ordinary hint binds whole content to the YAML core, whose relative lengths derive header/body/marker boundaries without fresh HTML tails. Retained completion_frontmatter_v1 hints keep their complete ranges and original compiler frames; neither hint name is a public selector. Only valid compiler headers can hide whole reference/location rows. Markers remain literal and body-authored labels never become metadata/actions. Expansion and invalid/missing hints reveal full original text. These checks establish display consistency, not authentication, source/read scope or acceptance; display line-ending/tab handling never rewrites saved content. Routine state-equivalent summaries remain in the journal, not the new model content; meaningful summaries, loss/redaction/unavailability and reference coverage remain visible. Exact source/generation/parent bindings, whole references and fresh48KiB/64row limits include hidden technical data; retained codecs keep16KiB. The postprivacy byte budget is divided equally between candidate rows: roughly48KiB for one,24KiB each for two,16KiB each for three, less encoded service overhead. Whole admitted text uses result only when it fits without known upstream clipping; otherwise preview uses the safe prefix with exact retained-source omissions. There is no fixed16KiB result/2KiB preview cap and no render-time source IO or reallocation. Already-retained packets keep their exact captured bytes; pre-record messages keep the host renderer and retained record messages keep their original verified view. The Pi boundary recognizes the strict whole YAML core for ordinary source records, or original closed markers/anchored headers for retained captures, after private details are stripped, preserving exact owned-context acceptance without interpreting authored body labels. Actual actors guidance describes this implemented fresh-capture route; this is not a claim that a loaded host was reloaded. Fresh source urgent-steer captures use typed YAML metadata and a separate raw selected body before saving immutable envelope.content: complete final-message fitting and whole reference sequences retain16KiB/eight-slot bounds. Ordinary attention remains unbounded; bounded source/compiled/actual-default acceptance does not establish loaded-host acceptance. Existing envelopes are not reinterpreted, and no older new-message default remains. Fresh ordinary notify/followup uses one AX formatter in the existing sink: the same opaque checkpoint/body and whole first-eight reference projection, without borrowing steer's shared byte cap or changing routing. Committed history keeps its exact text; the retired presentation selector is not a compatibility API. Fresh read-time agent Trace preview leaves now also use boundary U+2026, exact admitted normalized-retained-turn omissions and separately unknown upstream loss, without changing the160UTF-16 source allowance, identifiers/chronology, detail/source data or public JSON schema. Malformed text is unknown, not repaired; no journal capture aspect is minted for a derived current read. New urgent admission/send/recovery diagnostics now also use event/attention/stage AX records, opaque raw240-unit previews and unknown loss while their persisted message-only evidence stays unchanged. A failed send leaves delivery/presentation unconfirmed, and unknown/conflicting queued recovery does not force replay. Fresh non-runtime explicit inspection also uses bare block-YAML metadata: unchanged Run/view headers, tool activation/argument sequences and Recipe registry/focused-doctor facts, whole selected source/identity/advice scalars or explicit whole-field omission, native counts/flags and one typed read-only hint or opaque `next.instruction`. The explicit `tool:* view=schema` text is generated definition metadata in the same bare YAML form with native parameter nodes when renderable; unsupported/over-ceiling schemas retain the exact legacy JSON fallback. Compact argument sequences are whole or explicitly omitted/unavailable. Verbose views bypass compact formatting and machine details keep their JSON contracts. Only the three existing closed read-only Recipe inspect literals become typed next; other advisory strings remain opaque instruction values with full next_actions retained in unchanged details/verbose JSON. Existing body/scope/budget/default-status contracts stay independent. Compact runtime status/runs/triage now also presents only its existing facts/counts as AX fields, with full owned inventory independent from bounded verbose navigation and bounded triage rows. Fresh locally owned runtime notices (callback failure, completion recovery/acceptance, steer admission/delivery/recovery diagnostics and the shutdown teardown report) are now bare block-YAML metadata with explicit receipt/report stages and native counters. UI-only notices keep complete well-formed selected fields without borrowing the model byte/depth ceilings; malformed selected text is explicitly unavailable. Existing steer preview bounds, source/errors, acceptance and native authority are unchanged. Producer-owned watcher/retirement notices now also use uncapped bare block-YAML metadata: whole selected literal paths and opaque diagnostics preserve raw signature/dedup/rearm behavior, while returned stop/reported cancellation/skip/failure remain non-closure reports with exact existing optional-notifier/error observation semantics. Inspector document/detail rendering now uses flat semantic fields, real sequence lists and opaque literal terminal values, with ephemeral compiler-label provenance instead of parsing authored colon/bullet lines as metadata. Separator-preserving native-column wrapping keeps whole text/references, source values, root stripes and existing identity/chronology/navigation/source bounds. Empty containers remain typed values; terminal line-ending/tab display policy does not rewrite source. Ten locally authored inspect refusals now render bare block-YAML metadata with true supported-value sequences, field-local whole-field coverage records and one typed read-only next, preserving their original guards and Error/dependency behavior. Only the two already-guided tool failures retain typed read-only next actions. New local error text shares16KiB including public spacing; variable fields/actions are whole or explicitly counted omitted without shortening targets, reading raw private lengths or wrapping unowned exceptions. Session/source/dependency errors keep their separate owners and old catches rather than being globally restyled. Inspector Kill confirmation now also uses captured run/state/action AX fields with whole-value paging, while both choices and closure: unconfirmed remain pinned at narrow/low viewports. Read-only PgUp/PgDn preserves original Cancel/choice/confirmation/generation behavior and adds no actuation or source permission. Inspector Kill cancellation only closes the dialog; successful actions use the selected Run's visible status without a second Notice. Failures/refusals/uncertainty remain visible, and notifications on other surfaces are not suppressed. Remaining Inspector feedback shows the complete selected opaque message directly in a modal popup over unchanged data rows, without i prefix/command or another reader. Esc dismisses; only physical overflow scrolls within that same popup. Kill uses the same centered rectangle compositor. Both use terminal-default backgrounds rather than a theme fill, two-column left content insets and top/bottom blank spacing, plus the Inspector's shared frame/key/description color grammar. On space-constrained heights, safety/choices/readable text take priority over decorative blanks. They keep the captured underlay stable through resize/invalidation and resume ordinary refresh on close, without fresh evidence/native authority. Action-port feedback pins closure uncertainty/no automatic retry without inferring native effects from message text. Fresh Kill producers now use a shared pure selected-value AX formatter: domain180-unit normalization/trim and overlay160-unit normalization/slice remain, while a cut pair retracts one unit and malformed selected text is unknown/unavailable. Dynamic legacy values state upstream completeness/privacy unproven, with unknown local clipping markers rather than private-tail counts; compiler refusals add no fake loss. ok/callback/getter/coercion/error semantics and old success suppression stay unchanged, and the popup's anchored header recognition affects color only. This does not recover discarded Markdown/causes or create a saved capture version. Trace table rows now mark actual column/line gaps with native ellipsis while preserving full selected item/detail, and compact warning captions keep incomplete-history/non-lifetime/unavailable-rank meaning visible at narrow widths. This is UI preview loss only, not new source/private character counts, rank/identity changes or a generic selector/fit rewrite. Four locally authored Control pre-dispatch guards now also use caller target/action/result and actual supported/available-action sequences: whole target/list groups fit16KiB including public spacing or carry field/entry omission counts, while malformed selected text is unavailable without repair. Original guard/getter/join/coercion observations, plain Error/host-error behavior and all unowned/dispatch exceptions stay separate; no input/status/correlation/retry/no-effects or new dispatch authority follows. Synchronous registered-command failures now present compiler-owned exit_code/killed metadata as bare block YAML, followed by a delimited header before the unchanged selected stderr/stdout bodies (or metadata-only when no stream text was selected); trim/tail selection, truncation notices, temp-file publication and exact executor failures are unchanged. The pre-dispatch argument-repair error now likewise puts owned tool/required/optional facts in a closed YAML header and keeps the original validation prose plus the verbatim JSON invocation example as unparsed body text, and local spawn pre-launch guards use bare block YAML with one whole selected value or an explicit omission record. Three local spawn pre-launch guards present field/result and a whole or explicitly omitted selected caller value as bare block YAML rather than inventing an admitted Run: unsupported state_dir, missing run: namespace and invalid id. Whole valid-scalar values fit16KiB or are omitted; malformed selections are unavailable, without repair or source/private-tail counts. Original input/method/coercion/launch behavior stays separate. The real host still rejects unsupported state_dir through its own unchanged schema before the facade, so this does not claim all SDK validation errors are AX. Namespace/id guard errors retain real host isError behavior. Successful normal registration/update-or-persisted receipts now use original tool/outcome/source/callable facts, actual required/optional argument and warning lists, a whole fenced non-template source and one prior hint. Invocation advice stays opaque instruction; only the producer-known unverified tool-status hint is typed next. Complete safety warnings have first budget priority; all variable fields/groups/actions fit16KiB including public spacing or show whole selected-field/entry omission, with malformed selections unavailable without repair. Original post-effect warning/argument/coercion/boundary observations and all transaction/details/notify/error behavior remain. This is not new callability, host activation, rollback or invocation authority. Registry current-name listing and deletion returns now also use AX: original sorted/captured names are a whole selected group with shown/omitted/total coverage, never a new page/work quota or active/callable/global registry claim. Overlarge groups are wholly omitted and malformed groups unavailable without raw-key re-coercion or repair. Deletion keeps original selected tool/result and the exact operator reload note as opaque instruction; current-map not found stays a returned result, not a new error or orphan-file cleanup. Lookup/file/deactivation/notify/errors/details remain unchanged, including post-effect failures. Draft promotion success now also uses only its prior selected name/new-update/source=draft/exact callable display/first hint as AX. It does not inherit ordinary-registration args/warnings/boundary facts or change its admission/rollback policy. Original template String conversions remain after notify, including zero/object/Symbol behavior and post-effect failures. Whole scalars/actions fit16KiB or are explicitly omitted/unavailable; only the closed producer-known read-only status hint is typed, and invocation advice is opaque. Machine details/bytes and later activation observations remain unchanged. Locally authored registry mode/name/source/template/draft/transaction refusals now render as bare block-YAML metadata documents with compiler-literal fields, native choice sequences, and each opaque selected value whole or explicitly omitted under the unchanged16KiB cap; authored text stays scalar content with escaped line breaks rather than becoming keys or actions. Registry activation/promotion/deletion notice text remains flat report/tool fields, outside this refusal migration. No supplied source values, new helper/wrapper or changed guard/descriptor/getter/trim order. The host still owns cloning, coercion and schema validation: rejected extra/object fields need not reach these AX guards, while numeric input may normalize and preserve a non-error unnamed list result. This is not new schema, no-effects or automatic retry authority. Three ordinary name/source refusals now also use AX: invalid normalized name without raw caller echo, reserved selected-name value whole or explicitly omitted/unavailable, and missing source only for a new registration with actual source choices/opaque prior advice. Original normalization/reserved-set/resolution/lookup/blocker/fault order stays unchanged; empty-name listing, existing-tool update with retained source and dependency blocker text are not reinterpreted. SDK clone/coercion/schema remains separate. Ordinary and draft duplicate-registration refusals now show their original selected name whole/omitted/unavailable plus the original update advice as opaque instruction; distinct authoritative-file/Map/exists/blocker/update predicates and original single display coercion stay unchanged. No overwrite/retry, body-read or no-effects authority follows. Template-shape helper errors now also use fixed template/result records for nested Recipe objects, empty sequences and unsupported types, with actual supported-kind lists/opaque old correction and no supplied value echo. Getter/Array/reference/key/expand semantics and external errors stay exact; null/undefined/deletion/retained-source behavior and SDK coercion remain separate. Authored-Recipe non-object defaults, missing command description, null-at-authoring and missing-final-template constants now also use fixed field/result, without new value echoes or changes to args/from/description/default/retained-source order. Front deletion, inheritance and Schema/dependency errors keep separate ownership. The delegated runtime-owned-default-key refusal now shows only its original first selected key, defaults/result and opaque old correction. Full copy/find order, eight-name membership and the delegated-only condition remain; no all-key/value disclosure, early rejection optimization or new retry authority. Two draft-path refusals now show only their old captured allowed root or resolved path as complete dynamically fenced literals, or explicit whole-reference omission/unavailability under16KiB. Refused caller path stays undisplayed in root refusal; existing containment/exists/getter/error behavior and opaque prior advice are unchanged, not new absence/native proof. Public from-normalization refusal now also uses only its old displayed source/reason/legacy summary/doctor advice as AX, preserving inner errors, catch/coercion/method order and source/hint disagreement. Source is a whole literal; reason/summary preserve opaque Markdown, and advice is instruction content. Monotone whole-field omission/unavailability fits16KiB without parsing old summary text, adding causes/counts or widening source/catch authority. Normal candidate-admission refusal now also projects only its old source-conditional displayed source/joined diagnostics/legacy summary/advice, preserving branch/coercion/join and pre-Error order. Existing4096-unit upstream admission diagnostic clipping is not widened or repaired; selected summary fields are whole/omitted/unavailable under16KiB, with fitting diagnostics first. This adds no admission policy, full diagnostics/source proof or rollback/readiness authority. Draft raw/candidate invalid-Recipe errors now likewise expose only old optional reason/joined diagnostics with fixed draft/result, preserving separate read/diagnose, truthiness/coercion, Error-before-join and legacy diagnostic bounds. No new path/body, cause, reader, policy or retry follows; whole opaque values fit16KiB or are explicitly omitted/unavailable. Outer registration transaction errors now also project only old post-cleanup stage/resolution-generation/legacy summary/error, preserving cleanup and fallible template order exactly. Resolution generation is not a Run epoch; fitting surfaced error has budget priority and opaque inner rollback/advice text is not a new guarantee. No replay, extra cause/source read or changed transaction policy follows. Registry activation/promotion/deletion notices now also use report/tool AX fields for only old compiler report identity/name, preserving callback order/info type/faults and real hasUI gate. Report wording is not callable/full-host-removal proof. UI text stays literal with native wrapping; no borrowed model16KiB cap, whole well-formed values retained and malformed selected name unavailable. RPC delivery remains fire-and-forget, and loaded UI acceptance stays separate. Recipe registry watcher warning/refresh messages now also use report and opaque instruction constants only, preserving their distinct direct ctx.ui.notify calls (no added hasUI gate), failure dedup/pending-load/callback fault order and old default-root report rather than new verified metadata. Runtime startup warnings now also preserve true category sequences/singletons and whole opaque selected entries through the existing shared field primitive. Original suppression/classification/map/push/join/coercion precedes new projection from compiler-known slots, not parsed authored labels. Trailing LF/no UI cap remain; malformed selected warning is unavailable and old doctor advice is opaque instruction. Native Inspector Run controls retain their selection grammar rather than forced Markdown: producer-specific column gaps now carry ellipses, and complete selected_run_id context uses existing Recipe/Control literal documents, separately from authored fields. Generic fit/composition, source reads, keys and action targets remain unchanged; loaded colored-terminal/phone acceptance stays gated. Other errors/notifications/public owners remain separately scoped, with live client acceptance independent. Reuse the cohesive owner of each projection:
 
 - `tools-message.ts`: Control receipts, refusals and conservative public error text.
 - `tools-response.ts`, `tools-spawn.ts`, `tools-local.ts`: shared response primitives and launch/runtime-tool presentation.