@zq-silk/yui 0.7.1 → 0.8.1

package/dist/setup/setupCommand.js

@@ -1,22 +1,14 @@
 import { existsSync, mkdirSync, realpathSync } from "node:fs";
 import { delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { isDeepStrictEqual } from "node:util";
 import { configuredAgentToDefinition, createConfiguredAgent } from "../agent/agent.js";
-import { selectAgentPermission, selectAgentModelAndEffort } from "../cli/agentConfigurationPicker.js";
-import { runCompletionWizard } from "../completion/completionWizard.js";
+import { assertRoleRuntimeMutationAllowed } from "../commands/roleRuntimeGuard.js";
+import { resolveTmuxBin } from "../config/yuiConfig.js";
 import { usageError } from "../errors/cliError.js";
-import { defaultRoleAgentConfig, resolveAgentAdapter } from "../executor/agentAdapter.js";
-import { AgentConfigurationCatalogService } from "../executor/agentConfigurationCatalog.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { resolveTimeZone } from "../output/timePresentation.js";
 import { createGlobalRole, createRoleAgentBinding, updateGlobalRole } from "../role/role.js";
-import { SYSTEM_LEADER_ROLE, SYSTEM_OPERATOR_ROLE, SYSTEM_WORKER_ROLE } from "../role/systemRoles.js";
-import { DEFAULT_REVIEWER_ROLE } from "../review/reviewConfig.js";
-import { builtinAgentProfileInputs, createAgentProfile } from "../profile/agentProfile.js";
-import { assertRoleRuntimeMutationAllowed } from "../commands/roleRuntimeGuard.js";
+import { SYSTEM_LEADER_ROLE, SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
+import { initializeCompatibleTaskStore } from "../storage/compatibleTaskStore.js";
 import { ensureYuiHome, resolveYuiHome } from "../storage/taskStore.js";
-import { initializeCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
 const BUILTIN_AGENTS = Object.freeze([
     Object.freeze({
         id: "codex",
@@ -32,7 +24,7 @@ const BUILTIN_AGENTS = Object.freeze([
     })
 ]);
 export async function runSetupCommand(args, env, executor, io = {}) {
-    const dependency = parseSetupOptions(args);
+    parseSetupOptions(args);
     if (!shouldPrompt(io))
         throw setupRequiresInteractiveError();
     const readline = createInterface({
@@ -44,48 +36,32 @@ export async function runSetupCommand(args, env, executor, io = {}) {
         const question = createSetupQuestion(readline, io);
         const home = resolveYuiHome(env);
         ensureYuiHome(home);
-        const store = initializeCompatibleFileTaskStore(home);
-        const catalogs = new AgentConfigurationCatalogService(home, { environment: env });
-        const result = await configureYui(store, home, env, question, setupSelectionIo(question, io), catalogs, io);
-        const lines = [
-            "Yui home initialized.",
-            `Agents configured: ${result.agentIds.join(", ")}.`,
-            `Default Agent: ${result.defaultAgentId}.`,
-            `Operator Agent: ${result.operatorAgentId}.`,
-            `Leader model: ${result.leaderConfig.model ?? "CLI default"}.`,
-            `Leader reasoning effort: ${result.leaderConfig.effort ?? "CLI default"}.`,
-            `Leader permission: ${result.leaderConfig.permission.strategy}.`,
-            `Operator model: ${result.operatorConfig.model ?? "CLI default"}.`,
-            `Operator reasoning effort: ${result.operatorConfig.effort ?? "CLI default"}.`,
-            `Operator permission: ${result.operatorConfig.permission.strategy}.`,
-            `Worker Agent: ${result.workerAgentId}.`,
-            `Worker configuration: ${result.workerReusesLeader
-                ? "Reused Leader configuration"
-                : "Configured separately"}.`,
-            `Worker model: ${result.workerConfig.model ?? "CLI default"}.`,
-            `Worker reasoning effort: ${result.workerConfig.effort ?? "CLI default"}.`,
-            `Worker permission: ${result.workerConfig.permission.strategy}.`,
-            ...(result.reviewerInitialized
-                ? [
-                    `Reviewer Agent: ${result.reviewerAgentId}.`,
-                    `Reviewer model: ${result.reviewerConfig?.model ?? "CLI default"}.`,
-                    `Reviewer reasoning effort: ${result.reviewerConfig?.effort ?? "CLI default"}.`,
-                    `Reviewer permission: ${result.reviewerConfig?.permission.strategy}.`,
-                    ...(result.reviewPolicy === undefined
-                        ? ["Review policy: disabled."]
-                        : [`Review policy: ${result.reviewPolicy.roleName} (${result.reviewPolicy.trigger}).`])
-                ]
-                : []),
-            `Project workspace: ${result.workspace}.`,
-            `Time zone: ${resolveTimeZone(store.getConfig().timeZone)}.`
-        ];
-        if (dependency === undefined || dependency === "tmux") {
-            lines.push(...await setupTmux(env, executor, question));
+        const store = initializeCompatibleTaskStore(home);
+        const tmuxBin = resolveTmuxBin(store.getConfig().tmuxBin);
+        assertTmuxAvailable(executor, tmuxBin);
+        const choices = availableAgentChoices(store, env);
+        if (choices.length === 0) {
+            throw usageError("No usable Agent configuration was found. Setup never overwrites an existing Agent id; "
+                + "repair it with yui config agent update, add another usable Agent with yui config agent add, "
+                + "or install Codex or Claude, then run yui setup again.");
         }
-        const completion = await runCompletionWizard("install", store, env, cliIdentity(env), question, { width: tableWidth(io), defaultSelection: "skip" });
-        lines.push(completion.trimEnd());
-        lines.push("Yui setup complete.");
-        return `${lines.join("\n")}\n`;
+        const currentOperator = store.getGlobalRole(SYSTEM_OPERATOR_ROLE);
+        const selected = await selectOperatorAgent(choices, currentOperator, store.getConfig().defaultAgent, question, io);
+        const agent = selected.existing ?? createConfiguredAgent(selected.id, selected.adapterId, selected.command, [], [], new Date());
+        const workspace = resolveWorkspace(store.getConfig().defaultWorkspace ?? join(dirname(resolve(home)), "workspace"), home);
+        const roleStatus = saveMinimumConfiguration(store, agent, workspace, new Set(choices.map(({ id }) => id)));
+        return `${[
+            "Yui setup complete.",
+            `Yui home: ${home}.`,
+            `Operator Agent: ${agent.id}.`,
+            `Leader Agent: ${roleStatus.leaderAgentId}.`,
+            `Default workspace: ${workspace}.`,
+            `Operator configuration: ${roleStatus.operator}.`,
+            `Leader configuration: ${roleStatus.leader}.`,
+            `Tmux: ${tmuxBin}.`,
+            "Setup did not configure Review, Worker, Profiles, or shell completion.",
+            "Run `yui operator enter` to continue, or `yui config show` to inspect configuration."
+        ].join("\n")}\n`;
     }
     finally {
         readline.close();
@@ -96,371 +72,129 @@ export function validateSetupInvocation(args, io = {}) {
     if (!shouldPrompt(io))
         throw setupRequiresInteractiveError();
 }
-async function configureYui(store, home, env, question, selectionIo, catalogs, io) {
-    const initialConfig = store.getConfig();
-    const freshHome = store.listGlobalRoles().length === 0
-        && store.listConfiguredAgents().length === 0
-        && initialConfig.defaultAgent === undefined
-        && initialConfig.defaultWorkspace === undefined
-        && initialConfig.review === undefined;
-    const candidates = availableAgentChoices(store, env);
-    if (candidates.length === 0) {
-        throw usageError("No supported Agent CLI was found. Install Codex or Claude, then run setup again.");
-    }
-    io.output?.write(`${renderTable("Available Agents", [
-        { header: "#", minWidth: 1, maxWidth: 3 },
-        { header: "Agent", minWidth: 6, maxWidth: 16 },
-        { header: "Adapter", minWidth: 7, maxWidth: 10 },
-        { header: "Command", minWidth: 7, maxWidth: 24 },
-        { header: "Description", minWidth: 12, maxWidth: 42 }
-    ], candidates.map((candidate, index) => [
-        String(index + 1),
-        candidate.id,
-        candidate.adapterId,
-        candidate.command,
-        candidate.description
-    ]), tableWidth(io))}\n`);
-    const selected = parseAgentSetSelection(await question(`Choose Agents by number or name, comma-separated [all: ${candidates.map(({ id }) => id).join(", ")}]: `), candidates);
-    const now = new Date();
-    const prepared = selected.map((choice) => prepareAgent(store, choice, now));
-    const configuredIds = new Set(prepared.map(({ id }) => id));
-    const config = store.getConfig();
-    const defaultFallback = prepared.some(({ id }) => id === config.defaultAgent)
-        ? config.defaultAgent
-        : prepared[0].id;
-    const defaultAgentId = parseSingleAgentSelection(await question(`Choose default Agent [${defaultFallback}]: `), prepared, defaultFallback);
-    const currentOperatorAgent = store.getGlobalRole(SYSTEM_OPERATOR_ROLE)?.activeAgentId;
-    const operatorFallback = configuredIds.has(currentOperatorAgent ?? "")
-        ? currentOperatorAgent
-        : defaultAgentId;
-    const operatorAgentId = parseSingleAgentSelection(await question(`Choose Operator Agent [${operatorFallback}]: `), prepared, operatorFallback);
-    const existingReviewer = store.getGlobalRole(DEFAULT_REVIEWER_ROLE);
-    const reviewerInitialized = freshHome || existingReviewer !== null;
-    let reviewerAgentId;
-    let reviewerConfig;
-    if (reviewerInitialized) {
-        const reviewerFallback = configuredIds.has(existingReviewer?.activeAgentId ?? "")
-            ? existingReviewer.activeAgentId
-            : defaultAgentId;
-        reviewerAgentId = parseSingleAgentSelection(await question(`Choose Reviewer Agent [${reviewerFallback}]: `), prepared, reviewerFallback);
-        const reviewerAgent = prepared.find(({ id }) => id === reviewerAgentId);
-        if (reviewerAgent === undefined) {
-            throw usageError("Selected Reviewer Agent is no longer available.");
-        }
-        reviewerConfig = await promptRoleAgentConfig("Reviewer", reviewerAgent, existingReviewer, home, selectionIo, catalogs, true);
-    }
-    const defaultAgent = prepared.find(({ id }) => id === defaultAgentId);
-    const operatorAgent = prepared.find(({ id }) => id === operatorAgentId);
-    if (defaultAgent === undefined || operatorAgent === undefined) {
-        throw usageError("Selected setup Agent is no longer available.");
-    }
-    const leaderConfig = await promptRoleAgentConfig("Leader", defaultAgent, store.getGlobalRole(SYSTEM_LEADER_ROLE), home, selectionIo, catalogs);
-    const operatorConfig = await promptRoleAgentConfig("Operator", operatorAgent, store.getGlobalRole(SYSTEM_OPERATOR_ROLE), home, selectionIo, catalogs);
-    const existingWorker = store.getGlobalRole(SYSTEM_WORKER_ROLE);
-    const workerModeFallback = workerConfigurationModeFallback(existingWorker, defaultAgentId, leaderConfig);
-    io.output?.write("\n\nWorker is the default Agent configuration copied into Task Roles such as "
-        + "investigator and implementer. Each Task Role gets its own Session.\n");
-    const workerReusesLeader = await selectWorkerConfigurationMode(question, io, workerModeFallback) === "reuse-leader";
-    let workerAgentId = defaultAgentId;
-    let workerConfig = structuredClone(leaderConfig);
-    if (!workerReusesLeader) {
-        io.output?.write("\n\nConfigure Worker separately:\n");
-        const existingWorkerAgent = existingWorker?.activeAgentId;
-        const workerFallback = configuredIds.has(existingWorkerAgent ?? "")
-            ? existingWorkerAgent
-            : defaultAgentId;
-        workerAgentId = parseSingleAgentSelection(await question(`Choose Worker Agent [${workerFallback}]: `), prepared, workerFallback);
-        const workerAgent = prepared.find(({ id }) => id === workerAgentId);
-        if (workerAgent === undefined) {
-            throw usageError("Selected Worker Agent is no longer available.");
-        }
-        workerConfig = await promptRoleAgentConfig("Worker", workerAgent, existingWorker, home, selectionIo, catalogs, true);
-    }
-    const suggestedWorkspace = config.defaultWorkspace?.trim()
-        || join(dirname(resolve(home)), "workspace");
-    io.output?.write("\n\n");
-    const workspaceAnswer = (await question(`Project workspace for stable checkouts and managed worktrees [${suggestedWorkspace}]: `)).trim();
-    const workspace = resolveWorkspace(workspaceAnswer || suggestedWorkspace, home);
-    if (config.defaultWorkspace !== undefined
-        && resolve(config.defaultWorkspace) !== workspace) {
-        throw usageError(`Project workspace is fixed after setup: ${resolve(config.defaultWorkspace)}.`);
-    }
-    store.transaction((tx) => {
-        for (const agent of prepared)
-            tx.saveConfiguredAgent(agent);
-        const latestDefaultAgent = requireSetupAgent(tx, defaultAgentId);
-        const latestOperatorAgent = requireSetupAgent(tx, operatorAgentId);
-        const latestWorkerAgent = requireSetupAgent(tx, workerAgentId);
-        const operatorRole = prepareSystemRole(tx, SYSTEM_OPERATOR_ROLE, latestOperatorAgent, workspace, now, operatorConfig);
-        const leaderRole = prepareSystemRole(tx, SYSTEM_LEADER_ROLE, latestDefaultAgent, workspace, now, leaderConfig);
-        const workerRole = prepareSystemRole(tx, SYSTEM_WORKER_ROLE, latestWorkerAgent, workspace, now, workerConfig);
-        const reviewerRole = reviewerInitialized
-            && reviewerAgentId !== undefined
-            && reviewerConfig !== undefined
-            ? prepareSystemRole(tx, DEFAULT_REVIEWER_ROLE, requireSetupAgent(tx, reviewerAgentId), workspace, now, reviewerConfig, freshHome ? reviewerRoleProfile() : undefined)
-            : null;
-        const latest = tx.getConfig();
-        tx.saveConfig({
-            ...latest,
-            defaultAgent: defaultAgentId,
-            defaultWorkspace: workspace,
-            timeZone: resolveTimeZone(latest.timeZone),
-            ...(freshHome
-                ? { review: { roleName: DEFAULT_REVIEWER_ROLE, trigger: "final" } }
-                : {})
+function availableAgentChoices(store, env) {
+    const choices = new Map();
+    const configured = store.listConfiguredAgents();
+    const configuredIds = new Set(configured.map(({ id }) => id));
+    for (const agent of configured) {
+        if (!commandOnPath(agent.command, env))
+            continue;
+        choices.set(agent.id, {
+            id: agent.id,
+            adapterId: agent.adapterId,
+            command: agent.command,
+            description: "Existing Yui Agent",
+            existing: agent
         });
-        if (operatorRole !== null)
-            savePreparedSystemRole(tx, operatorRole, now);
-        if (leaderRole !== null)
-            savePreparedSystemRole(tx, leaderRole, now);
-        if (workerRole !== null)
-            savePreparedSystemRole(tx, workerRole, now);
-        if (reviewerRole !== null)
-            savePreparedSystemRole(tx, reviewerRole, now);
-        seedBuiltinProfiles(tx, now);
-    });
-    return {
-        agentIds: prepared.map(({ id }) => id),
-        defaultAgentId,
-        operatorAgentId,
-        leaderConfig,
-        operatorConfig,
-        workerAgentId,
-        workerConfig,
-        workerReusesLeader,
-        reviewerInitialized,
-        ...(reviewerAgentId === undefined ? {} : { reviewerAgentId }),
-        ...(reviewerConfig === undefined ? {} : { reviewerConfig }),
-        ...(freshHome
-            ? { reviewPolicy: { roleName: DEFAULT_REVIEWER_ROLE, trigger: "final" } }
-            : initialConfig.review === undefined ? {} : { reviewPolicy: initialConfig.review }),
-        workspace
-    };
-}
-function reviewerRoleProfile() {
-    const reviewer = builtinAgentProfileInputs().find(({ id }) => id === "reviewer");
-    if (reviewer === undefined)
-        return {};
-    return {
-        ...(reviewer.description === undefined ? {} : { description: reviewer.description }),
-        ...(reviewer.instructions === undefined ? {} : { systemPrompt: reviewer.instructions }),
-        ...(reviewer.skills === undefined ? {} : { skills: [...reviewer.skills] })
-    };
-}
-async function selectWorkerConfigurationMode(question, io, fallback) {
-    const choices = [
-        [
-            "1",
-            `Reuse Leader${fallback === "reuse-leader" ? " (default)" : ""}`,
-            "Copy the complete Leader Agent launch configuration; skip Worker-specific prompts"
-        ],
-        [
-            "2",
-            `Configure separately${fallback === "configure-separately" ? " (default)" : ""}`,
-            "Choose the Worker Agent, model, effort, and permission independently"
-        ]
-    ];
-    const fallbackNumber = fallback === "reuse-leader" ? "1" : "2";
-    io.output?.write(`\n${renderTable("Choose Worker configuration", [
-        { header: "#", minWidth: 1, maxWidth: 4 },
-        { header: "Choice", minWidth: 16, maxWidth: 28 },
-        { header: "Consequence", minWidth: 24, maxWidth: 64 }
-    ], choices, tableWidth(io))}\n\n`);
-    return parseWorkerConfigurationMode(await question(`Choose Worker configuration [1-2; default ${fallbackNumber}]: `), fallback);
-}
-function workerConfigurationModeFallback(existing, leaderAgentId, leaderConfig) {
-    if (existing === null)
-        return "reuse-leader";
-    return existing.activeAgentId === leaderAgentId
-        && isDeepStrictEqual(existing.agentBindings[leaderAgentId]?.config, leaderConfig)
-        ? "reuse-leader"
-        : "configure-separately";
-}
-function parseWorkerConfigurationMode(answer, fallback) {
-    const value = answer.trim().toLowerCase();
-    if (value.length === 0)
-        return fallback;
-    if (["1", "reuse", "reuse leader", "leader"].includes(value))
-        return "reuse-leader";
-    if (["2", "configure", "configure separately", "separate"].includes(value)) {
-        return "configure-separately";
-    }
-    throw usageError("Choose reuse Leader or configure separately for Worker.");
-}
-function savePreparedSystemRole(store, role, now) {
-    const sessions = store.getGlobalRoleSessionSet(role.name);
-    const activeSession = sessions?.sessions[sessions.activeAgentId];
-    if (sessions === null
-        || sessions.activeAgentId === role.activeAgentId
-        || (activeSession !== undefined && activeSession.status !== "stopped")) {
-        store.saveGlobalRole(role);
-        return;
     }
-    store.saveGlobalRoleWithSessionSet(role, {
-        ...sessions,
-        activeAgentId: role.activeAgentId,
-        updatedAt: now.toISOString()
-    });
-}
-function seedBuiltinProfiles(store, now) {
-    for (const desired of builtinAgentProfileInputs()) {
-        const existing = store.getAgentProfile(desired.id);
-        if (existing === null)
-            store.saveAgentProfile(createAgentProfile(desired, now));
+    for (const builtin of BUILTIN_AGENTS) {
+        if (configuredIds.has(builtin.id) || !commandOnPath(builtin.command, env))
+            continue;
+        choices.set(builtin.id, builtin);
+    }
+    return [...choices.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+async function selectOperatorAgent(choices, currentOperator, defaultAgent, question, io) {
+    const current = choices.find(({ id }) => id === currentOperator?.activeAgentId);
+    if (current !== undefined)
+        return current;
+    const configuredDefault = choices.find(({ id }) => id === defaultAgent);
+    if (configuredDefault !== undefined)
+        return configuredDefault;
+    if (choices.length === 1)
+        return choices[0];
+    io.output?.write([
+        "Available Operator Agents:",
+        ...choices.map((choice, index) => `  ${index + 1}. ${choice.id} (${choice.adapterId}) - ${choice.description}`),
+        ""
+    ].join("\n"));
+    const answer = (await question(`Choose Operator Agent [1: ${choices[0].id}]: `)).trim();
+    if (answer.length === 0)
+        return choices[0];
+    const numeric = Number(answer);
+    const selected = Number.isSafeInteger(numeric) && numeric >= 1 && numeric <= choices.length
+        ? choices[numeric - 1]
+        : choices.find(({ id }) => id.toLowerCase() === answer.toLowerCase());
+    if (selected === undefined) {
+        throw usageError("Choose one available Agent by number or name.");
     }
+    return selected;
 }
-async function promptRoleAgentConfig(label, agent, existingRole, cwd, io, catalogs, selectPermission = false) {
-    const existing = existingRole?.activeAgentId === agent.id
-        ? existingRole.agentBindings[agent.id]?.config
-        : undefined;
-    io.write(`\n\n${label} Agent configuration: ${agent.id}\n`);
-    const resolved = await catalogs.resolve({
-        agent,
-        cwd,
-        ...(existing === undefined ? {} : { config: existing })
-    });
-    const selection = await selectAgentModelAndEffort(resolved, io, {
-        currentModel: existing?.model,
-        currentEffort: existing?.effort
-    });
-    if (selection.kind === "cancelled") {
-        throw usageError(`${label} Agent configuration was cancelled.`);
-    }
-    const candidate = structuredClone(existing ?? defaultRoleAgentConfig(agent.adapterId));
-    if (selection.model === undefined)
-        delete candidate.model;
-    else
-        candidate.model = selection.model;
-    if (selection.effort === undefined)
-        delete candidate.effort;
-    else
-        candidate.effort = selection.effort;
-    if (selectPermission) {
-        const permission = await selectAgentPermission(resolved, io, candidate.permission);
-        if (permission.kind === "cancelled") {
-            throw usageError(`${label} permission configuration was cancelled.`);
+function saveMinimumConfiguration(store, agent, workspace, usableAgentIds) {
+    return store.transaction((tx) => {
+        tx.saveConfiguredAgent(agent);
+        const config = tx.getConfig();
+        tx.saveConfig({
+            ...config,
+            defaultAgent: config.defaultAgent ?? agent.id,
+            defaultWorkspace: config.defaultWorkspace ?? workspace
+        });
+        const now = new Date();
+        const leader = tx.getGlobalRole(SYSTEM_LEADER_ROLE);
+        let leaderStatus = "preserved";
+        let leaderAgentId = leader?.activeAgentId;
+        if (leader === null) {
+            assertRoleRuntimeMutationAllowed(tx, {
+                scope: "global",
+                roleName: SYSTEM_LEADER_ROLE
+            }, "creation");
+            const definition = configuredAgentToDefinition(agent);
+            tx.saveGlobalRole(createGlobalRole(SYSTEM_LEADER_ROLE, [createRoleAgentBinding(definition)], agent.id, workspace, now));
+            leaderStatus = "created";
+            leaderAgentId = agent.id;
         }
-        candidate.permission = permission.permission;
-    }
-    try {
-        return resolveAgentAdapter(agent.adapterId).canonicalizeConfig(candidate);
-    }
-    catch (error) {
-        throw usageError(error instanceof Error ? error.message : String(error));
-    }
-}
-function availableAgentChoices(store, env) {
-    const existing = new Map(store.listConfiguredAgents().map((agent) => [agent.id, agent]));
-    return BUILTIN_AGENTS.flatMap((builtin) => {
-        const configured = existing.get(builtin.id);
-        const command = configured?.command ?? builtin.command;
-        if (!commandOnPath(command, env))
-            return [];
-        return [{
-                ...builtin,
-                adapterId: configured?.adapterId ?? builtin.adapterId,
-                command
-            }];
-    });
-}
-function setupSelectionIo(question, io) {
-    return {
-        interactive: true,
-        json: false,
-        width: tableWidth(io),
-        write: (value) => { io.output.write(value); },
-        question
-    };
-}
-function prepareAgent(store, choice, now) {
-    const existing = store.getConfiguredAgent(choice.id);
-    if (existing !== null
-        && existing.adapterId === choice.adapterId
-        && existing.command === choice.command) {
-        return existing;
-    }
-    const agent = createConfiguredAgent(choice.id, choice.adapterId, choice.command, existing?.baseArgs ?? [], existing?.environment ?? [], now);
-    return agent;
-}
-function requireSetupAgent(store, agentId) {
-    const agent = store.getConfiguredAgent(agentId);
-    if (agent === null)
-        throw usageError(`Configured Agent not found: ${agentId}.`);
-    return agent;
-}
-function prepareSystemRole(store, name, agent, workspace, now, config, profile) {
-    const existing = store.getGlobalRole(name);
-    if (existing !== null) {
-        const definition = configuredAgentToDefinition(agent);
-        const binding = createRoleAgentBinding(definition, config);
-        if (name === "operator" && !Object.hasOwn(existing.agentBindings, agent.id)) {
-            const sameAdapter = Object.values(existing.agentBindings).find((candidate) => candidate.adapterId === agent.adapterId);
-            if (sameAdapter !== undefined) {
-                throw usageError(`${name} already has a ${agent.adapterId} Agent: ${sameAdapter.agentId}. `
-                    + "Update that Agent's configuration, or activate another adapter and "
-                    + "unbind it before selecting this Agent.");
-            }
+        if (leaderAgentId === undefined) {
+            throw usageError("Leader has no active Agent. Repair it with yui config role update leader, then run yui setup again.");
         }
-        if (existing.activeAgentId === agent.id
-            && existing.workspace === workspace
-            && isDeepStrictEqual(existing.agentBindings[agent.id], binding)) {
-            return null;
+        if (!usableAgentIds.has(leaderAgentId)) {
+            throw usageError(`Leader Agent ${leaderAgentId} is unavailable. Repair it with yui config agent update `
+                + "or yui config role update leader, then run yui setup again.");
+        }
+        const operator = tx.getGlobalRole(SYSTEM_OPERATOR_ROLE);
+        if (operator !== null && operator.activeAgentId === agent.id) {
+            return {
+                operator: "preserved",
+                leader: leaderStatus,
+                leaderAgentId
+            };
+        }
+        const definition = configuredAgentToDefinition(agent);
+        const binding = createRoleAgentBinding(definition);
+        if (operator === null) {
+            assertRoleRuntimeMutationAllowed(tx, {
+                scope: "global",
+                roleName: SYSTEM_OPERATOR_ROLE
+            }, "creation");
+            tx.saveGlobalRole(createGlobalRole(SYSTEM_OPERATOR_ROLE, [binding], agent.id, workspace, now));
+            return {
+                operator: "created",
+                leader: leaderStatus,
+                leaderAgentId
+            };
         }
-        assertRoleRuntimeMutationAllowed(store, {
+        assertRoleRuntimeMutationAllowed(tx, {
             scope: "global",
-            roleName: name
-        }, "desired launch configuration update");
-        return updateGlobalRole(existing, {
-            activeAgentId: agent.id,
-            workspace,
-            agentBindings: { ...existing.agentBindings, [agent.id]: binding },
-            ...(profile === undefined ? {} : profile)
-        }, now);
-    }
-    assertRoleRuntimeMutationAllowed(store, {
-        scope: "global",
-        roleName: name
-    }, "creation");
-    const definition = configuredAgentToDefinition(agent);
-    return createGlobalRole(name, [createRoleAgentBinding(definition, config)], definition.id, workspace, now, profile);
-}
-function parseAgentSetSelection(answer, candidates) {
-    const value = answer.trim().toLowerCase();
-    if (value.length === 0 || value === "all")
-        return [...candidates];
-    const tokens = value.split(",").map((token) => token.trim()).filter(Boolean);
-    if (tokens.length === 0)
-        throw usageError("Select at least one Agent.");
-    const selected = [];
-    for (const token of tokens) {
-        const numeric = Number(token);
-        const choice = Number.isSafeInteger(numeric) && numeric >= 1 && numeric <= candidates.length
-            ? candidates[numeric - 1]
-            : candidates.find(({ id }) => id.toLowerCase() === token);
-        if (choice === undefined) {
-            throw usageError("Choose available Agents by number or name, separated by commas.");
+            roleName: SYSTEM_OPERATOR_ROLE
+        }, "desired Agent binding update");
+        const duplicateAdapter = Object.values(operator.agentBindings).find((candidate) => candidate.adapterId === agent.adapterId && candidate.agentId !== agent.id);
+        if (duplicateAdapter !== undefined) {
+            throw usageError(`Operator already has a ${agent.adapterId} Agent: ${duplicateAdapter.agentId}. `
+                + "Use yui config agent update or yui config role bind to repair the Operator configuration.");
         }
-        if (!selected.some(({ id }) => id === choice.id))
-            selected.push(choice);
-    }
-    return selected;
-}
-function parseSingleAgentSelection(answer, agents, fallback) {
-    const value = answer.trim().toLowerCase();
-    if (value.length === 0)
-        return fallback;
-    const numeric = Number(value);
-    const selected = Number.isSafeInteger(numeric) && numeric >= 1 && numeric <= agents.length
-        ? agents[numeric - 1]
-        : agents.find(({ id }) => id.toLowerCase() === value);
-    if (selected === undefined) {
-        throw usageError("Choose one of the configured Agents by number or name.");
-    }
-    return selected.id;
+        tx.saveGlobalRole(updateGlobalRole(operator, {
+            activeAgentId: agent.id,
+            agentBindings: { ...operator.agentBindings, [agent.id]: binding }
+        }, now));
+        return {
+            operator: "updated",
+            leader: leaderStatus,
+            leaderAgentId
+        };
+    });
 }
 function resolveWorkspace(value, home) {
     if (!isAbsolute(value))
-        throw usageError("Project workspace must be an absolute path.");
+        throw usageError("Default workspace must be an absolute path.");
     const requested = resolve(value);
     assertWorkspaceOutsideHome(requested, resolve(home));
     mkdirSync(requested, { recursive: true, mode: 0o700 });
@@ -472,7 +206,7 @@ function resolveWorkspace(value, home) {
 function assertWorkspaceOutsideHome(workspace, homeRoot) {
     const fromHome = relative(homeRoot, workspace);
     if (fromHome === "" || (!fromHome.startsWith("..") && !isAbsolute(fromHome))) {
-        throw usageError("Project workspace must be outside YUI_HOME.");
+        throw usageError("Default workspace must be outside YUI_HOME.");
     }
 }
 function commandOnPath(command, env) {
@@ -484,6 +218,15 @@ function commandOnPath(command, env) {
         : [""];
     return entries.some((entry) => extensions.some((extension) => existsSync(join(entry, `${command}${extension}`))));
 }
+function assertTmuxAvailable(executor, tmuxBin) {
+    try {
+        executor.run(tmuxBin, ["-V"], { timeoutMs: 3_000 });
+    }
+    catch {
+        throw usageError(`Tmux is required to run the Operator, but ${tmuxBin} is unavailable. `
+            + "Install tmux or set yui config tools set tmux-bin, then run yui setup again.");
+    }
+}
 function createSetupQuestion(readline, io) {
     if (io.input.isTTY === true)
         return (prompt) => readline.question(prompt);
@@ -502,89 +245,7 @@ function shouldPrompt(io) {
 function setupRequiresInteractiveError() {
     return usageError("Setup requires an interactive terminal.");
 }
-function tableWidth(io) {
-    return io.output?.columns === undefined
-        ? defaultTableWidth()
-        : Math.max(46, Math.min(io.output.columns, 140));
-}
-function cliIdentity(env) {
-    return env.YUI_CLI_NAME === "yui-dev" ? "yui-dev" : "yui";
-}
 function parseSetupOptions(args) {
-    if (args.length === 0)
-        return undefined;
-    if (args.length === 1 && args[0] === "tmux")
-        return "tmux";
-    throw usageError("Setup usage: yui setup [tmux]");
-}
-async function setupTmux(env, executor, question) {
-    const command = "tmux";
-    if (hasExecutable(command, ["-V"], executor))
-        return ["Tmux already installed."];
-    const plan = detectTmuxInstallPlan(env, executor);
-    if (plan === null) {
-        return ["Tmux is not installed.", "Install tmux manually, then run yui doctor."];
-    }
-    const lines = [
-        "Tmux is not installed.",
-        `Install with ${plan.manager}:`,
-        ...plan.steps.map((step) => `  ${step.command} ${step.args.join(" ")}`)
-    ];
-    const answer = (await question("Install tmux now? [y/N]: ")).trim().toLowerCase();
-    if (answer !== "y" && answer !== "yes") {
-        return [...lines, "Skipped tmux installation.", "After installing tmux, run yui doctor."];
-    }
-    for (const step of plan.steps)
-        executor.run(step.command, [...step.args], { inheritStdio: true });
-    return hasExecutable(command, ["-V"], executor)
-        ? [...lines, "Tmux installed."]
-        : [...lines, `Tmux install command completed, but ${command} is still unavailable.`, plan.manualHint];
-}
-function detectTmuxInstallPlan(env, executor) {
-    if (process.platform === "darwin" && commandExists("brew", env, executor)) {
-        return {
-            manager: "Homebrew",
-            steps: [{ command: "brew", args: ["install", "tmux"] }],
-            manualHint: "brew install tmux"
-        };
-    }
-    if (process.platform !== "linux")
-        return null;
-    for (const candidate of [
-        { command: "apt-get", args: ["install", "-y", "tmux"], hint: "sudo apt-get install -y tmux" },
-        { command: "dnf", args: ["install", "-y", "tmux"], hint: "sudo dnf install -y tmux" },
-        { command: "pacman", args: ["-S", "--noconfirm", "tmux"], hint: "sudo pacman -S --noconfirm tmux" },
-        { command: "apk", args: ["add", "tmux"], hint: "sudo apk add tmux" }
-    ]) {
-        if (!commandExists(candidate.command, env, executor))
-            continue;
-        const step = withLinuxPrivilege(candidate.command, candidate.args, env, executor);
-        if (step !== null) {
-            return { manager: candidate.command, steps: [step], manualHint: candidate.hint };
-        }
-    }
-    return null;
-}
-function hasExecutable(command, args, executor) {
-    try {
-        executor.run(command, args);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function commandExists(command, env, executor) {
-    if (command.includes("/"))
-        return existsSync(command);
-    return (env.PATH ?? "").split(delimiter).filter(Boolean)
-        .some((entry) => existsSync(join(entry, command)))
-        || hasExecutable(command, ["--version"], executor);
-}
-function withLinuxPrivilege(command, args, env, executor) {
-    if (process.getuid?.() === 0)
-        return { command, args };
-    if (!commandExists("sudo", env, executor))
-        return null;
-    return { command: "sudo", args: [command, ...args] };
+    if (args.length !== 0)
+        throw usageError("Setup usage: yui setup");
 }