@zq-silk/yui 0.0.0

package/dist/cli/roleOptionCatalog.js

@@ -0,0 +1,67 @@
+const BOTH_ADAPTERS = Object.freeze(["codex", "claude"]);
+const CODEX_ONLY = Object.freeze(["codex"]);
+const CLAUDE_ONLY = Object.freeze(["claude"]);
+export const ROLE_AGENT_OPTION_SPECS = Object.freeze([
+    roleAgentOption("--model", "model", "model", false, BOTH_ADAPTERS),
+    roleAgentOption("--effort", "effort", "effort", false, BOTH_ADAPTERS),
+    roleAgentOption("--sandbox", "permission.sandbox", "mode", false, CODEX_ONLY),
+    roleAgentOption("--approval", "permission.approval", "policy", false, CODEX_ONLY),
+    roleAgentOption("--permission-mode", "permission.mode", "mode", false, CLAUDE_ONLY),
+    roleAgentOption("--allowed-tool", "permission.allowedTools", "tool", true, CLAUDE_ONLY),
+    roleAgentOption("--disallowed-tool", "permission.disallowedTools", "tool", true, CLAUDE_ONLY),
+    roleAgentOption("--search", "search", "true", false, CODEX_ONLY, { staticValues: ["true"] }),
+    roleAgentOption("--profile", "profile", "profile", false, CODEX_ONLY),
+    roleAgentOption("--add-dir", "additionalDirectories", "path", true, BOTH_ADAPTERS, { fileValue: true }),
+    roleAgentOption("--settings", "settingsFile", "file", false, CLAUDE_ONLY, { fileValue: true }),
+    roleAgentOption("--setting-source", "settingsSources", "source", true, CLAUDE_ONLY),
+    roleAgentOption("--raw-arg", "advanced.rawArgs", "arg", true, BOTH_ADAPTERS, { allowOptionLikeValue: true })
+]);
+export const ROLE_AGENT_INHERIT_OPTION = "--inherit";
+export const ROLE_EXPECT_UPDATED_AT_OPTION = "--expect-updated-at";
+export const ROLE_AGENT_INHERITABLE_FIELDS = Object.freeze(ROLE_AGENT_OPTION_SPECS.map(({ fieldKey }) => fieldKey));
+export const ROLE_PROFILE_INHERITABLE_FIELDS = Object.freeze(["systemPrompt"]);
+export const ROLE_INHERITABLE_FIELDS = Object.freeze([
+    ...ROLE_AGENT_INHERITABLE_FIELDS,
+    ...ROLE_PROFILE_INHERITABLE_FIELDS
+]);
+export const ROLE_AGENT_SCRIPTED_OPTIONS = Object.freeze([
+    ...ROLE_AGENT_OPTION_SPECS.map(({ option }) => option),
+    ROLE_AGENT_INHERIT_OPTION
+]);
+export const ROLE_AGENT_FILE_OPTIONS = Object.freeze(ROLE_AGENT_OPTION_SPECS.filter(({ fileValue }) => fileValue === true).map(({ option }) => option));
+export function roleAgentOptionSpecsForAdapter(adapterId) {
+    return ROLE_AGENT_OPTION_SPECS.filter(({ adapters }) => adapters.includes(adapterId));
+}
+export function roleAgentOptionUsage() {
+    return [
+        ...ROLE_AGENT_OPTION_SPECS.map(({ option, valueLabel, repeatable }) => `[${option} <${valueLabel}>${repeatable ? " ..." : ""}]`),
+        `[${ROLE_AGENT_INHERIT_OPTION} <field-key> ...]`
+    ].join(" ");
+}
+function roleAgentOption(option, fieldKey, valueLabel, repeatable, adapters, extra = {}) {
+    return Object.freeze({ option, fieldKey, valueLabel, arity: "value", repeatable, adapters, ...extra });
+}
+export const FIRST_CLASS_AGENT_OPTIONS = Object.freeze([
+    Object.freeze({ id: "codex", label: "Codex" }),
+    Object.freeze({ id: "claude", label: "Claude" })
+]);
+export function orderRoleOptions(roles) {
+    return [...roles].sort((left, right) => {
+        const rank = roleRank(left) - roleRank(right);
+        if (rank !== 0)
+            return rank;
+        return roleName(left).localeCompare(roleName(right));
+    });
+}
+function roleRank(role) {
+    const kind = role.kind?.toLowerCase();
+    const name = roleName(role).toLowerCase();
+    if (kind === "operator" || name === "operator")
+        return 0;
+    if (kind === "leader" || name === "leader")
+        return 1;
+    return 2;
+}
+function roleName(role) {
+    return role.name ?? role.id ?? "";
+}

