@zq-silk/yui 0.16.1 → 0.99.0

package/dist/executor/agentConfigurationProbe.js

@@ -9,6 +9,7 @@ import { codexClientInitialization } from "../runtime/codexAppServerRuntime.js";
 import { acpInitializeRequest, readAcpInitializeResult } from "../runtime/acpProtocol.js";
 import { handshakeObservationFrom } from "../runtime/agentRunConfiguration.js";
 import { YUI_VERSION } from "../version.js";
+import { configurationFieldsFromHelp, configurationFieldWarnings, STATIC_CONFIGURATION_NOTICE } from "./agentConfigurationFields.js";
 /**
  * Codex and Claude Code are configured by flags and their own files; neither
  * plan exchanges capabilities on connect. Saying so explicitly keeps a caller
@@ -20,8 +21,6 @@ const NO_HANDSHAKE = Object.freeze({
 });
 const MAX_OUTPUT_BYTES = 1024 * 1024;
 const PROCESS_TERMINATION_GRACE_MS = 100;
-const CODEX_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
-const CODEX_APPROVALS = ["untrusted", "on-request", "never"];
 const ACP_PROBE_REQUEST_ID = 1;
 export async function discoverCodexConfiguration(input) {
     const environment = configuredAgentLaunchEnvironment(input.agent, input.environment);
@@ -43,17 +42,35 @@ export async function discoverCodexConfiguration(input) {
             client.request("configRequirements/read", {}),
             client.request("modelProvider/capabilities/read", {})
         ]);
-        const requirements = object(requirementsResult)?.requirements;
-        const requirementRecord = object(requirements);
+        const requirements = requiredObject(requirementsResult, "Codex configuration requirements response").requirements;
+        const requirementRecord = requirements === null ? undefined
+            : requiredObject(requirements, "Codex configuration requirements");
         const allowedSandboxes = optionalStrings(requirementRecord?.allowedSandboxModes);
-        const allowedApprovals = optionalStrings(requirementRecord?.allowedApprovalPolicies);
+        const allowedApprovals = optionalApprovalChoices(requirementRecord?.allowedApprovalPolicies);
         const allowedWebSearchModes = optionalStrings(requirementRecord?.allowedWebSearchModes);
-        const capabilityRecord = object(providerCapabilities);
-        const webSearch = capabilityRecord?.webSearch === true
+        const capabilityRecord = requiredObject(providerCapabilities, "Codex Provider capabilities");
+        if (typeof capabilityRecord.webSearch !== "boolean") {
+            throw new Error("Codex Provider capabilities did not report webSearch.");
+        }
+        const webSearch = capabilityRecord.webSearch
             && (allowedWebSearchModes === undefined || allowedWebSearchModes.includes("live"));
-        const bypass = configurationFlagAvailable(help, "--dangerously-bypass-approvals-and-sandbox");
-        const sandboxChoices = intersectChoices(configurationHelpChoices(help, "--sandbox", CODEX_SANDBOXES), allowedSandboxes);
-        const approvalChoices = intersectChoices(configurationHelpChoices(help, "--ask-for-approval", CODEX_APPROVALS), allowedApprovals);
+        const fields = configurationFieldsFromHelp("codex", help).map(candidate => {
+            const allowed = candidate.key === "permission.sandbox" ? allowedSandboxes
+                : candidate.key === "permission.approval" ? allowedApprovals : undefined;
+            if (allowed !== undefined) {
+                const choices = candidate.choices.filter(choice => allowed.includes(choice.value));
+                return {
+                    ...candidate, choices, available: choices.length > 0,
+                    reason: `${candidate.reason} Native configuration requirements applied.${choices.length === 0 ? " No usable values were confirmed." : ""}`
+                };
+            }
+            if (candidate.key === "search")
+                return field("search", webSearch ? [choice("true")] : [], false, webSearch, webSearch ? "Native Provider capability and configuration requirements permit live web search."
+                    : "Live web search is unavailable or disallowed.");
+            if (candidate.key === "profile")
+                return codexProfileField(environment);
+            return candidate;
+        });
         return {
             schemaVersion: 1,
             agentId: input.agent.id,
@@ -61,21 +78,8 @@ export async function discoverCodexConfiguration(input) {
             ...(semanticVersion(version) === undefined ? {} : { cliVersion: semanticVersion(version) }),
             handshake: NO_HANDSHAKE,
             models,
-            fields: [
-                field("model", [], true),
-                field("effort", [], true),
-                field("permission.strategy", [
-                    choice("default"),
-                    ...(bypass ? [choice("bypass")] : []),
-                    choice("configured")
-                ], false, true, bypass ? undefined : "Codex bypass strategy is unavailable."),
-                field("permission.sandbox", sandboxChoices.map(choice), false),
-                field("permission.approval", approvalChoices.map(choice), false),
-                field("search", webSearch ? [choice("true")] : [], false, webSearch, webSearch ? undefined : "Live web search is unavailable or disallowed."),
-                field("profile", codexProfileChoices(environment).map(choice), true),
-                field("additionalDirectories", [], true)
-            ],
-            warnings: client.warnings()
+            fields,
+            warnings: [...client.warnings(), ...configurationFieldWarnings(fields)]
         };
     }
     finally {
@@ -105,9 +109,7 @@ export async function discoverClaudeConfiguration(input) {
     ]);
     const initialized = object(initialization);
     const models = array(initialized?.models, "Claude model catalog").map(claudeModel);
-    const permissionModes = configurationHelpChoices(help, "--permission-mode", []);
-    const bypass = configurationFlagAvailable(help, "--dangerously-skip-permissions");
-    const settingsSources = configurationHelpChoices(help, "--setting-sources", ["user", "project", "local"]);
+    const fields = configurationFieldsFromHelp("claude", help);
     return {
         schemaVersion: 1,
         agentId: input.agent.id,
@@ -115,22 +117,8 @@ export async function discoverClaudeConfiguration(input) {
         ...(semanticVersion(version) === undefined ? {} : { cliVersion: semanticVersion(version) }),
         handshake: NO_HANDSHAKE,
         models,
-        fields: [
-            field("model", [], true),
-            field("effort", [], true),
-            field("permission.strategy", [
-                choice("default"),
-                ...(bypass ? [choice("bypass")] : []),
-                choice("configured")
-            ], false, true, bypass ? undefined : "Claude bypass strategy is unavailable."),
-            field("permission.mode", permissionModes.map(choice), true),
-            field("permission.allowedTools", [], true),
-            field("permission.disallowedTools", [], true),
-            field("settingsSources", settingsSources.map(choice), false),
-            field("settingsFile", [], true),
-            field("additionalDirectories", [], true)
-        ],
-        warnings: []
+        fields,
+        warnings: configurationFieldWarnings(fields)
     };
 }
 async function listCodexModels(client) {
@@ -283,7 +271,7 @@ async function requestClaudeInitialization(command, args, cwd, environment, sign
 export async function discoverAcpConfiguration(input) {
     const environment = configuredAgentLaunchEnvironment(input.agent, input.environment);
     const negotiated = await requestAcpInitialization(input.agent.command, [...input.agent.baseArgs], input.cwd, environment, input.signal);
-    const warnings = [];
+    const warnings = [STATIC_CONFIGURATION_NOTICE];
     if (!negotiated.capabilities.loadSession) {
         warnings.push("This ACP Agent does not support `session/load`, so a managed Yui Turn "
             + "cannot survive a Provider restart.");
@@ -331,7 +319,7 @@ export async function discoverAcpConfiguration(input) {
             field("effort", [], true, true, "ACP selects reasoning effort with session/set_config_option, under the "
                 + "`thought_level` category. As with the model, the accepted values are "
                 + "negotiated per Session and verified at launch rather than listed here."),
-            field("permission.strategy", [choice("default"), choice("bypass"), choice("configured")], false, true, "`default` sends no mode, so the Agent's own default stands. `configured` "
+            field("permission.strategy", [choice("default"), choice("bypass"), choice("configured")], false, true, "Static Yui strategies: `default` sends no mode, so the Agent's own default stands. `configured` "
                 + "selects one exact mode the Agent offers. `bypass` applies the mode that "
                 + "grants unattended action, and only for an execution component Yui can "
                 + "identify — it is never guessed from a mode's name. None of these change "
@@ -573,47 +561,34 @@ function terminateProcess(child) {
     child.once("exit", () => { clearTimeout(force); });
     child.kill("SIGTERM");
 }
-export function codexProfileChoices(environment) {
+function codexProfileField(environment) {
     const root = environment.CODEX_HOME
         ?? join(environment.HOME ?? homedir(), ".codex");
     try {
         const profiles = object(parse(readFileSync(join(root, "config.toml"), "utf8")).profiles);
-        return Object.keys(profiles ?? {}).filter((name) => name.trim().length > 0 && !name.includes("\0")).sort();
-    }
-    catch {
-        return [];
+        const names = Object.keys(profiles ?? {}).filter((name) => name.trim().length > 0 && !name.includes("\0")).sort();
+        return field("profile", names.map(choice), true, undefined, "Local config.toml profile names, not a Provider enumeration; custom names remain explicit input.");
     }
-}
-export function configurationHelpChoices(help, flag, fallback) {
-    const lines = help.replace(/\r\n/g, "\n").split("\n");
-    const start = lines.findIndex((line) => line.includes(flag));
-    if (start < 0)
-        return [...fallback];
-    let end = start + 1;
-    while (end < lines.length && !/^\s{2,}(?:-[A-Za-z](?:,\s*)?|--)[\w-]/.test(lines[end] ?? "")) {
-        end += 1;
+    catch (error) {
+        const absent = error instanceof Error && "code" in error && error.code === "ENOENT";
+        return field("profile", [], true, absent ? undefined : false, absent
+            ? "No local config.toml; no profile names observed. Custom names remain explicit input."
+            : "Local config.toml could not be read or parsed; profile enumeration unavailable.");
     }
-    const section = lines.slice(start, end).join("\n");
-    const inline = /(?:\[possible values:\s*([^\]]+)\]|\(choices:\s*([^)]*)\))/i
-        .exec(section);
-    const declared = inline?.[1] ?? inline?.[2];
-    const bulletValues = declared === undefined && /Possible values:/i.test(section)
-        ? [...section.matchAll(/^\s*-\s*([\w.+-]+)\s*:/gm)].map((match) => match[1] ?? "")
-        : [];
-    const parsed = [...new Set((declared ?? bulletValues.join(","))
-            .replace(/["']/g, "")
-            .split(",")
-            .map((value) => value.trim().replace(/\.$/, ""))
-            .filter((value) => /^[\w.+-]+$/.test(value)))];
-    return parsed.length === 0 ? [...fallback] : parsed;
-}
-function configurationFlagAvailable(help, flag) {
-    return help.replace(/\r\n/g, "\n").split("\n").some((line) => line.includes(flag));
 }
-function intersectChoices(choices, allowed) {
-    return allowed === undefined
-        ? [...choices]
-        : choices.filter((candidate) => allowed.includes(candidate));
+function optionalApprovalChoices(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    // Current Codex also reports structured granular policies. They constrain
+    // configuration but cannot be selected by Yui's scalar approval input; do not
+    // reject the whole legitimate response or expand them into guessed aliases.
+    return array(value, "configuration approval requirements").flatMap(entry => {
+        if (typeof entry === "string")
+            return [requiredString(entry, "approval requirement")];
+        if (object(object(entry)?.granular) !== undefined)
+            return [];
+        throw new Error("Codex configuration approval requirement is invalid.");
+    });
 }
 function optionalStrings(value) {
     if (value === null || value === undefined)

package/dist/executor/agentExecutor.js

@@ -7,7 +7,7 @@ import { builtinAgentEndpointImplementation, validateAgentEndpointImplementation
 /** Recovery addresses retained execution identity, not a live Session grant.
  * A released Session cache can be absent while its native binding still needs
  * to be stopped. No active Session record is fabricated by this projection. */
