@zq-silk/yui 0.15.7 → 0.15.8

package/dist/agent/adapterCatalog.js

@@ -1,10 +1,23 @@
 export const AGENT_ADAPTER_CATALOG = Object.freeze([
     Object.freeze({ id: "codex", label: "Codex" }),
-    Object.freeze({ id: "claude", label: "Claude" })
+    Object.freeze({ id: "claude", label: "Claude" }),
+    // One adapter for the Agent Client Protocol, not one per product. Which ACP
+    // Agent runs is a launch descriptor fact, so a further ACP product needs no
+    // new adapter and no new branch anywhere above this line.
+    Object.freeze({ id: "acp", label: "Agent Client Protocol" })
 ]);
 export function supportedAgentAdapterIds() {
     return AGENT_ADAPTER_CATALOG.map(({ id }) => id).sort();
 }
 export function isAgentAdapterId(value) {
-    return value === "codex" || value === "claude";
+    return AGENT_ADAPTER_CATALOG.some(({ id }) => id === value);
+}
+/**
+ * The catalog's own display label, falling back to the raw id.
+ *
+ * The fallback is deliberate: a stored binding may name an adapter this build
+ * no longer ships, and showing that id is more useful than hiding it.
+ */
+export function agentAdapterLabel(adapterId) {
+    return AGENT_ADAPTER_CATALOG.find(({ id }) => id === adapterId)?.label ?? adapterId;
 }

package/dist/agent/agent.js

@@ -1,6 +1,7 @@
 import { isAgentAdapterId } from "./adapterCatalog.js";
+import { adapterIdForExecutionComponent, resolveAgentExecutionComponent } from "./executionComponents.js";
 import { validateAgentBaseArguments } from "./argumentPolicy.js";