package/dist/cli/roleWizard.js

@@ -0,0 +1,546 @@
+import { renderTable } from "../output/table.js";
+const TEXT_COLUMN = { header: "Selection", minWidth: 12, maxWidth: 34 };
+export async function resolveRoleWizardArguments(commandArgs, ports, io) {
+    const args = [...commandArgs];
+    if (!io.interactive || io.json)
+        return { kind: "unchanged", args };
+    if (isGlobalRoleAdd(args)) {
+        return addGlobalRole(args, ports, io);
+    }
+    if (isTaskRoleAdd(args)) {
+        return addTaskRole(args, ports, io);
+    }
+    if (isGlobalRoleUpdate(args)) {
+        return updateGlobalRole(args, ports, io);
+    }
+    if (isTaskRoleUpdate(args)) {
+        return updateTaskRole(args, ports, io);
+    }
+    return { kind: "unchanged", args };
+}
+function isGlobalRoleAdd(args) {
+    return args[0] === "role" && args[1] === "add";
+}
+function isTaskRoleAdd(args) {
+    return args[0] === "task" && args[1] === "role" && args[2] === "add";
+}
+// Explicit update options always win. This keeps scripts and deliberate
+// non-interactive invocations out of the wizard even when run from a TTY.
+function isGlobalRoleUpdate(args) {
+    return args.length === 3 && args[0] === "role" && args[1] === "update"
+        && isValue(args[2]);
+}
+function isTaskRoleUpdate(args) {
+    return args.length === 5 && args[0] === "task" && args[1] === "role"
+        && args[2] === "update" && isValue(args[3]) && isValue(args[4]);
+}
+async function addGlobalRole(args, ports, io) {
+    const named = await ensureRoleName(args, 2, io);
+    if (named === undefined)
+        return { kind: "cancelled", args };
+    const explicitSettings = hasExplicitAddSettings(named, 3);
+    const agents = await loadAgentSelection(ports);
+    const explicitAgent = optionValue(named, "--agent");
+    const selected = explicitAgent ?? await selectConfiguredAgent(ports, io, "Create Global Role from Agent", agents);
+    if (selected === undefined)
+        return { kind: "cancelled", args: named };
+    const withAgent = explicitAgent === undefined
+        ? [...named, "--agent", selected]
+        : named;
+    if (explicitSettings)
+        return { kind: "resolved", args: withAgent };
+    const agent = agents.agents.find((candidate) => candidate.id === selected);
+    return agent === undefined
+        ? { kind: "resolved", args: withAgent }
+        : configureRoleCreation(withAgent, agent, ports, io, false);
+}
+async function addTaskRole(args, ports, io) {
+    const withTask = await ensureTask(args, ports, io);
+    if (withTask === undefined)
+        return { kind: "cancelled", args };
+    const named = await ensureRoleName(withTask, 4, io);
+    if (named === undefined)
+        return { kind: "cancelled", args: withTask };
+    if (hasExplicitAddSettings(named, 5))
+        return { kind: "resolved", args: named };
+    const roleName = named[4] ?? "";
+    const [globalRoleValue, agents] = await Promise.all([
+        Promise.resolve(ports.call("role.show", { name: roleName })),
+        loadAgentSelection(ports)
+    ]);
+    const globalRole = asRole(globalRoleValue);
+    const explicitAgent = optionValue(named, "--agent");
+    if (globalRole !== undefined && explicitAgent === undefined) {
+        const source = await choose("Create Task Role from", [
+            {
+                value: "copy",
+                cells: ["Copy existing Global Role", `Active Agent: ${globalRole.activeAgentId}`]
+            },
+            {
+                value: "agent",
+                cells: ["Create from Agent", `Default Agent: ${agents.defaultAgent ?? "none"}`]
+            }
+        ], [TEXT_COLUMN, { header: "Details", minWidth: 18, maxWidth: 42 }], io, "copy", "source");
+        if (source === undefined)
+            return { kind: "cancelled", args: named };
+        if (source === "copy")
+            return { kind: "resolved", args: named };
+    }
+    const selected = explicitAgent ?? await selectConfiguredAgent(ports, io, "Create Task Role from Agent", agents);
+    if (selected === undefined)
+        return { kind: "cancelled", args: named };
+    const withAgent = explicitAgent === undefined
+        ? [...named, "--agent", selected]
+        : named;
+    const agent = agents.agents.find((candidate) => candidate.id === selected);
+    return agent === undefined
+        ? { kind: "resolved", args: withAgent }
+        : configureRoleCreation(withAgent, agent, ports, io, true);
+}
+async function ensureTask(args, ports, io) {
+    if (isValue(args[3]))
+        return args;
+    const value = await ports.call("task.list", {});
+    const tasks = Array.isArray(value) ? value.flatMap((candidate) => {
+        const input = entity(candidate);
+        const id = stringField(input, "id");
+        if (id === undefined)
+            return [];
+        return [{
+                value: id,
+                cells: [id, stringField(input, "title") ?? "", stringField(input, "status") ?? ""]
+            }];
+    }) : [];
+    const selected = await choose("Select Task", tasks, [
+        { header: "Task", minWidth: 5, maxWidth: 24 },
+        { header: "Title", minWidth: 8, maxWidth: 42 },
+        { header: "Status", minWidth: 6, maxWidth: 12 }
+    ], io, tasks[0]?.value, "Task");
+    if (selected === undefined)
+        return undefined;
+    const resolved = [...args];
+    resolved.splice(3, 0, selected);
+    return resolved;
+}
+async function ensureRoleName(args, index, io) {
+    if (isValue(args[index]))
+        return args;
+    const name = (await io.question("Role name: "))?.trim();
+    if (name === undefined || name.length === 0)
+        return undefined;
+    const resolved = [...args];
+    resolved.splice(index, 0, name);
+    return resolved;
+}
+async function configureRoleCreation(args, agent, ports, io, taskRole) {
+    const mode = await choose("Create Role", [
+        { value: "defaults", cells: ["Create with CLI defaults", "No Agent overrides"] },
+        { value: "configure", cells: ["Configure Role", "Set one Role or Agent field"] }
+    ], [TEXT_COLUMN, { header: "Result", minWidth: 18, maxWidth: 40 }], io, "defaults", "creation mode");
+    if (mode === undefined)
+        return { kind: "cancelled", args };
+    if (mode === "defaults")
+        return { kind: "resolved", args };
+    const section = await settingsSection("Configure Role", io, taskRole);
+    if (section === undefined)
+        return { kind: "cancelled", args };
+    return section === "role"
+        ? configureNewRoleField(args, agent, ports, io, taskRole)
+        : configureNewAgentField(args, agent, io);
+}
+async function configureNewRoleField(args, agent, ports, io, taskRole) {
+    const field = await choose("Role settings", [
+        { value: "description", cells: ["Description"] },
+        { value: "responsibilities", cells: ["Responsibilities"] },
+        { value: "constraints", cells: ["Constraints"] },
+        { value: "expected-output", cells: ["Expected output"] },
+        { value: "system-prompt", cells: ["System prompt"] },
+        { value: "active-agent", cells: ["Active Agent"] },
+        ...(taskRole ? [] : [{ value: "workspace", cells: ["Workspace"] }])
+    ], [TEXT_COLUMN], io, undefined, "field");
+    if (field === undefined)
+        return { kind: "cancelled", args };
+    if (field === "active-agent") {
+        const selected = await selectConfiguredAgent(ports, io, "Select Active Agent");
+        return selected === undefined
+            ? { kind: "cancelled", args }
+            : { kind: "resolved", args: replaceOptionValue(args, "--agent", selected) };
+    }
+    if (field === "workspace") {
+        const workspace = (await io.question("Workspace: "))?.trim();
+        return workspace === undefined || workspace.length === 0
+            ? { kind: "cancelled", args }
+            : { kind: "resolved", args: [...args, "--workspace", workspace] };
+    }
+    void agent;
+    return setProfileField(args, field, io);
+}
+async function configureNewAgentField(args, agent, io) {
+    const fields = agentFields({
+        agentId: agent.id,
+        adapterId: agent.adapterId,
+        config: { adapterId: agent.adapterId }
+    });
+    const field = await choose(`Agent settings: ${agent.id}`, fields.map((candidate) => ({ value: candidate.value, cells: [candidate.label, "CLI default"] })), [TEXT_COLUMN, { header: "Current", minWidth: 12, maxWidth: 24 }], io, undefined, "field");
+    const selected = fields.find((candidate) => candidate.value === field);
+    if (selected === undefined)
+        return { kind: "cancelled", args };
+    const value = await promptAgentFieldValue(selected, io);
+    return value === undefined
+        ? { kind: "cancelled", args }
+        : { kind: "resolved", args: [...args, selected.set, value] };
+}
+async function updateGlobalRole(args, ports, io) {
+    const role = asRole(await ports.call("role.show", { name: args[2] }));
+    if (role === undefined)
+        return { kind: "unchanged", args };
+    return updateRole(args, role, ports, io, false);
+}
+async function updateTaskRole(args, ports, io) {
+    const role = asRole(await ports.call("task.role.show", {
+        taskId: args[3],
+        roleName: args[4]
+    }));
+    if (role === undefined)
+        return { kind: "unchanged", args };
+    return updateRole(args, role, ports, io, true);
+}
+async function updateRole(args, role, ports, io, taskRole) {
+    const section = await settingsSection(`Update Role: ${role.name}`, io, taskRole);
+    if (section === undefined)
+        return { kind: "cancelled", args };
+    return section === "role"
+        ? updateRoleSettings(args, role, ports, io, taskRole)
+        : updateAgentSettings(args, role, io);
+}
+async function settingsSection(title, io, taskRole) {
+    return choose(title, [
+        {
+            value: "role",
+            cells: ["Role settings", taskRole ? "Profile, Active Agent" : "Profile, Active Agent, workspace"]
+        },
+        { value: "agent", cells: ["Agent settings", "Model, effort, permissions"] }
+    ], [TEXT_COLUMN, { header: "Includes", minWidth: 18, maxWidth: 46 }], io, "role", "settings");
+}
+async function updateRoleSettings(args, role, ports, io, taskRole) {
+    const fields = [
+        profileChoice("description", "Description", role.description),
+        profileChoice("responsibilities", "Responsibilities", role.responsibilities),
+        profileChoice("constraints", "Constraints", role.constraints),
+        profileChoice("expected-output", "Expected output", role.expectedOutput),
+        profileChoice("system-prompt", "System prompt", role.systemPrompt),
+        { value: "active-agent", cells: ["Active Agent", role.activeAgentId] },
+        ...(taskRole ? [] : [{ value: "workspace", cells: ["Workspace", roleDisplay(role.workspace)] }])
+    ];
+    const field = await choose("Role settings", fields, [TEXT_COLUMN, { header: "Current", minWidth: 12, maxWidth: 52 }], io, undefined, "field");
+    if (field === undefined)
+        return { kind: "cancelled", args };
+    if (field === "active-agent") {
+        const target = await selectActiveAgent(role, ports, io);
+        if (target === undefined)
+            return { kind: "cancelled", args };
+        return taskRole
+            ? { kind: "resolved", args: ["task", "role", "bind", args[3] ?? "", args[4] ?? "", target] }
+            : { kind: "resolved", args: ["role", "bind", args[2] ?? "", target] };
+    }
+    if (field === "workspace") {
+        const value = (await io.question(`Workspace [${roleDisplay(role.workspace)}]: `))?.trim();
+        return value === undefined || value.length === 0
+            ? { kind: "cancelled", args }
+            : { kind: "resolved", args: [...args, "--workspace", value] };
+    }
+    return updateProfileField(args, field, io);
+}
+async function updateProfileField(args, field, io) {
+    const action = await choose(`Update ${profileLabel(field)}`, [
+        { value: "keep", cells: ["Keep current"] },
+        { value: "clear", cells: ["Clear"] },
+        { value: "set", cells: ["Set value"] }
+    ], [TEXT_COLUMN], io, "keep", "action");
+    if (action === undefined || action === "keep")
+        return { kind: "cancelled", args };
+    const options = profileOptions(field);
+    if (action === "clear") {
+        return { kind: "resolved", args: [...args, options.clear] };
+    }
+    return setProfileField(args, field, io);
+}
+async function setProfileField(args, field, io) {
+    const options = profileOptions(field);
+    const hint = options.repeatable ? " (comma-separated)" : "";
+    const value = (await io.question(`${profileLabel(field)}${hint}: `))?.trim();
+    if (value === undefined || value.length === 0)
+        return { kind: "cancelled", args };
+    const values = options.repeatable
+        ? value.split(",").map((part) => part.trim()).filter(Boolean)
+        : [value];
+    if (values.length === 0)
+        return { kind: "cancelled", args };
+    return {
+        kind: "resolved",
+        args: [...args, ...values.flatMap((entry) => [options.set, entry])]
+    };
+}
+async function updateAgentSettings(args, role, io) {
+    const bindings = Object.values(role.agentBindings);
+    const selectedId = await choose("Select Role Agent binding", bindings.map((binding) => ({
+        value: binding.agentId,
+        cells: [binding.agentId, binding.adapterId, binding.agentId === role.activeAgentId ? "active" : "bound"]
+    })), [
+        { header: "Agent", minWidth: 5, maxWidth: 24 },
+        { header: "Adapter", minWidth: 7, maxWidth: 12 },
+        { header: "State", minWidth: 6, maxWidth: 8 }
+    ], io, role.activeAgentId, "binding");
+    if (selectedId === undefined)
+        return { kind: "cancelled", args };
+    const binding = role.agentBindings[selectedId];
+    if (binding === undefined)
+        return { kind: "cancelled", args };
+    const fields = agentFields(binding);
+    const field = await choose(`Agent settings: ${binding.agentId}`, [
+        ...fields.map((candidate) => ({
+            value: candidate.value,
+            cells: [candidate.label, candidate.current]
+        })),
+        { value: "clear-all", cells: ["Clear all overrides", "Use CLI defaults"] }
+    ], [TEXT_COLUMN, { header: "Current", minWidth: 12, maxWidth: 36 }], io, undefined, "field");
+    if (field === undefined)
+        return { kind: "cancelled", args };
+    if (field === "clear-all") {
+        return {
+            kind: "resolved",
+            args: [...args, "--agent", binding.agentId, "--clear-agent-config"]
+        };
+    }
+    const selectedField = fields.find((candidate) => candidate.value === field);
+    if (selectedField === undefined)
+        return { kind: "cancelled", args };
+    const action = await choose(`Update ${selectedField.label}`, [
+        { value: "keep", cells: ["Keep current", selectedField.current] },
+        { value: "clear", cells: ["Use CLI default", "Remove override"] },
+        { value: "set", cells: ["Set value", "Override CLI default"] }
+    ], [TEXT_COLUMN, { header: "Result", minWidth: 14, maxWidth: 36 }], io, "keep", "action");
+    if (action === undefined || action === "keep")
+        return { kind: "cancelled", args };
+    if (action === "clear") {
+        return {
+            kind: "resolved",
+            args: [...args, "--agent", binding.agentId, selectedField.clear]
+        };
+    }
+    const value = await promptAgentFieldValue(selectedField, io);
+    if (value === undefined || value.length === 0)
+        return { kind: "cancelled", args };
+    return {
+        kind: "resolved",
+        args: [...args, "--agent", binding.agentId, selectedField.set, value]
+    };
+}
+function agentFields(binding) {
+    const config = binding.config;
+    const permission = entity(config.permission) ?? {};
+    return [
+        agentField("model", "Model", config.model, "--model", "--clear-model"),
+        agentField("effort", "Effort", config.effort, "--effort", "--clear-effort"),
+        ...(binding.adapterId === "codex" ? [
+            agentField("sandbox", "Sandbox", permission.sandbox, "--sandbox", "--clear-sandbox", [
+                "read-only", "workspace-write", "danger-full-access"
+            ]),
+            agentField("approval", "Approval", permission.approval, "--approval", "--clear-approval", [
+                "untrusted", "on-request", "never"
+            ]),
+            agentField("search", "Web search", config.search, "--search", "--clear-search", [
+                "true"
+            ])
+        ] : []),
+        ...(binding.adapterId === "claude" ? [
+            agentField("permission-mode", "Permission mode", permission.mode, "--permission-mode", "--clear-permission-mode")
+        ] : [])
+    ];
+}
+function agentField(value, label, current, set, clear, choices) {
+    return { value, label, current: display(current), set, clear, ...(choices === undefined ? {} : { choices }) };
+}
+async function promptAgentFieldValue(field, io) {
+    return field.choices === undefined
+        ? (await io.question(`${field.label}: `))?.trim()
+        : choose(`Set ${field.label}`, field.choices.map((choice) => ({ value: choice, cells: [choice] })), [TEXT_COLUMN], io, field.choices[0], "value");
+}
+async function selectActiveAgent(role, ports, io) {
+    const configured = await configuredAgents(ports);
+    const byId = new Map(configured.map((agent) => [agent.id, agent]));
+    for (const binding of Object.values(role.agentBindings)) {
+        if (!byId.has(binding.agentId)) {
+            byId.set(binding.agentId, { id: binding.agentId, adapterId: binding.adapterId });
+        }
+    }
+    return choose("Select Active Agent", [...byId.values()].map((agent) => ({
+        value: agent.id,
+        cells: [
+            agent.id,
+            agent.adapterId,
+            agent.id === role.activeAgentId ? "active" : role.agentBindings[agent.id] === undefined ? "new" : "bound"
+        ]
+    })), [
+        { header: "Agent", minWidth: 5, maxWidth: 24 },
+        { header: "Adapter", minWidth: 7, maxWidth: 12 },
+        { header: "State", minWidth: 5, maxWidth: 8 }
+    ], io, role.activeAgentId, "Agent");
+}
+async function selectConfiguredAgent(ports, io, title, loaded) {
+    const selection = loaded ?? await loadAgentSelection(ports);
+    return choose(title, selection.agents.map((agent) => ({
+        value: agent.id,
+        cells: [agent.id, agent.adapterId, agent.id === selection.defaultAgent ? "yes" : ""]
+    })), [
+        { header: "Agent", minWidth: 5, maxWidth: 24 },
+        { header: "Adapter", minWidth: 7, maxWidth: 12 },
+        { header: "Default", minWidth: 7, maxWidth: 7 }
+    ], io, selection.defaultAgent, "Agent");
+}
+async function loadAgentSelection(ports) {
+    const [agents, config] = await Promise.all([
+        configuredAgents(ports),
+        ports.call("config.get", {})
+    ]);
+    const configuredDefault = stringField(entity(config), "defaultAgent");
+    const defaultAgent = agents.some((agent) => agent.id === configuredDefault)
+        ? configuredDefault
+        : agents[0]?.id;
+    return {
+        agents,
+        ...(defaultAgent === undefined ? {} : { defaultAgent })
+    };
+}
+async function configuredAgents(ports) {
+    const value = await ports.call("agent.list", {});
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((candidate) => {
+        const input = entity(candidate);
+        const id = stringField(input, "id");
+        const adapterId = stringField(input, "adapterId");
+        return id === undefined || adapterId === undefined ? [] : [{ id, adapterId }];
+    });
+}
+async function choose(title, choices, columns, io, defaultValue, label) {
+    if (choices.length === 0) {
+        io.write(`○ No ${label}s are available.\n`);
+        return undefined;
+    }
+    io.write(`${renderTable(title, [{ header: "#", minWidth: 1, maxWidth: 4 }, ...columns], choices.map((choice, index) => [String(index + 1), ...choice.cells]), io.width)}\n\n`);
+    const answer = (await io.question(`Choose ${label} [1-${choices.length}/value, q]: `))?.trim();
+    if (answer === undefined || answer.toLowerCase() === "q" || answer.toLowerCase() === "quit") {
+        return undefined;
+    }
+    if (answer.length === 0) {
+        return choices.find((choice) => choice.value === defaultValue)?.value
+            ?? choices[0]?.value;
+    }
+    const numeric = Number(answer);
+    if (Number.isSafeInteger(numeric) && numeric >= 1 && numeric <= choices.length) {
+        return choices[numeric - 1]?.value;
+    }
+    return choices.find((choice) => choice.value === answer)?.value;
+}
+function asRole(value) {
+    const input = entity(value);
+    const name = stringField(input, "name");
+    const activeAgentId = stringField(input, "activeAgentId");
+    const rawBindings = entity(input?.agentBindings);
+    if (input === undefined || name === undefined || activeAgentId === undefined || rawBindings === undefined) {
+        return undefined;
+    }
+    const agentBindings = Object.fromEntries(Object.entries(rawBindings).flatMap(([id, raw]) => {
+        const binding = entity(raw);
+        const agentId = stringField(binding, "agentId");
+        const adapterId = stringField(binding, "adapterId");
+        const config = entity(binding?.config);
+        return agentId === undefined || adapterId === undefined || config === undefined
+            ? []
+            : [[id, { agentId, adapterId, config }]];
+    }));
+    return {
+        name,
+        activeAgentId,
+        agentBindings,
+        ...(stringField(input, "workspace") === undefined ? {} : { workspace: stringField(input, "workspace") }),
+        ...(stringField(input, "description") === undefined ? {} : { description: stringField(input, "description") }),
+        ...(stringArray(input.responsibilities) === undefined ? {} : { responsibilities: stringArray(input.responsibilities) }),
+        ...(stringArray(input.constraints) === undefined ? {} : { constraints: stringArray(input.constraints) }),
+        ...(stringField(input, "expectedOutput") === undefined ? {} : { expectedOutput: stringField(input, "expectedOutput") }),
+        ...(stringField(input, "systemPrompt") === undefined ? {} : { systemPrompt: stringField(input, "systemPrompt") })
+    };
+}
+function profileChoice(value, label, current) {
+    return { value, cells: [label, roleDisplay(current)] };
+}
+function profileLabel(field) {
+    return {
+        description: "Description",
+        responsibilities: "Responsibilities",
+        constraints: "Constraints",
+        "expected-output": "Expected output",
+        "system-prompt": "System prompt"
+    }[field] ?? field;
+}
+function profileOptions(field) {
+    switch (field) {
+        case "description": return { set: "--description", clear: "--clear-description", repeatable: false };
+        case "responsibilities": return { set: "--responsibility", clear: "--clear-responsibilities", repeatable: true };
+        case "constraints": return { set: "--constraint", clear: "--clear-constraints", repeatable: true };
+        case "expected-output": return { set: "--expected-output", clear: "--clear-expected-output", repeatable: false };
+        case "system-prompt": return { set: "--system-prompt", clear: "--clear-system-prompt", repeatable: false };
+        default: throw new Error(`Unsupported Role profile field: ${field}.`);
+    }
+}
+function entity(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringField(value, field) {
+    const candidate = value?.[field];
+    return typeof candidate === "string" && candidate.length > 0 ? candidate : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string")
+        ? [...value]
+        : undefined;
+}
+function display(value) {
+    if (Array.isArray(value))
+        return value.length === 0 ? "—" : value.join(", ");
+    if (typeof value === "string")
+        return value.length === 0 ? "—" : value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return "CLI default";
+}
+function roleDisplay(value) {
+    if (Array.isArray(value))
+        return value.length === 0 ? "—" : value.join(", ");
+    if (typeof value === "string")
+        return value.length === 0 ? "—" : value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return "—";
+}
+function isValue(value) {
+    return value !== undefined && value.length > 0 && !value.startsWith("--");
+}
+function hasExplicitAddSettings(args, optionStart) {
+    return args.slice(optionStart).some((value) => value.startsWith("--") && value !== "--agent");
+}
+function optionValue(args, option) {
+    const index = args.indexOf(option);
+    return index < 0 || !isValue(args[index + 1]) ? undefined : args[index + 1];
+}
+function replaceOptionValue(args, option, value) {
+    const replaced = [...args];
+    const index = replaced.indexOf(option);
+    if (index < 0)
+        return [...replaced, option, value];
+    replaced[index + 1] = value;
+    return replaced;
+}

package/dist/cli/selectionPorts.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/updateCommand.js

@@ -0,0 +1,22 @@
+import { spawnSync } from "node:child_process";
+import { runtimeError } from "../errors/cliError.js";
+/**
+ * Update the published global package. This intentionally remains an exact,
+ * shell-free npm invocation. In particular, yui-dev updates the published
+ * Yui installation; it never rewrites the current checkout.
+ */
+export function runUpdateCommand(spawn = spawnSync) {
+    const result = spawn("npm", ["install", "--global", "@zq-silk/yui@latest"], {
+        cwd: process.cwd(),
+        env: process.env,
+        shell: false,
+        stdio: "inherit"
+    });
+    if (result.error !== undefined) {
+        throw runtimeError(`Failed to start npm: ${result.error.message}`);
+    }
+    if (result.status === null) {
+        throw runtimeError(`npm update terminated${result.signal === null ? "" : ` by ${result.signal}`}.`);
+    }
+    return result.status;
+}