@zq-silk/yui 0.16.1 → 1.0.0-alpha

package/dist/controller/updateReconciliation.js

@@ -3,6 +3,14 @@ import { acquireHomeLifecycleLock } from "../core/controllerServer.js";
 import { cleanControllerResource } from "./resourceCleanupLinux.js";
 import { scanControllerResourceInventory } from "./resourceInventoryLinux.js";
 const MAX_RECONCILIATION_PASSES = 4;
+export class UpdateControllerReconciliationError extends Error {
+    result;
+    constructor(message, result, options) {
+        super(message, options);
+        this.result = result;
+        this.name = "UpdateControllerReconciliationError";
+    }
+}
 /**
  * Reconcile only Controller-owned resources for the Home being updated.
  *
@@ -12,21 +20,49 @@ const MAX_RECONCILIATION_PASSES = 4;
  * and inode fingerprints. Agent, tmux, app, and foreign-Home resources are
  * deliberately outside this operation.
  */
-export async function reconcileControllerResourcesForUpdate(home, environment = process.env, tmuxBin) {
+export async function reconcileControllerResourcesForUpdate(home, environment = process.env, tmuxBin, ports = {
+    scan: scanControllerResourceInventory,
+    clean: cleanControllerResource,
+    acquireLock: acquireHomeLifecycleLock
+}) {
     const resolvedHome = resolve(home);
-    const releaseLock = await acquireHomeLifecycleLock(resolvedHome, {
-        removeStaleOwner: true
-    });
     const cleaned = new Set();
-    try {
-        for (let pass = 0; pass < MAX_RECONCILIATION_PASSES; pass += 1) {
-            const snapshot = await scanControllerResourceInventory({
-                currentHome: resolvedHome,
-                scope: "current",
-                environment,
+    const attempts = [];
+    let remaining = [];
+    let observedAt;
+    let observationError;
+    let lockReleaseError;
+    const result = () => ({
+        home: resolvedHome, cleaned: [...cleaned], attempts: [...attempts], remaining: [...remaining],
+        ...(observedAt === undefined ? {} : { observedAt }),
+        ...(observationError === undefined ? {} : { observationError }),
+        ...(lockReleaseError === undefined ? {} : { lockReleaseError })
+    });
+    const scan = async () => {
+        try {
+            const snapshot = await ports.scan({
+                currentHome: resolvedHome, scope: "current", environment,
                 ...(tmuxBin === undefined ? {} : { tmuxBin })
             });
+            if (snapshot.scope === "current" && resolve(snapshot.currentHome) === resolvedHome) {
+                remaining = controllerResources(snapshot, resolvedHome);
+                observedAt = snapshot.observedAt;
+            }
             assertCertainSnapshot(snapshot, resolvedHome);
+            observationError = undefined;
+            return snapshot;
+        }
+        catch (error) {
+            observationError = messageOf(error);
+            throw error;
+        }
+    };
+    let releaseLock;
+    let failure;
+    try {
+        releaseLock = await ports.acquireLock(resolvedHome, { removeStaleOwner: true });
+        for (let pass = 0; pass < MAX_RECONCILIATION_PASSES; pass += 1) {
+            const snapshot = await scan();
             const resources = controllerResources(snapshot, resolvedHome);
             const controllers = resources.filter(({ kind }) => kind === "controller");
             const current = controllers.filter(({ state }) => state === "current");
@@ -50,36 +86,52 @@ export async function reconcileControllerResourcesForUpdate(home, environment =
             }
             const candidates = [...historicalCleanup, ...staleArtifactCleanup];
             if (candidates.length === 0) {
-                return { cleaned: [...cleaned] };
+                break;
             }
             for (const candidate of candidates) {
                 try {
-                    await cleanControllerResource(candidate, { environment, ...(tmuxBin === undefined ? {} : { tmuxBin }) });
+                    await ports.clean(candidate, { environment, ...(tmuxBin === undefined ? {} : { tmuxBin }) });
                     cleaned.add(candidate.id);
+                    attempts.push({ resource: candidate, outcome: "cleaned" });
+                    remaining = remaining.filter(({ id }) => id !== candidate.id);
                 }
                 catch (error) {
                     // A concurrent exact cleanup that already reached the desired state
                     // is harmless. Anything still present or reclassified is a real
                     // ownership change and must remain a user-visible blocker.
-                    const afterFailure = await scanControllerResourceInventory({
-                        currentHome: resolvedHome,
-                        scope: "current",
-                        environment
-                    });
-                    assertCertainSnapshot(afterFailure, resolvedHome);
+                    const attempt = { resource: candidate, outcome: "unknown", error: messageOf(error) };
+                    attempts.push(attempt);
+                    // If this observation also fails, keep BOTH failures and the exact
+                    // attempted identity. Failure to observe absence is never success.
+                    const afterFailure = await scan();
                     if (!controllerResources(afterFailure, resolvedHome).some(({ id }) => id === candidate.id)) {
                         cleaned.add(candidate.id);
+                        attempts[attempts.length - 1] = { ...attempt, outcome: "absent" };
                         continue;
                     }
                     throw reconciliationBlocked(`resource ${candidate.id} changed or could not be cleaned: ${messageOf(error)}`);
                 }
             }
+            if (pass === MAX_RECONCILIATION_PASSES - 1) {
+                throw reconciliationBlocked("Controller resources did not converge after bounded cleanup");
+            }
         }
-        throw reconciliationBlocked("Controller resources did not converge after bounded cleanup");
+    }
+    catch (error) {
+        failure = error;
     }
     finally {
-        await releaseLock();
+        try {
+            await releaseLock?.();
+        }
+        catch (error) {
+            lockReleaseError = messageOf(error);
+            failure ??= error;
+        }
     }
+    if (failure !== undefined)
+        throw new UpdateControllerReconciliationError(messageOf(failure), result(), { cause: failure });
+    return result();
 }
 function assertCertainSnapshot(snapshot, resolvedHome) {
     if (snapshot.scope !== "current"

package/dist/coordination/workMailbox.js

@@ -2,7 +2,7 @@ import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 const RECENT_DEDUPE_KEY_LIMIT = 256;
 export function createWorkMailbox(target) {
     return {
-        schemaVersion: 5,
+        schemaVersion: 1,
         target: copyTarget(target),
         nextSequence: 1,
         processing: null,
@@ -13,8 +13,8 @@ export function createWorkMailbox(target) {
 export function validateWorkMailbox(value) {
     const mailbox = record(value, "WorkMailbox");
     exact(mailbox, ["schemaVersion", "target", "nextSequence", "processing", "pending", "recentDedupeKeys"], "WorkMailbox");
-    if (mailbox.schemaVersion !== 5)
-        throw new Error("WorkMailbox must use schemaVersion 5");
+    if (mailbox.schemaVersion !== 1)
+        throw new Error("WorkMailbox must use schemaVersion 1");
     const target = parseTarget(mailbox.target);
     const nextSequence = requireInteger(mailbox.nextSequence, 1, "WorkMailbox nextSequence");
     const processing = mailbox.processing === null ? null : parseProcessing(mailbox.processing);
@@ -38,7 +38,7 @@ export function validateWorkMailbox(value) {
         }
     }
     return {
-        schemaVersion: 5,
+        schemaVersion: 1,
         target,
         nextSequence,
         processing,

package/dist/core/controllerIdentity.js

@@ -0,0 +1,25 @@
+import { compareStorageVersions, isStorageVersion } from "../storage/storageVersions.js";
+export function isControllerIdentity(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.executablePath === "string" && record.executablePath.length > 0
+        && Array.isArray(record.args) && record.args.every(arg => typeof arg === "string")
+        && typeof record.version === "string" && record.version.length > 0
+        && Number.isSafeInteger(record.controllerProtocolVersion) && record.controllerProtocolVersion > 0
+        && isStorageVersion(record.storageVersion) && isStorageVersion(record.minimumStorageVersion)
+        && compareStorageVersions(record.minimumStorageVersion, record.storageVersion) <= 0;
+}
+export function parseControllerIdentity(value) {
+    if (!isControllerIdentity(value)) {
+        throw new Error("Controller identity must include the exact executable, argv, package, protocol and storage versions.");
+    }
+    return {
+        executablePath: value.executablePath,
+        args: [...value.args],
+        version: value.version,
+        controllerProtocolVersion: value.controllerProtocolVersion,
+        storageVersion: value.storageVersion,
+        minimumStorageVersion: value.minimumStorageVersion
+    };
+}

package/dist/core/controllerProcessIdentity.js

@@ -1,7 +1,7 @@
 import { readFileSync, readdirSync } from "node:fs";
 import { readLinuxProcessStartIdentity } from "../controller/domainIdentity.js";
 import { readHomeFilesystemId, validateHomeFilesystemId } from "./homeFilesystemIdentity.js";
-/** Exact live-process fence used only at Controller startup and v3 handoff. */
+/** Exact live-process fence used at Controller startup and handover. */
 export function inspectLiveControllerProcess(pid, homeFilesystemId, expectedProcessStartIdentity) {
     if (!Number.isSafeInteger(pid) || pid < 1 || pid === process.pid)
         return undefined;
@@ -39,7 +39,7 @@ export function inspectLiveControllerProcess(pid, homeFilesystemId, expectedProc
         return undefined;
     }
 }
-/** Finds an older/current Controller whose discovery record was lost. */
+/** Finds a Controller whose discovery record was lost. */
 export function findLiveControllerProcessForHome(homeFilesystemId) {
     validateHomeFilesystemId(homeFilesystemId);
     if (process.platform !== "linux")

package/dist/core/controllerServer.js

@@ -171,7 +171,7 @@ async function startControllerServerLocked(home, dispatcher, beforeDiscoveryRemo
     }
 }
 /**
- * Fence an older Controller whose socket name was derived by another protocol.
+ * Prevent a second Controller from claiming a Home with existing discovery.
  * A dead or PID-reused owner is stale and may be replaced; an unverifiable
  * live owner fails closed so an endpoint migration can never create dual
  * writers for one durable Home.
@@ -362,6 +362,8 @@ async function routeRequest(socket, line, token, dispatcher, stop, status, telem
                 cliRealpath: controllerCliRealpath(),
                 controllerRealpath: realpathSync(fileURLToPath(import.meta.url)),
                 controllerProtocolVersion: FILE_TASK_CONTROLLER_PROTOCOL_VERSION,
+                storageVersion: yuiVersionIdentity().storageVersion,
+                minimumStorageVersion: yuiVersionIdentity().minimumStorageVersion,
                 homeId,
                 homeFilesystemId,
                 controllerInstanceId,
@@ -676,7 +678,7 @@ export function buildRuntimeIdentityReceipt(input) {
         }
     })();
     return Object.freeze({
-        schemaVersion: 2,
+        schemaVersion: 1,
         version: YUI_VERSION,
         executablePath: process.execPath,
         args: process.argv.slice(1),

package/dist/core/protocol.js

@@ -3,7 +3,7 @@ import { validateHomeFilesystemId } from "./homeFilesystemIdentity.js";
 export const MAX_CONTROLLER_MESSAGE_BYTES = 1_048_576;
 export const CONTROLLER_DISCOVERY_PATH = "runtime/controller.json";
 /** Bump when a running Controller cannot safely share one YUI_HOME with this CLI. */
-export const FILE_TASK_CONTROLLER_PROTOCOL_VERSION = 4;
+export const FILE_TASK_CONTROLLER_PROTOCOL_VERSION = 1;
 export class ControllerProtocolError extends Error {
     code;
     id;

package/dist/doctor/doctor.js

@@ -694,7 +694,8 @@ function checkAgent(agent, executor, environment) {
             detail: [
                 `start resume interrupt nativeSession=${snapshot.lifecycle.nativeSessionDiscovery}`,
                 `preInputReady=${snapshot.lifecycle.preInputReadiness.status}`,
-                `fields=${available}/${degraded}/${unavailable}`,
+                `fields(help-observed/static-or-unverified/unavailable)=${available}/${degraded}/${unavailable}`,
+                "installation/help inspection only; no model or account capability query",
                 ...snapshot.warnings.map((warning) => `warning=${warning}`)
             ].join(" ")
         }

package/dist/domain/validation.js

@@ -51,6 +51,12 @@ export function normalizedUniqueIdentities(values, label) {
 export function cloneJson(value) {
     return JSON.parse(JSON.stringify(value));
 }
+/** Current envelopes accept only declared fields; no historical-field denylist. */
+export function requireKnownFields(value, fields, label) {
+    const unknown = Object.keys(value).find(key => !fields.includes(key));
+    if (unknown !== undefined)
+        throw new Error(`${label} has unsupported field: ${unknown}.`);
+}
 /**
  * True for a concrete, pinnable package version — a semver-shaped `X.Y.Z` with
  * an optional pre-release/build suffix. Rejects dist-tag sentinels (`latest`,

package/dist/event/taskEvent.js

@@ -2,7 +2,7 @@ import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { requireTimestamp } from "../domain/validation.js";
 export function createTaskEvent(id, taskId, type, payload, now) {
     const event = {
-        schemaVersion: 2,
+        schemaVersion: 1,
         id: requireText(id, "Task event id"),
         taskId: requireText(taskId, "Task event Task id"),
         type: requireText(type, "Task event type"),
@@ -12,8 +12,8 @@ export function createTaskEvent(id, taskId, type, payload, now) {
     return validateTaskEvent(event);
 }
 export function validateTaskEvent(event) {
-    if (event.schemaVersion !== 2)
-        throw new Error("Task Event must use schemaVersion 2.");
+    if (event.schemaVersion !== 1)
+        throw new Error("Task Event must use schemaVersion 1.");
     validateTaskRecordReference({ taskId: event.taskId, localId: event.id }, "event");
     requireText(event.type, "Task event type");
     if (event.payload === null || typeof event.payload !== "object" || Array.isArray(event.payload)) {

package/dist/execution/workItemExecution.js

@@ -3,8 +3,8 @@ import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requ
 import { validateContextSnapshotRef } from "../context/contextSnapshot.js";
 import { validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { MAX_SYNTHESIS_SOURCE_RUNS } from "../context/sourceRunContext.js";
-export const WORK_ITEM_EXECUTION_GROUP_SCHEMA_VERSION = 2;
-export const WORK_ITEM_EXECUTION_LANE_SCHEMA_VERSION = 2;
+export const WORK_ITEM_EXECUTION_GROUP_SCHEMA_VERSION = 1;
+export const WORK_ITEM_EXECUTION_LANE_SCHEMA_VERSION = 1;
 export const WORK_ITEM_EXECUTION_ASSIGNMENT_SCHEMA_VERSION = 1;
 export const MINIMUM_EXECUTION_GROUP_LANES = 2;
 export const EXECUTION_GROUP_SCHEMA_VERSION = WORK_ITEM_EXECUTION_GROUP_SCHEMA_VERSION;

package/dist/executor/agentAdapter.js

@@ -6,11 +6,12 @@ import { ownedArgumentsForAdapter, validateAgentAdvancedArguments, validateAgent
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { discoverAcpConfiguration, discoverClaudeConfiguration, discoverCodexConfiguration } from "./agentConfigurationProbe.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-const SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
-const APPROVALS = ["untrusted", "on-request", "never"];
+import { CODEX_SANDBOXES as SANDBOXES, CODEX_APPROVALS as APPROVALS, configurationFieldsFromHelp, configurationFieldWarnings, staticAgentConfigurationFields, STATIC_CONFIGURATION_NOTICE } from "./agentConfigurationFields.js";
 const PROBE_TIMEOUT_MS = 2_000;
 const PROBE_MAX_BYTES = 1024 * 1024;
-const CODEX_TESTED_THROUGH_VERSION = "0.150.1";
+// Offline producer/type evidence, not a claim of live account/model testing.
+// Keep the existing minimum support floors separate: see provider-protocol-contracts.md.
+const AUDITED_PRODUCER_VERSIONS = { codex: "0.153.4", claude: "2.1.270" };
 class BaseAdapter {
     launchContextArgs(_input) {
         return [];
@@ -556,7 +557,7 @@ export function inspectAgentCapabilities(agent, optionsOrNow = {}) {
     const at = now.toISOString();
     const adapter = resolveAgentAdapter(agent.adapterId);
     validateAgentBaseArguments(agent.adapterId, agent.baseArgs);
-    const versionRun = run(agent.command, ["--version"]);
+    const versionRun = run(agent.command, [...agent.baseArgs, "--version"]);
     const failure = failed(versionRun);
     if (failure !== undefined) {
         const missing = versionRun.error?.code === "ENOENT";
@@ -583,7 +584,7 @@ export function inspectAgentCapabilities(agent, optionsOrNow = {}) {
             probedAt: at
         }, fields, at, [`Installed version ${version} is not supported by adapter ${adapter.id}.`]);
     }
-    const help = run(agent.command, ["--help"]);
+    const help = run(agent.command, [...agent.baseArgs, "--help"]);
     const helpFailure = failed(help);
     if (helpFailure !== undefined) {
         return snapshot(agent, adapter, {
@@ -593,114 +594,45 @@ export function inspectAgentCapabilities(agent, optionsOrNow = {}) {
         }, fields, at);
     }
     const helpOutput = output(help.stdout, help.stderr);
-    fields = fromHelp(agent.adapterId, helpOutput);
+    const helpFields = configurationFieldsFromHelp(agent.adapterId, helpOutput);
+    fields = capabilityFields(helpFields);
+    warnings.push(...configurationFieldWarnings(helpFields));
     const missing = missingRequiredCapabilities(adapter.id, helpOutput);
     if (missing.length > 0) {
         return snapshot(agent, adapter, {
             status: "unsupported-version", command: agent.command, version,
             reason: `${adapter.label} CLI is missing required capabilities: ${missing.join(", ")}.`,
             probedAt: at
-        }, fields, at);
+        }, fields, at, warnings);
     }
-    if (adapter.id === "codex"
-        && compareVersions(version, CODEX_TESTED_THROUGH_VERSION) > 0) {
-        warnings.push(`Installed Codex version ${version} is newer than the latest tested version `
-            + `${CODEX_TESTED_THROUGH_VERSION}; required capabilities were detected.`);
+    const audited = adapter.id === "acp" ? undefined : AUDITED_PRODUCER_VERSIONS[adapter.id];
+    if (audited !== undefined && compareVersions(version, audited) > 0) {
+        warnings.push(`Installed ${adapter.label} version ${version} is newer than the latest audited producer `
+            + `${audited}; required CLI flags were detected, not live protocol compatibility.`);
     }
     return snapshot(agent, adapter, {
         status: "installed", command: agent.command, version, probedAt: at
     }, fields, at, warnings);
 }
 function baseline(id) {
-    // ACP negotiates its whole configurable surface per Session, so a static
-    // baseline can only say which axes exist — never which values one Agent
-    // accepts. Model, effort and mode are all `degraded` for exactly that reason:
-    // they are configurable and the enumeration comes from the live Session, so
-    // promising values here would be inventing them.
-    if (id === "acp")
-        return [
-            field("model", "enum", "degraded", true),
-            field("effort", "enum", "degraded", true),
-            field("permission.strategy", "enum", "available", false, ["default", "bypass", "configured"]),
-            // The exact mode ids belong to the Agent, and only a live Session lists
-            // them. `configured` carries whichever id the user names.
-            field("permission.mode", "enum", "degraded", true),
-            // Configurable, but only reaches an Agent that advertises
-            // `sessionCapabilities.additionalDirectories` at `initialize`. A static
-            // baseline cannot see that handshake, so it reports the field as degraded
-            // rather than promising delivery it cannot guarantee.
-            field("additionalDirectories", "path-list", "degraded", true)
-        ];
-    if (id === "codex")
-        return [
-            field("model", "enum", "degraded", true), field("effort", "enum", "unavailable", true),
-            field("permission.strategy", "enum", "available", false, ["default", "bypass", "configured"]),
-            field("permission.sandbox", "enum", "available", false, SANDBOXES),
-            field("permission.approval", "enum", "available", false, APPROVALS),
-            field("profile", "string", "available", true), field("search", "boolean", "available", false, ["true"]),
-            field("additionalDirectories", "path-list", "available", true)
-        ];
-    return [
-        field("model", "enum", "degraded", true, ["fable", "opus", "sonnet"]),
-        field("effort", "enum", "unavailable", true),
-        field("permission.strategy", "enum", "available", false, ["default", "bypass", "configured"]),
-        field("permission.mode", "enum", "unavailable", true),
-        field("permission.allowedTools", "string-list", "available", true),
-        field("permission.disallowedTools", "string-list", "available", true),
-        field("additionalDirectories", "path-list", "available", true), field("settingsFile", "path", "available", true),
-        field("settingsSources", "string-list", "degraded", false, ["user", "project", "local"])
-    ];
-}
-function fromHelp(id, help) {
-    const fields = baseline(id);
-    // Nothing in an ACP Agent's `--help` describes the protocol it speaks, so
-    // there is nothing here to refine: the baseline is already the whole truth.
-    if (id === "acp")
-        return fields;
-    const replacements = id === "codex"
-        ? [permissionStrategyField(help, "--dangerously-bypass-approvals-and-sandbox"),
-            choiceField("permission.sandbox", help, "--sandbox", SANDBOXES),
-            choiceField("permission.approval", help, "--ask-for-approval", APPROVALS)]
-        : [choiceField("model", help, "--model", ["fable", "opus", "sonnet"], true),
-            choiceField("effort", help, "--effort", [], true),
-            permissionStrategyField(help, "--dangerously-skip-permissions"),
-            choiceField("permission.mode", help, "--permission-mode", [], true),
-            choiceField("settingsSources", help, "--setting-sources", ["user", "project", "local"])];
-    const byKey = new Map(replacements.map((value) => [value.key, value]));
-    return fields.map((value) => byKey.get(value.key) ?? value);
-}
-function permissionStrategyField(help, bypassFlag) {
-    const choices = [
-        "default",
-        ...(help.includes(bypassFlag) ? ["bypass"] : []),
-        "configured"
-    ];
-    return field("permission.strategy", "enum", choices.includes("bypass") ? "available" : "degraded", false, choices);
-}
-function choiceField(key, help, flag, fallback, custom = false) {
-    const choices = helpChoices(help, flag);
-    return field(key, key === "settingsSources" ? "string-list" : "enum", choices.length > 0 ? "available" : fallback.length > 0 ? "degraded" : "unavailable", custom, choices.length > 0 ? choices : fallback);
-}
-function field(key, kind, status, allowCustom, choices) {
-    return { key, kind, status, allowCustom, ...(choices === undefined ? {} : { choices: [...choices] }) };
-}
-function helpChoices(help, flag) {
-    const lines = help.replace(/\r\n/g, "\n").split("\n");
-    const start = lines.findIndex((line) => line.includes(flag));
-    if (start < 0)
-        return [];
-    let end = start + 1;
-    while (end < lines.length && !/^\s{2,}(?:-[A-Za-z](?:,\s*)?|--)[\w-]/.test(lines[end]))
-        end += 1;
-    const body = /(?:\[possible values:\s*([^\]]+)\]|\(choices:\s*([^)]*)\)|\(([^)]*)\))/i
-        .exec(lines.slice(start, end).join("\n"));
-    return [...new Set((body?.[1] ?? body?.[2] ?? body?.[3] ?? "").replace(/["']/g, "").split(",")
-            .map((value) => value.trim().replace(/\.$/, "")).filter((value) => /^[\w.+-]+$/.test(value)))];
+    return capabilityFields(staticAgentConfigurationFields(id));
+}
+function capabilityFields(fields) {
+    const kinds = {
+        profile: "string", search: "boolean", additionalDirectories: "path-list", settingsFile: "path",
+        settingsSources: "string-list", "permission.allowedTools": "string-list", "permission.disallowedTools": "string-list"
+    };
+    return fields.map(field => ({
+        key: field.key, kind: kinds[field.key] ?? "enum", allowCustom: field.allowCustom,
+        status: field.available === true ? "available" : field.available === false ? "unavailable" : "degraded",
+        choices: field.choices.map(choice => choice.value)
+    }));
 }
 function snapshot(agent, adapter, installation, fields, at, warnings = []) {
     return { schemaVersion: 1, agentId: agent.id, adapterId: agent.adapterId, installation,
         lifecycle: { start: true, resume: true, nativeSessionDiscovery: adapter.capabilities.nativeSessionDiscovery,
-            interrupt: true, preInputReadiness: adapter.capabilities.preInputReadiness }, fields, warnings, refreshedAt: at };
+            interrupt: true, preInputReadiness: adapter.capabilities.preInputReadiness }, fields,
+        warnings: [...new Set([STATIC_CONFIGURATION_NOTICE, ...warnings])], refreshedAt: at };
 }
 function runProbe(command, args) {
     const result = spawnSync(command, [...args], { encoding: "utf8", shell: false, timeout: PROBE_TIMEOUT_MS,

package/dist/executor/agentConfigurationCatalog.js

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
 import { redactAgentErrorText } from "../runtime/agentError.js";
+import { staticAgentConfigurationFields, STATIC_CONFIGURATION_NOTICE } from "./agentConfigurationFields.js";
 const DEFAULT_TIMEOUT_MS = 8_000;
 export class AgentConfigurationCatalogService {
     yuiHome;
@@ -119,71 +120,14 @@ export class AgentConfigurationCatalogService {
     }
 }
 export function fallbackAgentConfigurationCatalog(agent) {
-    const choice = (value) => ({ value, label: value });
-    const common = [
-        field("model", [], true),
-        field("effort", [], true)
-    ];
-    // The fallback exists for when the probe could not run, so it must still be
-    // this Agent's own shape. Falling through to Claude's fields handed the
-    // caller a catalog whose `adapterId` contradicted the Agent it described.
-    if (agent.adapterId === "acp") {
-        return {
-            schemaVersion: 1,
-            agentId: agent.id,
-            adapterId: "acp",
-            models: [],
-            fields: [
-                ...common,
-                field("permission.strategy", [choice("default"), choice("bypass"), choice("configured")], false),
-                // The mode ids come from a live Session, so an offline catalog can only
-                // say the axis exists. Listing candidates here would invent an Agent's
-                // vocabulary from a build-time guess.
-                field("permission.mode", [], true)
-            ],
-            warnings: ["Runtime configuration catalog is unavailable."]
-        };
-    }
-    return agent.adapterId === "codex"
-        ? {
-            schemaVersion: 1,
-            agentId: agent.id,
-            adapterId: "codex",
-            models: [],
-            fields: [
-                ...common,
-                field("permission.strategy", ["default", "bypass", "configured"].map(choice), false),
-                field("permission.sandbox", [
-                    "read-only", "workspace-write", "danger-full-access"
-                ].map(choice), false),
-                field("permission.approval", [
-                    "untrusted", "on-request", "never"
-                ].map(choice), false),
-                field("search", [choice("true")], false),
-                field("profile", [], true),
-                field("additionalDirectories", [], true)
-            ],
-            warnings: ["Runtime configuration catalog is unavailable."]
-        }
-        : {
-            schemaVersion: 1,
-            agentId: agent.id,
-            adapterId: "claude",
-            models: [],
-            fields: [
-                ...common,
-                field("permission.strategy", ["default", "bypass", "configured"].map(choice), false),
-                field("permission.mode", [
-                    "acceptEdits", "auto", "bypassPermissions", "manual", "dontAsk", "plan"
-                ].map(choice), true),
-                field("permission.allowedTools", [], true),
-                field("permission.disallowedTools", [], true),
-                field("settingsSources", ["user", "project", "local"].map(choice), false),
-                field("settingsFile", [], true),
-                field("additionalDirectories", [], true)
-            ],
-            warnings: ["Runtime configuration catalog is unavailable."]
-        };
+    return {
+        schemaVersion: 1,
+        agentId: agent.id,
+        adapterId: agent.adapterId,
+        models: [],
+        fields: staticAgentConfigurationFields(agent.adapterId),
+        warnings: ["Runtime configuration catalog is unavailable.", STATIC_CONFIGURATION_NOTICE]
+    };
 }
 export function configurationField(catalog, key) {
     return catalog.fields.find((candidate) => candidate.key === key);
@@ -232,9 +176,6 @@ export function validateAgentLaunchConfiguration(catalog, config) {
             + `Inspect current options: yui config agent capabilities ${catalog.agentId}.`);
     }
 }
-function field(key, choices, allowCustom) {
-    return { key, choices, allowCustom };
-}
 function catalogFingerprint(input, environment) {
     const bindings = input.agent.environment.map((binding) => ({
         target: binding.target,
@@ -259,6 +200,10 @@ function catalogFingerprint(input, environment) {
             }
             : null;
     return createHash("sha256").update(JSON.stringify({
+        // Old derived caches may contain guessed help values. They cannot establish
+        // the current discovery contract. No durable record or cache shape changes.
+        discoveryContract: "explicit-native-enumeration",
+        agentId: input.agent.id,
         // The component, not just the plan: two ACP products answer the same
         // handshake differently, so a cache keyed on the plan alone would serve one
         // product's capabilities for the other.