-export function createConfiguredAgent(id, adapterId, command, baseArgs, environment, now) {
+export function createConfiguredAgent(id, adapterId, command, baseArgs, environment, now, component) {
     const normalizedId = requireSafeIdentity(id, "Agent id");
     if (!isAgentAdapterId(adapterId))
         throw new Error(`Agent adapter is unsupported: ${adapterId}.`);
@@ -8,8 +9,11 @@ export function createConfiguredAgent(id, adapterId, command, baseArgs, environm
     validateAgentBaseArguments(adapterId, baseArgs);
     const timestamp = now.toISOString();
     return {
-        schemaVersion: 2,
+        schemaVersion: 3,
         id: normalizedId,
+        // An unnamed component resolves from the plan, which for ACP means the
+        // unidentified entry rather than a guess at which product is installed.
+        component: resolveAgentExecutionComponent(adapterId, component),
         adapterId,
         command: normalizedCommand,
         baseArgs: [...baseArgs],
@@ -41,11 +45,27 @@ export function resolveAgentEnvironment(agent, processEnvironment = process.env)
     }));
 }
 export function validateConfiguredAgent(agent) {
-    if (agent.schemaVersion !== 2)
+    if (agent.schemaVersion !== 3)
         throw new Error("Agent schema version is invalid.");
     requireSafeIdentity(agent.id, "Agent id");
     if (!isAgentAdapterId(agent.adapterId))
         throw new Error(`Agent adapter is unsupported: ${agent.adapterId}.`);
+    // A schema 3 record always carries a component: storage 10 backfilled every
+    // stored Agent, and the constructor resolves one for every new Agent. So an
+    // absent value here is a corrupt record, not an old one, and resolving it to
+    // the plan default would invent a product identity for data that never lost
+    // one. That default belongs to the constructor, where an operator naming
+    // only a plan is a real and supported request — this validator reads records
+    // that were already written, where the same silence means something else.
+    if (agent.component === undefined) {
+        throw new Error(`Agent is missing its execution component: ${agent.id}.`);
+    }
+    // The component determines its plan, so a stored pair that disagrees is
+    // corruption rather than a configuration the operator can act on.
+    const expected = adapterIdForExecutionComponent(resolveAgentExecutionComponent(agent.adapterId, agent.component));
+    if (expected !== agent.adapterId) {
+        throw new Error(`Agent execution component ${agent.component} does not match adapter ${agent.adapterId}.`);
+    }
     requireText(agent.command, "Agent command");
     validateAgentBaseArguments(agent.adapterId, agent.baseArgs);
     if (!Array.isArray(agent.environment))

package/dist/agent/argumentPolicy.js

@@ -18,7 +18,13 @@ const OWNED_ARGUMENTS_BY_ADAPTER = {
         "--fallback-model", "--tools", "--system-prompt", "--system-prompt-file",
         "--append-system-prompt", "--append-system-prompt-file", "--plugin-dir",
         "--name", "-n", "--output-format", "--input-format"
-    ]
+    ],
+    // The ACP adapter compiles no arguments of its own: the protocol is spoken
+    // over stdio once the product is running, and how a given product enters ACP
+    // mode (`acp`, `--experimental-acp`, …) is a descriptor fact. Reserving any
+    // name here would both encode one product's spelling and reject the very
+    // baseArgs that select ACP mode.
+    acp: []
 };
 export function ownedArgumentsForAdapter(adapterId) {
     return OWNED_ARGUMENTS_BY_ADAPTER[adapterId];

package/dist/agent/connectionPlan.js

@@ -0,0 +1,62 @@
+/**
+ * The connection plan: how Yui reaches an execution component.
+ *
+ * Yui's adapter id has always carried this meaning, but two of its values are
+ * product names and one is a protocol name, which reads as a single mixed axis.
+ * Nothing about the plans changes here; they are stated explicitly instead of
+ * being implied by an adapter id and a lookup table elsewhere.
+ *
+ * A plan names its protocol and its transport together, as one authoritative
+ * binding. Protocol and transport are not independently selectable: there is no
+ * combination graph to assemble, because a wire protocol and the carrier it
+ * runs over are decided as a pair by the implementation that speaks them.
+ *
+ * Static protocol support is what this table records: what Yui's own client
+ * implements. It is not what a given Agent agreed to. Live handshake facts are
+ * negotiated per connection and reported separately; where a plan negotiates
+ * nothing, its handshake is explicitly `none` rather than silently absent.
+ */
+import { AGENT_ADAPTER_CATALOG } from "./adapterCatalog.js";
+export const AGENT_CONNECTION_PLANS = Object.freeze([
+    Object.freeze({
+        id: "codex",
+        label: "Codex app-server",
+        protocol: "codex-app-server",
+        // Codex versions its app-server interface with the CLI, not separately.
+        protocolVersion: "unknown",
+        transport: "codex-app-server-proxy",
+        handshake: "none"
+    }),
+    Object.freeze({
+        id: "claude",
+        label: "Claude Code stream-json",
+        protocol: "claude-stream-json",
+        protocolVersion: "unknown",
+        transport: "claude-stream-json",
+        handshake: "none"
+    }),
+    Object.freeze({
+        id: "acp",
+        label: "Agent Client Protocol (stdio)",
+        protocol: "agent-client-protocol",
+        protocolVersion: "1",
+        transport: "acp-stdio",
+        handshake: "negotiated",
+        handshakeMethod: "initialize"
+    })
+]);
+export function agentConnectionPlan(adapterId) {
+    const plan = AGENT_CONNECTION_PLANS.find(({ id }) => id === adapterId);
+    if (plan === undefined) {
+        throw new Error(`No connection plan for adapter: ${adapterId}.`);
+    }
+    return plan;
+}
+export function agentTransportForAdapter(adapterId) {
+    return agentConnectionPlan(adapterId).transport;
+}
+// Every catalogued adapter must have exactly one plan. Checking at module load
+// turns a missing entry into an immediate, obvious failure rather than a
+// transport mismatch surfacing at launch.
+for (const { id } of AGENT_ADAPTER_CATALOG)
+    agentConnectionPlan(id);

package/dist/agent/executionComponents.js

@@ -0,0 +1,158 @@
+/**
+ * Which execution component runs an Agent, stated independently from how Yui
+ * reaches it.
+ *
+ * Yui's adapter id answers one question: the connection plan — the protocol
+ * Yui speaks and the transport it speaks over. It deliberately does not answer
+ * "which product is running", because several distinct products are reachable
+ * through the same plan. The Agent Client Protocol is the clear case: Claude
+ * Code's CLI, the Claude Agent SDK bridge and any other ACP Agent all arrive
+ * over `acp`, and treating that protocol name as a product identity makes them
+ * indistinguishable in registration, display, Role bindings and Session
+ * snapshots.
+ *
+ * So the component is its own axis. Every component names exactly one
+ * connection plan it is reachable through, and that mapping is one-way and
+ * total: the component determines the plan, never the reverse. There is still
+ * exactly one authoritative binding to write, so the two facts cannot drift
+ * into disagreement, and no arbitrary component/protocol combination graph
+ * exists to be assembled.
+ *
+ * Naming follows the component that actually executes — a CLI or an SDK — and
+ * never "native", which names no product.
+ */
+import { isAgentAdapterId } from "./adapterCatalog.js";
+export const AGENT_EXECUTION_COMPONENT_CATALOG = Object.freeze([
+    Object.freeze({
+        id: "codex-cli",
+        label: "Codex CLI",
+        adapterId: "codex",
+        kind: "cli",
+        identified: true
+    }),
+    // Claude Code's own CLI, driven over its stream-json interface. This is a
+    // different access implementation from the SDK bridge below: different
+    // executable, different startup, different authentication surface and a
+    // different set of settings Yui can express. Neither one's configuration
+    // may be assumed to work for the other.
+    Object.freeze({
+        id: "claude-code-cli",
+        label: "Claude Code CLI",
+        adapterId: "claude",
+        kind: "cli",
+        identified: true
+    }),
+    // The Claude Agent SDK reached through an ACP bridge process. It speaks the
+    // protocol Yui already implements, so it needs no product branch in the
+    // codec — only its own identity here, so an operator can see and select it.
+    Object.freeze({
+        id: "claude-agent-sdk",
+        label: "Claude Agent SDK (ACP)",
+        adapterId: "acp",
+        kind: "sdk",
+        identified: true,
+        // The bridge exposes Claude Code's own permission modes, where
+        // `bypassPermissions` is the documented mode that skips approval
+        // prompts. The bridge offers it only when its own preconditions hold, so
+        // its presence in a Session's option list is still checked rather than
+        // assumed.
+        bypassPermissionMode: "bypassPermissions"
+    }),
+    // Every other ACP Agent, and every binding made before components were
+    // recorded. Yui does not know which product answers, and a command string
+    // is not evidence: an executable named `claude-agent-acp` may be a wrapper,
+    // a shim or something else entirely. Guessing a product here would attach a
+    // confident label to an unverified fact, so the honest value is this one.
+    // It states no bypass mode for the same reason: not knowing the product
+    // means not knowing which of its modes, if any, grants that authority.
+    Object.freeze({
+        id: "unknown-acp-agent",
+        label: "ACP Agent (unidentified)",
+        adapterId: "acp",
+        kind: "unknown",
+        identified: false
+    })
+]);
+/**
+ * The component recorded when a connection plan is selected without naming one.
+ *
+ * A plan with a single possible component resolves to it. The ACP plan carries
+ * many products, so it resolves to the unidentified entry rather than to
+ * whichever product happens to be most common.
+ */
+const DEFAULT_COMPONENT_BY_ADAPTER = Object.freeze({
+    codex: "codex-cli",
+    claude: "claude-code-cli",
+    acp: "unknown-acp-agent"
+});
+export function supportedAgentExecutionComponentIds() {
+    return AGENT_EXECUTION_COMPONENT_CATALOG.map(({ id }) => id).sort();
+}
+export function isAgentExecutionComponentId(value) {
+    return AGENT_EXECUTION_COMPONENT_CATALOG.some(({ id }) => id === value);
+}
+export function agentExecutionComponent(componentId) {
+    const entry = AGENT_EXECUTION_COMPONENT_CATALOG.find(({ id }) => id === componentId);
+    if (entry === undefined) {
+        throw new Error(`Agent execution component is unsupported: ${componentId}.`);
+    }
+    return entry;
+}
+/**
+ * The component's display label, falling back to the raw id.
+ *
+ * As with adapters, a stored binding may name a component this build no longer
+ * ships; showing that id is more useful than hiding it.
+ */
+export function agentExecutionComponentLabel(componentId) {
+    return AGENT_EXECUTION_COMPONENT_CATALOG.find(({ id }) => id === componentId)?.label
+        ?? componentId;
+}
+/** The connection plan a component is reached through. */
+export function adapterIdForExecutionComponent(componentId) {
+    return agentExecutionComponent(componentId).adapterId;
+}
+/** Components reachable through one connection plan, in catalog order. */
+export function executionComponentsForAdapter(adapterId) {
+    return AGENT_EXECUTION_COMPONENT_CATALOG.filter((entry) => entry.adapterId === adapterId);
+}
+export function defaultExecutionComponentForAdapter(adapterId) {
+    return DEFAULT_COMPONENT_BY_ADAPTER[adapterId];
+}
+/**
+ * The component to show for a record that was parsed rather than constructed.
+ *
+ * Display surfaces read values back over the wire, where neither field is
+ * guaranteed to be a value this build knows. Refusing to render is the wrong
+ * answer there, so this never throws: a recognised component wins, an absent
+ * one falls back to its plan's default, and anything unrecognised is shown
+ * verbatim rather than replaced with a guess.
+ */
+export function displayExecutionComponent(adapterId, componentId) {
+    if (componentId !== undefined)
+        return componentId;
+    return isAgentAdapterId(adapterId)
+        ? defaultExecutionComponentForAdapter(adapterId)
+        : adapterId;
+}
+/**
+ * Resolve the component for a connection plan, given what the caller stated.
+ *
+ * An absent component is not an error: it means the caller named only the plan,
+ * which is how every binding made before this axis existed reads. It resolves
+ * to the plan's default, which for ACP is the unidentified entry — the value is
+ * never inferred from a command, an argument or an environment variable.
+ */
+export function resolveAgentExecutionComponent(adapterId, componentId) {
+    if (componentId === undefined)
+        return defaultExecutionComponentForAdapter(adapterId);
+    if (!isAgentExecutionComponentId(componentId)) {
+        throw new Error(`Agent execution component is unsupported: ${componentId}.`);
+    }
+    const expected = adapterIdForExecutionComponent(componentId);
+    if (expected !== adapterId) {
+        throw new Error(`Agent execution component ${componentId} is reached over the ${expected} `
+            + `connection plan, not ${adapterId}.`);
+    }
+    return componentId;
+}

package/dist/agent/launchEnvironment.js

@@ -56,14 +56,42 @@ export const AGENT_OPERATIONAL_ENVIRONMENT_NAMES = [
     "REQUESTS_CA_BUNDLE",
     "SSH_AUTH_SOCK"
 ];
+/** Native account context. Credential values remain volatile and belong only
+ * to this adapter; they are never copied into Roles, Tasks or launch arguments.
+ * Do not inherit numeric credential FDs across unrelated processes. */
+const CLAUDE_NATIVE_ENVIRONMENT_NAMES = [
+    "CLAUDE_CONFIG_DIR",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "ANTHROPIC_PROFILE",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "CLAUDE_CODE_SUBAGENT_MODEL",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+    "CLAUDE_CODE_USE_GATEWAY",
+    "CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST",
+    "CLAUDE_CODE_HOST_CREDS_FILE",
+    "CLAUDE_CODE_API_KEY_HELPER_TTL_MS",
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
+    "DISABLE_AUTOUPDATER"
+];
 export const NATIVE_AGENT_ENVIRONMENT_NAMES = [
-    "CODEX_HOME",
-    "CLAUDE_CONFIG_DIR"
+    "CODEX_HOME", ...CLAUDE_NATIVE_ENVIRONMENT_NAMES
 ];
 export function nativeAgentEnvironmentNames(adapterId) {
     switch (adapterId) {
         case "codex": return ["CODEX_HOME"];
-        case "claude": return ["CLAUDE_CONFIG_DIR"];
+        case "claude": return CLAUDE_NATIVE_ENVIRONMENT_NAMES;
+        // ACP standardizes the protocol, not where a product keeps its
+        // configuration. Naming a variable here would be a product branch, so an
+        // ACP Agent that needs one declares it as an ordinary environment binding.
+        case "acp": return [];
     }
 }
 export function selectEnvironment(source, names) {

package/dist/agent/managedRuntimeEnvironment.js

@@ -1,7 +1,7 @@
 /**
  * Environment values owned by Yui's managed runtime.
  *
- * These values carry control-plane, Task, workspace, or runtime generation identity. They
+ * These values carry control-plane, Task, workspace, or runtime identity. They
  * are never user Agent environment bindings, and an ordinary repository test
  * must not inherit them from the managed Session that launched the test
  * command.
@@ -16,8 +16,7 @@ export const YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES = Object.freeze([
     "YUI_ADAPTER_ID",
     "YUI_DRIVER_ID",
     "YUI_WORKSPACE",
-    "YUI_TURN_ID",
-    "YUI_RUNTIME_GENERATION_ID",
+    "YUI_RUN_ID",
     "YUI_NATIVE_SESSION_ROOT",
     "YUI_NATIVE_SESSION_ID",
     // Retired: Yui no longer publishes a frozen control-plane descriptor into a
@@ -31,6 +30,5 @@ export const YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES = Object.freeze([
     "YUI_AGENT_BASE_ARGS",
     "YUI_WRITABLE_PROJECT_IDS",
     "YUI_CONTEXT_PROJECT_IDS",
-    "YUI_WORKSPACE_PROJECTS",
-    "YUI_JOB_CALLER_KEY"
+    "YUI_WORKSPACE_PROJECTS"
 ]);