@zq-silk/yui 0.15.7 → 0.15.8

package/dist/commands/agentCommands.js

@@ -1,10 +1,11 @@
 import { isDeepStrictEqual } from "node:util";
 import { agentNotFound, usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
+import { isAgentAdapterId, supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
+import { adapterIdForExecutionComponent, agentExecutionComponentLabel, defaultExecutionComponentForAdapter, isAgentExecutionComponentId, supportedAgentExecutionComponentIds } from "../agent/executionComponents.js";
 import { createConfiguredAgent, validateConfiguredAgent } from "../agent/agent.js";
 import { LIVE_SESSION_ACKNOWLEDGEMENT_OPTION } from "./roleRuntimeGuard.js";
 import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-const SUPPORTED_ADAPTERS = Object.freeze(["codex", "claude"]);
 export function runAgentCommand(args, store) {
     const [command, ...rest] = args;
     switch (command) {
@@ -23,16 +24,24 @@ function addAgent(args, store) {
     const [rawId, ...tail] = args;
     const id = agentId(rawId);
     const parsed = parseAgentOptions(tail, "add");
-    const adapterId = parsed.one("--adapter") ?? (SUPPORTED_ADAPTERS.includes(id) ? id : undefined);
-    if (adapterId === undefined)
-        throw usageError("--adapter is required.");
+    const component = parsed.one("--component")?.trim();
+    if (component !== undefined)
+        assertComponent(component);
+    // Naming the component is enough: it determines its own connection plan, so
+    // there is one fact to state rather than a pair that could contradict.
+    const adapterId = parsed.one("--adapter")
+        ?? (component === undefined ? undefined : adapterIdForExecutionComponent(component))
+        ?? (isAgentAdapterId(id) ? id : undefined);
+    if (adapterId === undefined) {
+        throw usageError("--component or --adapter is required.");
+    }
     assertAdapter(adapterId);
     const command = parsed.one("--command")?.trim();
     if (command === undefined || command.length === 0)
         throw usageError("--command is required.");
     let agent;
     try {
-        agent = createConfiguredAgent(id, adapterId, command, parsed.many("--arg"), parsed.many("--env").map(parseEnvironmentBinding), new Date());
+        agent = createConfiguredAgent(id, adapterId, command, parsed.many("--arg"), parsed.many("--env").map(parseEnvironmentBinding), new Date(), component);
     }
     catch (error) {
         throw usageError(error instanceof Error ? error.message : String(error));
@@ -50,11 +59,13 @@ function listAgents(args, store) {
         return "No agents configured.\n";
     return `${renderTable("Agents", [
         { header: "Agent", minWidth: 5, maxWidth: 24 },
+        { header: "Component", minWidth: 9, maxWidth: 20 },
         { header: "Adapter", minWidth: 7, maxWidth: 12 },
         { header: "Command", minWidth: 7, maxWidth: 48 },
         { header: "Environment", minWidth: 11, maxWidth: 32 }
     ], agents.map((agent) => [
         agent.id,
+        agent.component,
         agent.adapterId,
         [agent.command, ...agent.baseArgs].join(" "),
         agent.environment.map((binding) => `${binding.target}<-${binding.sourceName}`).join(", ")
@@ -86,11 +97,25 @@ function updateAgent(args, store) {
     const adapterId = parsed.one("--adapter")?.trim();
     if (adapterId !== undefined)
         assertAdapter(adapterId);
+    const component = parsed.one("--component")?.trim();
+    if (component !== undefined)
+        assertComponent(component);
+    if (component !== undefined && adapterId !== undefined
+        && adapterIdForExecutionComponent(component) !== adapterId) {
+        throw usageError(`Agent execution component ${component} is reached over the `
+            + `${adapterIdForExecutionComponent(component)} connection plan, not ${adapterId}. `
+            + "Pass --component alone to move the Agent onto its own plan.");
+    }
     const command = parsed.one("--command")?.trim();
     if (command !== undefined && command.length === 0)
         throw usageError("--command is required.");
-    const patch = {
+    const requestedPatch = {
         ...(adapterId === undefined ? {} : { adapterId }),
+        // Changing the component can move the Agent onto its plan, which is the one
+        // way the two stay consistent without asking the operator to restate both.
+        ...(component === undefined
+            ? {}
+            : { component, adapterId: adapterIdForExecutionComponent(component) }),
         ...(command === undefined ? {} : { command }),
         ...(parsed.has("--arg")
             ? { baseArgs: parsed.many("--arg") }
@@ -104,6 +129,14 @@ function updateAgent(args, store) {
         const existing = tx.getConfiguredAgent(id);
         if (existing === null)
             return null;
+        // Derive a default only when actually leaving the stored plan. Restating
+        // the same plan must preserve an explicitly identified ACP component.
+        const patch = {
+            ...requestedPatch,
+            ...(component === undefined && adapterId !== undefined && adapterId !== existing.adapterId
+                ? { component: defaultExecutionComponentForAdapter(adapterId) }
+                : {})
+        };
         const changes = actualAgentChanges(existing, patch);
         if (!changes.operational) {
             return { status: "unchanged", agent: existing };
@@ -117,22 +150,37 @@ function updateAgent(args, store) {
         const liveSession = findNonStoppedSessionReference(tx, id);
         if (liveSession !== null && !parsed.has(LIVE_SESSION_ACKNOWLEDGEMENT_OPTION)) {
             throw usageError(`${describeReference(liveSession)} runs a live native session (${liveSession.status}) on `
-                + `Agent ${id}, so this change applies to its next Host activation instead of the `
+                + `Agent ${id}, so this change applies to its next Host process instead of the `
                 + "running one.\n"
                 + `Re-run with ${LIVE_SESSION_ACKNOWLEDGEMENT_OPTION} to record the change and keep that `
                 + "session.\n"
                 + "Stop the affected Role session first to apply it to a fresh session instead.");
         }
-        if (changes.adapter) {
+        // A component change is refused on a referenced Agent for the same reason
+        // an adapter change is, and the reason is not symmetry: the product identity
+        // is copied into Role bindings and frozen into every Session snapshot at
+        // launch. Rewriting only the Agent leaves those copies asserting the old
+        // product while the new command runs, so a Session resumes against one
+        // product under another's name. Rewriting the copies instead would relabel
+        // history that really did run the old product. Neither is correctable here,
+        // so the change is refused and the operator binds a new Agent explicitly —
+        // which leaves existing Sessions pinned to what they actually ran.
+        const identityChange = changes.adapter
+            ? { axis: "adapter", target: "adapter" }
+            : changes.component ? { axis: "execution component", target: "component" } : null;
+        if (identityChange !== null) {
             const profile = findAgentProfileReference(tx, id);
             if (profile !== null) {
-                throw usageError(`Agent ${id} adapter cannot change because Agent Profile ${profile.id} references it. `
+                throw usageError(`Agent ${id} ${identityChange.axis} cannot change because Agent Profile `
+                    + `${profile.id} references it. `
                     + "Update that explicit Profile or create a new Agent ID instead.");
             }
             const binding = findRoleBindingReference(tx, id);
             if (binding !== null) {
-                throw usageError(`Agent ${id} adapter cannot change because ${describeReference(binding)} references it. `
-                    + "Create a new Agent ID with the target adapter and bind the Role to it instead.");
+                throw usageError(`Agent ${id} ${identityChange.axis} cannot change because `
+                    + `${describeReference(binding)} references it. `
+                    + `Create a new Agent ID with the target ${identityChange.target} and bind the Role `
+                    + "to it instead.");
             }
         }
         assertValidAgentCandidate(existing, patch, now);
@@ -184,12 +232,14 @@ function removeAgent(args, store) {
 }
 function actualAgentChanges(existing, patch) {
     const adapter = patch.adapterId !== undefined && patch.adapterId !== existing.adapterId;
+    const component = patch.component !== undefined && patch.component !== existing.component;
     const operational = adapter
+        || component
         || (patch.command !== undefined && patch.command !== existing.command)
         || (patch.baseArgs !== undefined && !isDeepStrictEqual(patch.baseArgs, existing.baseArgs))
         || (patch.environment !== undefined
             && !isDeepStrictEqual(patch.environment, existing.environment));
-    return { adapter, operational };
+    return { adapter, component, operational };
 }
 function assertValidAgentCandidate(existing, patch, now) {
     try {
@@ -274,6 +324,7 @@ function describeReference(reference) {
 function parseAgentOptions(args, mode) {
     const valueOptions = new Map([
         ["--adapter", { repeatable: false, allowOptionLikeValue: false }],
+        ["--component", { repeatable: false, allowOptionLikeValue: false }],
         ["--command", { repeatable: false, allowOptionLikeValue: false }],
         ["--arg", { repeatable: true, allowOptionLikeValue: true }],
         ["--env", { repeatable: true, allowOptionLikeValue: false }]
@@ -339,8 +390,14 @@ function agentId(value) {
     return value.trim();
 }
 function assertAdapter(value) {
-    if (!SUPPORTED_ADAPTERS.includes(value)) {
-        throw usageError(`Agent adapter is not supported: ${value}. Supported adapters: ${SUPPORTED_ADAPTERS.join(", ")}.`);
+    if (!isAgentAdapterId(value)) {
+        throw usageError(`Agent adapter is not supported: ${value}. Supported adapters: ${supportedAgentAdapterIds().join(", ")}.`);
+    }
+}
+function assertComponent(value) {
+    if (!isAgentExecutionComponentId(value)) {
+        throw usageError(`Agent execution component is not supported: ${value}. Supported components: `
+            + `${supportedAgentExecutionComponentIds().join(", ")}.`);
     }
 }
 function assertNoArguments(args, message) {
@@ -350,6 +407,7 @@ function assertNoArguments(args, message) {
 function renderAgent(title, agent) {
     return [
         title,
+        `Component: ${agent.component} (${agentExecutionComponentLabel(agent.component)})`,
         `Adapter: ${agent.adapterId}`,
         `Executable: ${agent.command}`,
         `Arguments: ${agent.baseArgs.join(" ")}`,

package/dist/commands/capabilityCommands.js

@@ -3,9 +3,10 @@ import { resolveJobCaller } from "./taskActor.js";
 import { callFileTaskController } from "../controller/clientRuntime.js";
 export async function runCapabilityCommand(args, home, environment) {
     const [action, ...rest] = args;
-    const usage = "yui capability search [query] --task <id> | describe <name> --task <id> [--provider <id>] [--version <version>] | call <name> --task <id> --input <json> [--provider <id>] [--version <version>] [--request-id <id>]";
-    if (!["search", "describe", "call"].includes(action))
+    const usage = "yui capability search [query] --task <id> | commands --task <id> | panels --task <id> | describe <name> --task <id> [--provider <id>] [--version <version>] | call <name> --task <id> --input <json> [--provider <id>] [--version <version>] [--request-id <id>]";
+    if (!["search", "commands", "panels", "describe", "call"].includes(action))
         throw usageError(usage);
+    const surfaceList = action === "commands" || action === "panels";
     const flags = new Map();
     const positionals = [];
     const allowed = new Set(["--task", "--provider", "--version", "--input", "--request-id"]);
@@ -22,9 +23,11 @@ export async function runCapabilityCommand(args, home, environment) {
         flags.set(arg, next);
     }
     const taskId = flags.get("--task") ?? environment.YUI_TASK_ID;
-    if (!taskId || positionals.length > 1 || (action !== "search" && !positionals.length))
+    if (!taskId || positionals.length > 1
+        || (!surfaceList && action !== "search" && !positionals.length)
+        || (surfaceList && positionals.length))
         throw usageError(usage);
-    if (action === "search" && [...flags.keys()].some((key) => key !== "--task"))
+    if ((action === "search" || surfaceList) && [...flags.keys()].some((key) => key !== "--task"))
         throw usageError(usage);
     if (action === "describe" && (flags.has("--input") || flags.has("--request-id")))
         throw usageError(usage);
@@ -39,9 +42,9 @@ export async function runCapabilityCommand(args, home, environment) {
             throw usageError("Invalid capability JSON input.");
         }
     }
-    return callFileTaskController(home, `capability.${action}`, {
+    return callFileTaskController(home, `capability.${surfaceList ? "search" : action}`, {
         taskId, caller: resolveJobCaller(environment, taskId),
-        ...(action === "search" ? { query: positionals[0] ?? "" } : {
+        ...(surfaceList ? { surface: action } : action === "search" ? { query: positionals[0] ?? "" } : {
             request: {
                 name: positionals[0],
                 ...(input === undefined ? {} : { input }),

package/dist/commands/configCommands.js

@@ -1,7 +1,7 @@
 import { mkdirSync, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { usageError } from "../errors/cliError.js";
-import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryTurnCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
+import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_RUNS, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetRuns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { CONFIG_DEFINITIONS, CONFIG_KEYS, configDefinition, configDefinitionsForDomain } from "../config/configCatalog.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
@@ -77,12 +77,12 @@ export function effectiveConfigData(config, domain) {
         controllerTaskConcurrency: resolveControllerTaskConcurrency(config.controllerTaskConcurrency),
         agentLaunchInactivityTimeoutSeconds: resolveAgentLaunchInactivityTimeoutSeconds(config.agentLaunchInactivityTimeoutSeconds),
         deliveryTimeoutSeconds: resolveDeliveryTimeoutSeconds(config.deliveryTimeoutSeconds),
-        leaderSemanticBudgetTurns: resolveLeaderSemanticBudgetTurns(config.leaderSemanticBudgetTurns),
+        leaderSemanticBudgetRuns: resolveLeaderSemanticBudgetRuns(config.leaderSemanticBudgetRuns),
         tmuxBin: resolveTmuxBin(config.tmuxBin),
         tmuxHistoryLimit: resolveTmuxHistoryLimit(config.tmuxHistoryLimit),
         telemetryEnabled: resolveTelemetryEnabled(config.telemetryEnabled),
         telemetryTerminalKeep: resolveTelemetryTerminalKeep(config.telemetryTerminalKeep),
-        telemetryTurnCap: resolveTelemetryTurnCap(config.telemetryTurnCap),
+        telemetryRunCap: resolveTelemetryRunCap(config.telemetryRunCap),
         review: config.review === undefined
             ? null
             : {
@@ -263,23 +263,23 @@ const CONFIG_KEY_HANDLERS = [
         }
     },
     {
-        key: "leader-semantic-budget-turns",
+        key: "leader-semantic-budget-runs",
         showLabel: "Leader semantic budget",
-        showValue: (config) => `${resolveLeaderSemanticBudgetTurns(config.leaderSemanticBudgetTurns)} turns`,
+        showValue: (config) => `${resolveLeaderSemanticBudgetRuns(config.leaderSemanticBudgetRuns)} runs`,
         set(args, store) {
-            const usage = "Workflow config set usage: yui config workflow set leader-semantic-budget-turns <1-20>.";
+            const usage = "Workflow config set usage: yui config workflow set leader-semantic-budget-runs <1-20>.";
             if (args.length !== 1)
                 throw usageError(usage);
-            const leaderSemanticBudgetTurns = validatedConfigValue(() => resolveLeaderSemanticBudgetTurns(Number(args[0])), usage);
-            saveConfigKey(store, (config) => ({ ...config, leaderSemanticBudgetTurns }));
-            return `Leader semantic budget set to ${leaderSemanticBudgetTurns} turns\n`;
+            const leaderSemanticBudgetRuns = validatedConfigValue(() => resolveLeaderSemanticBudgetRuns(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, leaderSemanticBudgetRuns }));
+            return `Leader semantic budget set to ${leaderSemanticBudgetRuns} runs\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
-                const { leaderSemanticBudgetTurns: _removed, ...rest } = config;
+                const { leaderSemanticBudgetRuns: _removed, ...rest } = config;
                 return rest;
             });
-            return `Leader semantic budget reset to ${DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS} turns\n`;
+            return `Leader semantic budget reset to ${DEFAULT_LEADER_SEMANTIC_BUDGET_RUNS} runs\n`;
         }
     },
     {
@@ -520,22 +520,22 @@ const CONFIG_KEY_HANDLERS = [
         }
     },
     {
-        key: "telemetry-turn-cap",
-        showLabel: "Telemetry Turn cap",
-        showValue: (config) => String(resolveTelemetryTurnCap(config.telemetryTurnCap)),
+        key: "telemetry-run-cap",
+        showLabel: "Telemetry AgentRun cap",
+        showValue: (config) => String(resolveTelemetryRunCap(config.telemetryRunCap)),
         set(args, store) {
             if (args.length !== 1)
-                throw usageError("Tools config set usage: yui config tools set telemetry-turn-cap <n>.");
-            const telemetryTurnCap = validatedConfigValue(() => resolveTelemetryTurnCap(Number(args[0])), "Tools config set usage: yui config tools set telemetry-turn-cap <n>.");
-            saveConfigKey(store, (config) => ({ ...config, telemetryTurnCap }));
-            return `Telemetry Turn cap set to ${telemetryTurnCap}\n`;
+                throw usageError("Tools config set usage: yui config tools set telemetry-run-cap <n>.");
+            const telemetryRunCap = validatedConfigValue(() => resolveTelemetryRunCap(Number(args[0])), "Tools config set usage: yui config tools set telemetry-run-cap <n>.");
+            saveConfigKey(store, (config) => ({ ...config, telemetryRunCap }));
+            return `Telemetry AgentRun cap set to ${telemetryRunCap}\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
-                const { telemetryTurnCap: _removed, ...rest } = config;
+                const { telemetryRunCap: _removed, ...rest } = config;
                 return rest;
             });
-            return "Telemetry Turn cap reset to default\n";
+            return "Telemetry AgentRun cap reset to default\n";
         }
     },
     {

package/dist/commands/deliveryGuardPreflight.js

@@ -1,4 +1,4 @@
-import { resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns } from "../config/yuiConfig.js";
+import { resolveLeaderNextActionMode, resolveLeaderSemanticBudgetRuns } from "../config/yuiConfig.js";
 import { usageError } from "../errors/cliError.js";
 import { detectDeliveryDuplicates, evaluateDeliveryGuard, evaluateSemanticBudget, formatDeliveryDuplicate } from "../task/deliveryGuard.js";
 export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
@@ -15,7 +15,7 @@ export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
             + "Reuse the existing proof, or set leader.nextActionMode=warn to proceed with a warning.");
     }
     if (options.budget === true) {
-        const budget = evaluateSemanticBudget(facts, resolveLeaderSemanticBudgetTurns(store.getConfig().leaderSemanticBudgetTurns));
+        const budget = evaluateSemanticBudget(facts, resolveLeaderSemanticBudgetRuns(store.getConfig().leaderSemanticBudgetRuns));
         if (budget.exhausted) {
             warnings.push(`Semantic progress budget: ${budget.reason}`);
         }

package/dist/commands/executionAuditCommands.js

@@ -92,26 +92,26 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("tasks", report));
     }
-    if (report.turns.status === "ok" && report.turns.data !== undefined) {
-        const turns = report.turns.data;
-        lines.push("", `Turns: ${turns.total} total · ${turns.failed} failed (${(turns.failureRate * 100).toFixed(1)}%) · ${turns.completed} completed · ${turns.active} active`, `Duration: ${formatDuration(turns.cumulativeDurationMs)} total · ${formatDuration(turns.failedDurationMs)} in failed Turns`, `By role: ${turns.byRole.leader} leader · ${turns.byRole.reviewer} reviewer · ${turns.byRole.implementer} implementer/worker · ${turns.byRole.other} other`, `By purpose: ${turns.byPurpose.execution} execution · ${turns.byPurpose.review} review`);
-        const faultRows = Object.entries(turns.faultClasses)
+    if (report.runs.status === "ok" && report.runs.data !== undefined) {
+        const runs = report.runs.data;
+        lines.push("", `AgentRuns: ${runs.total} total · ${runs.failed} failed (${(runs.failureRate * 100).toFixed(1)}%) · ${runs.completed} completed · ${runs.active} active`, `Duration: ${formatDuration(runs.cumulativeDurationMs)} total · ${formatDuration(runs.failedDurationMs)} in failed AgentRuns`, `By role: ${runs.byRole.leader} leader · ${runs.byRole.reviewer} reviewer · ${runs.byRole.implementer} implementer/worker · ${runs.byRole.other} other`, `By purpose: ${runs.byPurpose.execution} execution · ${runs.byPurpose.review} review`);
+        const faultRows = Object.entries(runs.faultClasses)
             .filter(([, count]) => count > 0)
             .sort((left, right) => right[1] - left[1]);
         if (faultRows.length > 0) {
-            lines.push(renderTable("Turn failure classes", [
+            lines.push(renderTable("AgentRun failure classes", [
                 { header: "Class", minWidth: 24, maxWidth: 40 },
                 { header: "Count", minWidth: 5, maxWidth: 8 }
             ], faultRows.map(([name, count]) => [name, String(count)]), width));
         }
-        if (turns.launchFailures.total > 0) {
-            const phaseRows = Object.entries(turns.launchFailures.byPhase)
+        if (runs.launchFailures.total > 0) {
+            const phaseRows = Object.entries(runs.launchFailures.byPhase)
                 .filter(([, count]) => count > 0)
                 .sort((left, right) => right[1] - left[1]);
-            const kindRows = Object.entries(turns.launchFailures.byKind)
+            const kindRows = Object.entries(runs.launchFailures.byKind)
                 .filter(([, count]) => count > 0)
                 .sort((left, right) => right[1] - left[1]);
-            lines.push("", `Launch failures: ${turns.launchFailures.total}`, `By phase: ${phaseRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`, `By kind: ${kindRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`);
+            lines.push("", `Launch failures: ${runs.launchFailures.total}`, `By phase: ${phaseRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`, `By kind: ${kindRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`);
         }
     }
     else {
@@ -119,9 +119,9 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     }
     if (report.wakes.status === "ok" && report.wakes.data !== undefined) {
         const wakes = report.wakes.data;
-        lines.push("", `Leader wakes: ${wakes.leaderTurns} Turns · ${wakes.withWakeReasons} with reasons`);
+        lines.push("", `Leader wakes: ${wakes.leaderRuns} AgentRuns · ${wakes.withWakeReasons} with reasons`);
         if (wakes.suppressedWakes.status === "ok") {
-            lines.push(`Suppressed wakes: ${wakes.suppressedWakes.data ?? 0} (scheduler single-flight, not failed Turns)`);
+            lines.push(`Suppressed wakes: ${wakes.suppressedWakes.data ?? 0} (scheduler single-flight, not failed AgentRuns)`);
         }
         else if (wakes.suppressedWakes.status === "unsupported") {
             lines.push("Suppressed wakes: unsupported (no quiescence producer in this build)");
@@ -139,11 +139,11 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     }
     if (report.sessions.status === "ok" && report.sessions.data !== undefined) {
         const sessions = report.sessions.data;
-        lines.push("", `Sessions: ${sessions.generations} generations · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · Historical conversation switches ${sessions.conversationSwitches}`
-            + ` · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`, `Terminal by Turn relation: ${sessions.terminalByTurnRelation.postTurnCompleted} post-turn-completed`
-            + ` · ${sessions.terminalByTurnRelation.turnFailed} turn-failed`
-            + ` · ${sessions.terminalByTurnRelation.activeTurn} active-turn`
-            + ` · ${sessions.terminalByTurnRelation.noTurn} no-turn`);
+        lines.push("", `Sessions: ${sessions.count} count · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · Historical conversation switches ${sessions.conversationSwitches}`
+            + ` · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`, `Terminal by AgentRun relation: ${sessions.terminalByRunRelation.postRunCompleted} post-turn-completed`
+            + ` · ${sessions.terminalByRunRelation.runFailed} turn-failed`
+            + ` · ${sessions.terminalByRunRelation.activeRun} active-turn`
+            + ` · ${sessions.terminalByRunRelation.noRun} no-turn`);
     }
     else {
         lines.push("", ...sectionError("sessions", report));
@@ -185,7 +185,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
                 .map(([category, count]) => `${category}:${count}`).join(", ")}`);
             lines.push(renderTable("Agent errors", [
                 { header: "Task", minWidth: 8, maxWidth: 14 },
-                { header: "Turn", minWidth: 14, maxWidth: 24 },
+                { header: "AgentRun", minWidth: 14, maxWidth: 24 },
                 { header: "Role", minWidth: 8, maxWidth: 12 },
                 { header: "Category", minWidth: 12, maxWidth: 20 },
                 { header: "Code", minWidth: 16, maxWidth: 32 },
@@ -194,7 +194,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
                 { header: "Session", minWidth: 12, maxWidth: 16 }
             ], errors.entries.map((entry) => [
                 entry.taskId,
-                entry.turnId,
+                entry.runId,
                 entry.roleName,
                 entry.category,
                 entry.code,
@@ -223,7 +223,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
             lines.push(renderTable("Task orchestration metrics", [
                 { header: "Task", minWidth: 7, maxWidth: 14 },
                 { header: "Type", minWidth: 8, maxWidth: 12 },
-                { header: "Turns", minWidth: 4, maxWidth: 6 },
+                { header: "AgentRuns", minWidth: 4, maxWidth: 6 },
                 { header: "WIs", minWidth: 3, maxWidth: 5 },
                 { header: "Review F/D/X", minWidth: 12, maxWidth: 16 },
                 { header: "Integration A/F/R", minWidth: 17, maxWidth: 20 },
@@ -233,11 +233,11 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
             ], orchestration.tasks.map((task) => [
                 task.taskId,
                 task.taskType ?? "unspecified",
-                String(task.turns.total),
+                String(task.runs.total),
                 String(task.workItems),
                 `${task.reviews.full}/${task.reviews.delta}/${task.reviews.failed}`,
                 `${task.integrations.attempts}/${task.integrations.failed}/${task.integrations.repeatedIdentities}`,
-                String(task.providerGenerationsBeforeFirstProgress),
+                String(task.providerSessionsBeforeFirstProgress),
                 String(task.terminalWorkspaceCount),
                 String(task.advisories.length)
             ]), width));
@@ -276,15 +276,15 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     if (report.topLongRunning.status === "ok" && report.topLongRunning.data !== undefined) {
         const entries = report.topLongRunning.data;
         if (entries.length > 0) {
-            lines.push("", renderTable("Top long-running Turns", [
+            lines.push("", renderTable("Top long-running AgentRuns", [
                 { header: "Task", minWidth: 8, maxWidth: 14 },
-                { header: "Turn", minWidth: 14, maxWidth: 24 },
+                { header: "AgentRun", minWidth: 14, maxWidth: 24 },
                 { header: "Role", minWidth: 10, maxWidth: 20 },
                 { header: "Status", minWidth: 8, maxWidth: 10 },
                 { header: "Duration", minWidth: 8, maxWidth: 10 }
             ], entries.map((entry) => [
                 entry.taskId,
-                entry.turnId,
+                entry.runId,
                 entry.roleName,
                 entry.status,
                 formatDuration(entry.durationMs)

package/dist/commands/globalRoleCommands.js

@@ -248,7 +248,7 @@ function bindRole(args, store) {
         const activeSession = existingSet?.sessions[existingSet.activeAgentId];
         try {
             const switched = switchActiveRoleAgent(withBinding, existingSet ?? createRoleSessionSet({ scope: "global", roleName: name }, role.activeAgentId, now), agentId, {
-                activeTurn: false,
+                activeRun: false,
                 nativeProcessRunning: activeSession !== undefined
                     && activeSession.status === "active"
             }, now);

package/dist/commands/grantCommands.js

@@ -67,13 +67,13 @@ function issueGrant(args, store, options) {
  * Grant issue and revoke carry irreversible authority: they mint or revoke
  * the capability that lets a managed Agent perform irreversible site changes.
  * The only accepted origin is the authenticated global Operator Session,
- * whose env claims are verified against the durable live session binding by
+ * whose native conversation ID is matched against the durable live binding by
  * isCurrentGlobalOperator.
  *
  * Absence of YUI identity vars is deliberately NOT treated as user authority:
  * a managed Agent can clear its child-process environment, so a "clean"
  * environment is indistinguishable from a scrubbed managed one. A Task-scoped
- * Session, a partial managed identity, and a stale/forged global binding are
+ * Session, an absent conversation identity, and a replaced global conversation are
  * all refused. Caller-supplied --granter/--by labels are not identity; the
  * recorded granter/revoker is bound to the Operator Session instead.
  */
@@ -83,8 +83,8 @@ function authorizeGrantOrigin(store, env, usage) {
             "session. A managed Agent cannot self-issue or self-revoke a " +
             "capability grant, and a clean environment is not user authority.", usage);
     }
-    // isCurrentGlobalOperator verified YUI_AGENT_ID against the durable binding.
-    return `operator:${env.YUI_AGENT_ID ?? "unknown"}`;
+    // Identity comes from the matched durable conversation, not an env label.
+    return `operator:${store.getGlobalRole("operator").activeAgentId}`;
 }
 function showGrant(args, store) {
     const usage = "Task grant show usage: yui task grant show <task> <grant-id>.";

package/dist/commands/operatorCommands.js

@@ -1,4 +1,5 @@
 import { usageError } from "../errors/cliError.js";
+import { agentAdapterLabel as adapterLabel } from "../agent/adapterCatalog.js";
 import { createRoleSessionSet } from "../executor/agentExecutor.js";
 import { listOperatorSessions, projectOperatorStatus, prepareOperatorNewSession, prepareOperatorResumeSession } from "../operator/operatorSessionHistory.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
@@ -214,13 +215,6 @@ function requireOperator(store) {
         throw usageError("Operator is not configured. Run yui setup first.");
     return role;
 }
-function adapterLabel(adapterId) {
-    return adapterId === "codex"
-        ? "Codex"
-        : adapterId === "claude"
-            ? "Claude"
-            : adapterId;
-}
 function requiredValue(value, option) {
     if (value === undefined || value.startsWith("--") || value.trim().length === 0) {
         throw usageError(`${option} is required.`);

package/dist/commands/projectCommands.js

@@ -555,7 +555,7 @@ function assertNoActiveTaskBinding(store, project, action) {
     if (references.activeTaskIds.length > 0) {
         const delivery = [
             ...references.unresolvedWorkItemRefs,
-            ...references.activeTurnRefs,
+            ...references.activeRunRefs,
             ...references.unresolvedIntegrationRefs
         ];
         throw usageError(`Project cannot be ${action} while an active Task binds it: ${project.id}. `
@@ -846,7 +846,7 @@ async function replaceProject(args, store, options) {
 }
 /**
  * Auditable soft deprecation. The catalog record, checkout, and every
- * historical Task/Turn/Review/Integration/Publication reference are retained;
+ * historical Task/AgentRun/Review/Integration/Publication reference are retained;
  * the Project can no longer be bound to new work or maintained. Hard removal
  * is a separate `project delete` decision.
  */
@@ -871,7 +871,7 @@ function retireProjectCommand(args, store, options) {
         `Retired project ${retired.project.id} (${retired.project.name})`,
         `Reason: ${parsed.reason}`,
         `Retired by: ${retiredBy} at ${retired.project.retirement?.retiredAt ?? "?"}`,
-        "The catalog record, checkout, and historical Task/Turn/Review/Integration/Publication evidence are retained.",
+        "The catalog record, checkout, and historical Task/AgentRun/Review/Integration/Publication evidence are retained.",
         ...(retired.references.boundTaskIds.length === 0
             ? []
             : [`Historical Task bindings retained: ${retired.references.boundTaskIds.join(", ")}.`]),
@@ -998,7 +998,7 @@ function removeRetiredProjectRecord(store, projectId) {
         if (references.boundTaskIds.length > 0) {
             throw usageError(`Project cannot be deleted while Task records reference it: ${latest.id}. `
                 + `Bound Tasks: ${references.boundTaskIds.join(", ")}. `
-                + "Historical Task/Turn/Review/Integration/Publication evidence must stay resolvable; keep the Project retired instead.");
+                + "Historical Task/AgentRun/Review/Integration/Publication evidence must stay resolvable; keep the Project retired instead.");
         }
         if (!tx.removeProject(latest.id)) {
             throw new Error(`Project was already removed: ${latest.id}.`);

package/dist/commands/resourcesCommands.js

@@ -123,11 +123,11 @@ function collectTaskStatuses(store) {
     }
     return statuses;
 }
-/** Workspace paths claimed by active durable Jobs (Turns). */
+/** Workspace paths claimed by active durable Jobs (AgentRuns). */
 function collectActiveWorkspaceOwnerPaths(store) {
     const paths = [];
     for (const task of store.listTasks()) {
-        for (const run of store.listTurns(task.id)) {
+        for (const run of store.listRuns(task.id)) {
             if (run.status !== "active")
                 continue;
             const workspace = run.workspace;

package/dist/commands/roleConfiguration.js

@@ -187,7 +187,12 @@ function permissionPatch(binding, parsed) {
     }
     const current = binding.config.permission;
     if (selected !== "configured" && !nativeOptions) {
-        return structuredClone(current ?? { strategy: "bypass" });
+        // Nothing about permission was named, so the binding keeps what it already
+        // had. The fallback applies only to a binding that somehow carries no
+        // permission at all, and it must be the adapter's own default rather than a
+        // fixed `bypass`: ACP defaults to `default`, and defaulting it to bypass
+        // here would widen authority the user never granted.
+        return structuredClone(current ?? defaultRoleAgentConfig(binding.adapterId).permission);
     }
     const permission = current?.strategy === "configured"
         ? structuredClone(current)
@@ -199,6 +204,15 @@ function permissionPatch(binding, parsed) {
         if (parsed.has("--approval"))
             permission.approval = requiredText(parsed.one("--approval"));
     }
+    else if (binding.adapterId === "acp") {
+        // An ACP Session's configured permission is exactly one mode id, matched
+        // against what the Agent enumerates at launch. Tool rules are a Claude
+        // launch-flag concept with no ACP equivalent, so they are excluded above
+        // rather than silently written into a config the adapter would reject.
+        if (parsed.has("--permission-mode")) {
+            permission.mode = requiredText(parsed.one("--permission-mode"));
+        }
+    }
     else {
         if (parsed.has("--permission-mode")) {
             permission.mode = requiredText(parsed.one("--permission-mode"));
@@ -242,16 +256,22 @@ function assertAgentOptionConflicts(parsed) {
 }
 function assertAdapterOptions(adapterId, parsed) {
     const codex = ["--sandbox", "--approval", "--search", "--clear-search"];
-    const claude = [
-        "--permission-mode",
+    const tools = [
         "--allowed-tool", "--clear-allowed-tools",
         "--disallowed-tool", "--clear-disallowed-tools"
     ];
     if (adapterId !== "codex" && codex.some((option) => parsed.has(option))) {
         throw usageError("Sandbox, approval, and search settings are only supported by Codex.");
     }
-    if (adapterId !== "claude" && claude.some((option) => parsed.has(option))) {
-        throw usageError("Permission mode and tool rules are only supported by Claude.");
+    if (adapterId !== "claude" && tools.some((option) => parsed.has(option))) {
+        throw usageError("Tool rules are only supported by Claude.");
+    }
+    // `--permission-mode` is shared: Claude takes its own permission mode as a
+    // launch flag, and ACP selects a session mode the Agent enumerated. Codex has
+    // neither, so it stays excluded. Which mode ids are valid is not decided here
+    // — for ACP only the live Session can say, and that check happens there.
+    if (adapterId !== "claude" && adapterId !== "acp" && parsed.has("--permission-mode")) {
+        throw usageError("Permission mode is only supported by Claude and ACP Agents.");
     }
 }
 function assertPairs(parsed, pairs) {