-export function taskRoleControlTarget(set) {
+export function roleSessionControlTarget(set) {
     if (set == null)
         return undefined;
     const current = set.sessions[set.activeAgentId];
@@ -19,7 +19,10 @@ export function taskRoleControlTarget(set) {
     const agentId = fromBinding ? binding.accountScope : current?.agentId;
     if (nativeSessionId === undefined || agentId === undefined)
         return undefined;
-    const session = [...Object.values(set.sessions), ...(set.history ?? [])]
+    const history = set.owner.scope === "global"
+        ? Object.values(set.history ?? {})
+        : set.history ?? [];
+    const session = [...Object.values(set.sessions), ...history]
         .find(entry => entry.nativeSessionId === nativeSessionId && entry.agentId === agentId);
     const adapterId = session?.adapterId ?? (binding === null ? undefined : builtinAgentDriverRegistry().find(binding.providerNamespace)?.adapterId);
     return { nativeSessionId, agentId, adapterId, status: session?.status,

package/dist/executor/executorRegistry.js

@@ -176,15 +176,6 @@ export class ExecutorRegistry {
         });
         return deliveryReport(outcome);
     }
-    async notifyOperatorInputOnce(input) {
-        if (this.runtimePorts?.notifyOperatorInputOnce !== undefined) {
-            return this.runtimePorts.notifyOperatorInputOnce(input);
-        }
-        const probe = this.readiness(input.adapterId, "operator");
-        return this.tmux.sendRoleInputOnceIfReadyAsync === undefined
-            ? this.tmux.sendRoleInputOnceIfReady("operator", input.roleName, input.receiptId, input.text, probe)
-            : this.tmux.sendRoleInputOnceIfReadyAsync("operator", input.roleName, input.receiptId, input.text, probe);
-    }
     forgetPrepared(input) {
         for (const [deliveryId, prepared] of this.#prepared) {
             const delivery = prepared.delivery;

package/dist/executor/fileRoleLaunchPlanner.js

@@ -21,7 +21,7 @@ import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment } from "../runtime/taskRuntimeIsolation.js";
 import { planningRuntimeCwd } from "../storage/homeLayout.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { activeLiveRoleAgentSession, taskRoleControlTarget } from "./agentExecutor.js";
+import { activeLiveRoleAgentSession, roleSessionControlTarget } from "./agentExecutor.js";
 import { assertCodexLaunchOverridesAvailable, inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 import { effectiveRoleForLaunch, resolveEffectiveLaunch, roleSessionMayContinue } from "./effectiveLaunch.js";
 import { classifyWorkspacePreflight, formatWorkspacePreflightError } from "./workspacePreflightClassification.js";
@@ -69,9 +69,11 @@ export class FileRoleLaunchPlanner {
     }
     /** Recovery addresses the recorded Agent/Session, independent of delivery
      * admission, a missing worktree, or the old Endpoint code generation. */
-    planNativeControl(taskId, roleName) {
-        const set = this.store.getTaskRoleSessionSet(taskId, roleName);
-        const session = taskRoleControlTarget(set);
+    planNativeControl(owner) {
+        const set = owner.scope === "task"
+            ? this.store.getTaskRoleSessionSet(owner.taskId, owner.roleName)
+            : this.store.getGlobalRoleSessionSet(owner.roleName);
+        const session = roleSessionControlTarget(set);
         if (session?.adapterId !== "codex")
             throw new Error("Native metadata control requires a recorded Codex Session.");
         const configured = this.store.getConfiguredAgent(session.agentId);
@@ -79,9 +81,11 @@ export class FileRoleLaunchPlanner {
             throw new Error("The recorded native Agent connection is unavailable.");
         }
         const agent = configuredAgentToDefinition(configured);
-        const connection = this.store.listEvents(taskId).find(event => event.type === "runtime.native-connection-bound"
-            && event.payload.roleName === roleName && event.payload.agentId === session.agentId
-            && event.payload.nativeSessionId === session.nativeSessionId)?.payload;
+        const connection = owner.scope === "task"
+            ? this.store.listEvents(owner.taskId).find(event => event.type === "runtime.native-connection-bound"
+                && event.payload.roleName === owner.roleName && event.payload.agentId === session.agentId
+                && event.payload.nativeSessionId === session.nativeSessionId)?.payload
+            : undefined;
         return {
             command: configured.command, args: [...agent.baseArgs, "app-server", "proxy"], cwd: this.home,
             expectedAccountHome: connection?.nativeAccountHome,
@@ -758,10 +762,7 @@ function managedClaudeControlPlaneConfig(config, taskId, workItemId, runId) {
 }
 function isManagedYuiBashRule(rule) {
     const normalized = rule.trim();
-    return /^Bash\(yui(?:\s|:\*|\*|\))/u.test(normalized)
-        // Yui no longer writes a control-plane digest into a managed rule; this
-        // shape only clears one an earlier release left in a Provider config.
-        || /^Bash\(.*\s--yui-control\s/u.test(normalized);
+    return /^Bash\(yui(?:\s|:\*|\*|\))/u.test(normalized);
 }
 function canonicalPath(path) {
     const absolute = resolve(path);

package/dist/interaction/operatorPresentation.js

@@ -1,5 +1,5 @@
 /**
- * One mailbox batch becomes one short synthetic user message. The durable
+ * One mailbox batch becomes one short system notification. The durable
  * records remain the context authority; this wake text carries only stable
  * identities and exact CLI reads, never copied Task or Provider narrative.
  */
@@ -11,6 +11,7 @@ export function createOperatorBatchPresentation(batchId, items) {
         text: [
             "[Yui updates]",
             "Yui recorded the following durable updates. Inspect the referenced records and present only information that changes the user's understanding, authorization, or next action.",
+            "This notification is not a new execution assignment or authorization to replay prior operations.",
             ...items.flatMap(renderItem)
         ].join("\n")
     };

package/dist/message/messageContinuation.js

@@ -1,7 +1,8 @@
 import { isDeepStrictEqual } from "node:util";
-import { createRun, withRunContextSnapshot } from "../agentRun/agentRun.js";
+import { createRun } from "../agentRun/agentRun.js";
 import { createRunInput } from "../context/runInputContract.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot } from "../context/contextSnapshot.js";
+import { readRunContextSnapshot } from "../context/runContextPack.js";
 import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
 import { enqueueRoleRunDispatch } from "../coordination/workMailboxQueue.js";
 import { createTaskEvent } from "../event/taskEvent.js";
@@ -265,12 +266,9 @@ export function prepareMessageContinuations(store, taskId, now, roleName) {
             continue;
         const previous = store.listRuns(taskId).filter((run) => run.roleName === owner.roleName
             && run.workItemId === owner.workItemId && run.reviewRoundId === owner.reviewRoundId).at(-1);
-        const baselineRef = previous.inputs[0]?.input.contextSnapshotRef;
-        const baseline = baselineRef === undefined ? null : store.getContextSnapshot(taskId, baselineRef.id);
-        if (baseline === null || baseline.digest !== baselineRef.digest) {
-            markNotDelivered(store, message, "assignment-context-unavailable");
-            continue;
-        }
+        // Missing or drifted evidence is diagnosed by the caller; never reconstruct
+        // an Assignment from today's Task facts.
+        const baseline = readRunContextSnapshot(store, previous);
         const runId = store.nextRunId(taskId);
         const round = owner.reviewRoundId === undefined ? null : store.getReviewRound(taskId, owner.reviewRoundId);
         const continuingRound = round === null ? null : (() => {
@@ -300,9 +298,10 @@ export function prepareMessageContinuations(store, taskId, now, roleName) {
             resources, refs: resources.map(({ ref }) => ref)
         });
         store.saveContextSnapshot(snapshot);
-        const run = withRunContextSnapshot(createRun(runId, taskId, recipient.roleName, "resume", createRunInput({ source: { type: "yui", channel: "message-continuation" },
+        const run = createRun(runId, taskId, recipient.roleName, "resume", createRunInput({ source: { type: "yui", channel: "message-continuation" },
             directive: `Continue the same Assignment in its existing workspace. Read Messages ${batch.map((m) => m.id).join(", ")} from this exact Context. Message receipt is not implementation or acceptance.`,
-            deltaRefIds: batch.map((entry) => entry.id) }), now, copyAssignment(owner)), contextSnapshotRef(snapshot), batch.map((entry) => entry.id));
+            contextSnapshotRef: contextSnapshotRef(snapshot),
+            deltaRefIds: batch.map((entry) => entry.id) }), now, copyAssignment(owner));
         store.saveRun(run);
         store.saveActiveRun(run);
         if (continuingRound !== null)

package/dist/observability/executionAudit.js

@@ -678,13 +678,6 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
     })();
     const storage = (() => {
         try {
-            let stateJsonBytes = UNSUPPORTED;
-            try {
-                stateJsonBytes = statSync(join(home, "state.json")).size;
-            }
-            catch {
-                stateJsonBytes = UNSUPPORTED;
-            }
             let databaseBytes = UNSUPPORTED;
             try {
                 databaseBytes = statSync(join(home, "yui.db")).size;
@@ -693,15 +686,13 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 databaseBytes = UNSUPPORTED;
             }
             return ok({
-                stateJsonBytes,
                 databaseBytes,
                 // The audit aggregates history; live db integrity is the status
                 // command's job (it runs PRAGMA quick_check). Report presence/size
                 // and the authoritative backend, not a duplicate health probe.
                 databaseHealth: UNSUPPORTED,
                 backend: resolveTaskStoreBackendForHome(home),
-                runtimeDirBytes: ports.directorySize(join(home, "runtime")) ?? UNSUPPORTED,
-                deploymentsBytes: ports.directorySize(join(home, "runtime", "deployments")) ?? UNSUPPORTED
+                runtimeDirBytes: ports.directorySize(join(home, "runtime")) ?? UNSUPPORTED
             });
         }
         catch (error) {

package/dist/observability/runtimeIdentity.js

@@ -165,9 +165,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
         || storage.status === "unsupported"
         ? storage.currentVersion
         : UNSUPPORTED;
-    const statePath = join(home, "state.json");
-    const statePresent = ports.exists(statePath);
-    const stateBytes = ports.fileSize(statePath);
     const dbPath = join(home, "yui.db");
     const dbPresent = ports.exists(dbPath);
     const dbBytes = ports.fileSize(dbPath);
@@ -221,14 +218,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
             remediation: "Preserve this Home for diagnosis and restore a known-good backup."
         });
     }
-    if (ports.exists(join(home, "schema.json"))) {
-        findings.push({
-            code: "ignored-legacy-storage-manifest",
-            severity: "warning",
-            message: "schema.json is legacy metadata and is not a storage authority.",
-            remediation: "This file is not used. Preserve or archive it separately after inspecting its contents."
-        });
-    }
     if (dbPresent && dbHealth !== null && dbHealth !== "ok") {
         findings.push({
             code: "database-unhealthy",
@@ -237,14 +226,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
             remediation: "Preserve this Home for diagnosis and initialize a new Home."
         });
     }
-    if (statePresent) {
-        findings.push({
-            code: "ignored-historical-store",
-            severity: "warning",
-            message: "state.json is present but is not read or written by the current store.",
-            remediation: "Keep it only as read-only historical evidence or archive it outside the active Home."
-        });
-    }
     const rawWorkerFlag = ports.env.YUI_STORE_WORKER;
     if (rawWorkerFlag !== undefined && !["0", "1", "false", "true"].includes(rawWorkerFlag.toLowerCase())) {
         findings.push({
@@ -261,10 +242,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
         minimumStorageVersion: MIN_SUPPORTED_STORAGE_VERSION,
         configuredBackend,
         workerEnabled,
-        physicalStateJson: {
-            present: statePresent,
-            bytes: stateBytes ?? UNSUPPORTED
-        },
         physicalDatabase: {
             present: dbPresent,
             bytes: dbBytes ?? UNSUPPORTED,

package/dist/output/agentConfigurationPresentation.js

@@ -23,7 +23,9 @@ export function renderAgentConfigurationCatalog(resolved) {
         // query rather than a deliberate boundary, so it is shown either way.
         field.available === false
             ? `unavailable${field.reason === undefined ? "" : `: ${field.reason}`}`
-            : field.reason === undefined ? "available" : `available: ${field.reason}`,
+            : field.available === true
+                ? `available${field.reason === undefined ? "" : `: ${field.reason}`}`
+                : field.reason ?? "Native support not confirmed",
         field.allowCustom ? "yes" : "no"
     ]);
     const sections = [
@@ -39,7 +41,7 @@ export function renderAgentConfigurationCatalog(resolved) {
         agentModelOptionsSummary(catalog),
         ...(fieldRows.length === 0
             ? []
-            : [renderTable("Other runtime configuration", [
+            : [renderTable("Configuration fields (native observations and static adapter contracts)", [
                     { header: "Field", minWidth: 12, maxWidth: 30 },
                     { header: "Values", minWidth: 18, maxWidth: 58 },
                     { header: "Status", minWidth: 10, maxWidth: 38 },

package/dist/release/releaseHandover.js

@@ -131,14 +131,14 @@ async function activateLocked(ports, locked) {
         catch (rollbackError) {
             return {
                 outcome: "aborted", phase: "preflight",
-                message: `Host compatibility failed: ${messageOf(error)}; rollback failed: ${messageOf(rollbackError)}`,
+                message: `Storage preflight failed: ${messageOf(error)}; rollback failed: ${messageOf(rollbackError)}`,
                 action: "No candidate was started and the release pointer is unchanged. Preserve the fence and inspect the old Controller.",
                 recoverable: true
             };
         }
         return {
             outcome: "aborted", phase: "preflight",
-            message: `Fenced compatibility preflight failed: ${messageOf(error)}`,
+            message: `Fenced storage preflight failed: ${messageOf(error)}`,
             action: "The old Controller is serving again; the active release and Home are unchanged.",
             recoverable: true
         };

package/dist/release/releaseIdempotencyStore.js

@@ -38,41 +38,19 @@ import { writeTextFileAtomically } from "../storage/durableFile.js";
  * an unpersisted success into an ambiguous/fail-closed outcome; reporting
  * success for an effect whose dedup record did not land would let a crash
  * re-run the effect.
- *
- * Unsupported layouts
- * -------------------
- * The per-key `schemaVersion: 1` layout is the only supported format. A
- * legacy whole-map file (`release-idempotency.json`) from an unsupported
- * older layout is never auto-migrated: it fails closed with a bounded
- * diagnostic so the operator can inspect and clean it up deliberately.
  */
 export const RELEASE_IDEMPOTENCY_SCHEMA_VERSION = 1;
 const DIRECTORY_NAME = "release-idempotency";
-const LEGACY_FILE_NAME = "release-idempotency.json";
 export function createFileReleaseIdempotencyStore(home, now = () => new Date()) {
     const directory = join(home, DIRECTORY_NAME);
-    const legacyPath = join(home, LEGACY_FILE_NAME);
     function recordPath(key) {
         // encodeURIComponent is injective and leaves only Linux-filename-safe
         // characters unescaped, so distinct keys never collide on disk.
         return join(directory, `${encodeURIComponent(key)}.json`);
     }
-    /**
-     * Fail closed when an unsupported legacy whole-map file is present.
-     * The per-key layout is the only supported format; a whole-map file
-     * from an unsupported older layout must not be silently trusted.
-     */
-    function rejectLegacyLayout() {
-        if (existsSync(legacyPath)) {
-            throw new Error(`unsupported legacy release idempotency layout: ${legacyPath} ` +
-                `(whole-map file). Remove it after inspecting its contents; ` +
-                `the per-key schemaVersion 1 layout is the only supported format.`);
-        }
-    }
     return {
         async load(key) {
             try {
-                rejectLegacyLayout();
                 const path = recordPath(key);
                 if (!existsSync(path))
                     return undefined;
@@ -88,7 +66,6 @@ export function createFileReleaseIdempotencyStore(home, now = () => new Date())
                 throw new Error(`release idempotency store only records succeeded effects: ${effect.outcome}`);
             }
             try {
-                rejectLegacyLayout();
                 const record = Object.freeze({
                     schemaVersion: RELEASE_IDEMPOTENCY_SCHEMA_VERSION,
                     key,

package/dist/release/releaseWorkflowPorts.js

@@ -2,6 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { chmod, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { runUpdate } from "../cli/updateOrchestrator.js";
+import { renderUpdateResult } from "../cli/updateCommand.js";
 import { activatedControllerEntrypoint } from "../cli/updatePorts.js";
 import { runProjectCommand } from "../commands/projectCommands.js";
 import { restartFileTaskController, stopFileTaskController } from "../controller/clientRuntime.js";
@@ -116,11 +117,14 @@ export function createReleaseWorkflowPorts(deps) {
                     // Best-effort persistence; the effect may still succeed.
                 }
                 const result = runUpdate(inspectedPorts, { home: deps.home });
+                // Preserve cleanup/restore receipts in the existing step log, even
+                // when the binary result is success or a later phase is blocked.
+                const updateLog = renderUpdateResult(result);
                 if (result.outcome === "updated" || result.outcome === "already-current") {
                     return {
                         outcome: "succeeded",
                         externalId: result.version,
-                        logs: [`cli-update: ${result.outcome} (${result.version})`]
+                        logs: [updateLog]
                     };
                 }
                 if (result.outcome === "aborted" && !result.recoverable) {
@@ -143,7 +147,7 @@ export function createReleaseWorkflowPorts(deps) {
                     if (result.controllerOwnershipUnknown === true) {
                         return {
                             outcome: "timeout",
-                            logs: [`cli-update Controller ownership unknown at phase ${result.phase}: ${result.message}`]
+                            logs: [updateLog]
                         };
                     }
                     // P1-2 (rr22): persist the EXACT activation target (the resolved
@@ -154,13 +158,13 @@ export function createReleaseWorkflowPorts(deps) {
                     return {
                         outcome: "timeout",
                         ...(identity === undefined ? {} : { externalIdentity: identity }),
-                        logs: [`cli-update ambiguous at phase ${result.phase}: ${result.message}`]
+                        logs: [updateLog]
                     };
                 }
                 return {
                     outcome: "failed",
                     error: `cli-update aborted at phase ${result.phase}: ${result.message}`,
-                    logs: [`cli-update: ${result.message}`]
+                    logs: [updateLog]
                 };
             }
             case "controller-replace": {