evolcore 0.0.1 → 0.0.3

package/dist/cli/model.js

@@ -0,0 +1,591 @@
+/**
+ * `ec model` —— 面向 agent 的模型管理命令集。
+ *
+ * 可写作用域由参数决定：
+ *   --self           → agent  config.json
+ *   --self --peer    → 关系   relations/<peerKey>/config.json
+ * 角色模型策略由角色策略编辑器管理；--role 仅用于过滤和预览有效模型。
+ *
+ * 改某作用域后，对应范围所有会话的下一条消息即时生效（运行时按 关系>角色>agent>defaults 解析）。
+ * 与对话内 slash（/model /effort /baseagent）互不影响。
+ * 设计见 docs/model-command-design.md。
+ */
+import { isHelpFlag, wantsHelp, getArgValue } from './help.js';
+import { ModelScopeError, normalizePeer, determineScope, activeBaseagent, writeScope, clearScope, } from '../core/model/config-scope.js';
+import { resolveEffectiveFieldWithSource } from '../config/config-manager.js';
+import { getCatalog, getModelInfo } from '../core/model/model-catalog.js';
+import { constrainResolvedModelForRole, filterModelsForRole, validateModelSelectionForRole, } from '../core/model/model-permission.js';
+import { resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc.js';
+import { parsePeerKey } from '../core/relation/peer-identity.js';
+import { resolvePeerRoleDetail } from '../config/peer-role-resolver.js';
+import { getFieldPermission } from '../config/roles.js';
+import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { formatModelCheck, runModelCheck } from '../core/model/model-diagnostics.js';
+import { validateRuntimeStringFieldOverride } from '../core/role/runtime-policy.js';
+const ALL_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'auto'];
+const SCOPE_LABEL = {
+    global: '全局', agent: 'agent级', role: '角色级', relation: '关系级',
+};
+/** 输出 JSON 并退出（success=false 时 exit 1）。 */
+function emit(formatJson, payload, textFn) {
+    if (formatJson) {
+        console.log(JSON.stringify(payload, null, 2));
+    }
+    else {
+        console.log(textFn());
+    }
+}
+function fail(formatJson, code, message, data) {
+    if (formatJson) {
+        console.log(JSON.stringify({ ok: false, code, error: message, ...(data !== undefined ? { data } : {}) }, null, 2));
+    }
+    else {
+        console.error(`❌ ${message} (${code})`);
+    }
+    process.exit(1);
+}
+function isManagedSessionEnv(args) {
+    return !!process.env.EVOLCORE_SESSION_ID
+        && !getArgValue(args, '--self')
+        && !getArgValue(args, '--peer')
+        && !getArgValue(args, '--role');
+}
+function isManagedTargetedWriteEnv(args) {
+    return !!process.env.EVOLCORE_SESSION_ID
+        && !isManagedSessionEnv(args);
+}
+async function runCtlCommand(cmd, formatJson, timeoutMs = 10_000) {
+    const sessionId = process.env.EVOLCORE_SESSION_ID;
+    if (!sessionId)
+        fail(formatJson, 'NO_SESSION', 'EVOLCORE_SESSION_ID 未设置');
+    const result = await ipcQuery(resolvePaths().socket, {
+        type: 'ctl',
+        cmd,
+        sessionId,
+        delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+    }, timeoutMs);
+    if (!result)
+        fail(formatJson, 'DAEMON_UNAVAILABLE', '无法连接 evolcore 服务');
+    if (!result.ok)
+        fail(formatJson, 'CTL_FAILED', result.error || 'ctl 执行失败');
+    return { text: String(result.result || ''), data: result.data };
+}
+function printCtlResult(result, formatJson) {
+    if (formatJson) {
+        console.log(JSON.stringify(result.data ?? { ok: true, result: result.text }, null, 2));
+        return;
+    }
+    console.log(result.text);
+}
+async function runManagedConfigOperation(args, formatJson) {
+    const sessionId = process.env.EVOLCORE_SESSION_ID;
+    if (!sessionId)
+        fail(formatJson, 'NO_SESSION', 'EVOLCORE_SESSION_ID 未设置');
+    const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+    if (!delegationToken) {
+        fail(formatJson, 'DELEGATION_REQUIRED', `${AGENT_DELEGATION_TOKEN_ENV} 未设置`);
+    }
+    let response;
+    try {
+        response = await ipcQuery(resolvePaths().socket, {
+            type: 'config.op',
+            argv: ['config', ...args],
+            sessionId,
+            delegationToken,
+        }, 10_000);
+    }
+    catch {
+        response = null;
+    }
+    if (!response)
+        fail(formatJson, 'DAEMON_UNAVAILABLE', '无法连接 evolcore 服务');
+    if (!response.ok || !response.result?.ok) {
+        fail(formatJson, response.code || 'CONFIG_AUTH_FAILED', response.error || 'config 操作失败', response.data);
+    }
+}
+function configSelectorArgs(sel) {
+    const args = ['--self', sel.self];
+    if (sel.peerKey)
+        args.push('--peer', sel.peerKey);
+    return args;
+}
+async function setManagedModelField(sel, field, value, formatJson) {
+    const subcommand = value === null ? ['unset', field] : ['set', field, value];
+    await runManagedConfigOperation([...subcommand, ...configSelectorArgs(sel)], formatJson);
+}
+function preflightManagedFieldOverride(sel, role, field, value, formatJson) {
+    if (!role)
+        return;
+    const policy = getFieldPermission(role, field, sel.self);
+    if (policy?.allowOverride === false) {
+        fail(formatJson, 'ROLE_OVERRIDE_DISABLED', `Role ${role} cannot override ${field}`);
+    }
+    if (value === null)
+        return;
+    const decision = validateRuntimeStringFieldOverride({ selfAid: sel.self, role, field, value });
+    if (!decision.ok) {
+        fail(formatJson, decision.code || 'ROLE_VALUE_NOT_ALLOWED', decision.message || `Value ${value} is not allowed for ${field}`);
+    }
+}
+/**
+ * 解析 --self / --peer 为作用域选择器。
+ */
+function parseSelector(args, formatJson) {
+    const self = getArgValue(args, '--self');
+    const peerRaw = getArgValue(args, '--peer');
+    const role = getArgValue(args, '--role');
+    let peerKey;
+    if (peerRaw !== undefined) {
+        try {
+            peerKey = normalizePeer(peerRaw);
+        }
+        catch (e) {
+            if (e instanceof ModelScopeError)
+                fail(formatJson, e.code, e.message);
+            throw e;
+        }
+    }
+    const sel = { self, peerKey, role };
+    // 触发依赖校验（PEER_WITHOUT_SELF）
+    try {
+        determineScope(sel);
+    }
+    catch (e) {
+        if (e instanceof ModelScopeError)
+            fail(formatJson, e.code, e.message);
+        throw e;
+    }
+    return sel;
+}
+function explicitOrDerivedRole(args, sel) {
+    if (sel.role)
+        return sel.role;
+    if (!sel.self || !sel.peerKey)
+        return undefined;
+    try {
+        const peer = parsePeerKey(sel.peerKey);
+        const detail = resolvePeerRoleDetail({
+            selfAid: sel.self,
+            channelKey: sel.peerKey,
+            channelType: peer.channelType,
+            chatType: 'private',
+            actorId: peer.channelId,
+            conversationId: peer.channelId,
+        });
+        return detail.effectiveRole ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function determineWriteScope(sel, formatJson) {
+    const scope = determineScope(sel);
+    if (scope === 'global') {
+        fail(formatJson, 'NO_GLOBAL_SCOPE', '全局 model 作用域已退役；请用 --self 选择 agent');
+    }
+    if (scope === 'role') {
+        fail(formatJson, 'ROLE_POLICY_MANAGED', '角色策略只能通过角色策略编辑器修改');
+    }
+    return scope;
+}
+function selectorWithRole(sel, role) {
+    return role ? { ...sel, role } : sel;
+}
+function modelScopeFromSource(source) {
+    const layer = typeof source === 'string'
+        ? source
+        : source && typeof source === 'object' && 'target' in source
+            ? String(source.target ?? '')
+            : undefined;
+    if (layer === 'defaults' || layer === 'global')
+        return 'global';
+    if (layer === 'relation' || layer === 'role' || layer === 'agent')
+        return layer;
+    return undefined;
+}
+function resolveModelConfig(sel, baseagent) {
+    const effortKey = baseagent === 'codex' ? 'reasoning' : 'effort';
+    const model = resolveEffectiveFieldWithSource(`baseagents.${baseagent}.model`, sel, { cache: true });
+    const effort = resolveEffectiveFieldWithSource(`baseagents.${baseagent}.${effortKey}`, sel, { cache: true });
+    const modelDecision = sel.role
+        ? constrainResolvedModelForRole({
+            role: sel.role,
+            baseagent,
+            model: model.value,
+            selfAid: sel.self,
+        })
+        : { model: model.value, constrained: false };
+    const effectiveModel = modelDecision.model;
+    const modelSource = modelDecision.constrained ? 'role' : modelScopeFromSource(model.source);
+    const source = effectiveModel !== undefined ? modelSource : modelScopeFromSource(effort.source);
+    const scopes = ['relation', 'role', 'agent', 'global'];
+    return {
+        model: effectiveModel,
+        effort: effort.value,
+        source,
+        chain: scopes.map(scope => ({
+            scope,
+            hit: scope === source,
+            ...(scope === source && effectiveModel ? { model: effectiveModel } : {}),
+        })),
+    };
+}
+const HELP = `用法: ec model <command> [options]
+
+Commands:
+  list                列出可用模型，标注各作用域命中
+  current             显示按优先级解析后实际生效的模型 + 来源
+  info <model-id>     查看单个模型详情（厂商/上下文/价格/模态/effort/状态）
+  use <model-id>      设置模型（作用域由 --self/--peer 决定）
+  reset               清除指定作用域的设置，回落上一级
+  effort <level>      设置推理强度（low|medium|high|xhigh|max|auto）
+  check               诊断网关连通性与模型可用性（分阶段输出进度）
+
+作用域（越具体越优先：关系 > 角色 > agent > defaults）:
+  (无参数)                       本机 CLI 只读 catalog/defaults，不允许写入
+  --self <aid>                   agent级   → config.json
+  --self <aid> --role <role>     角色策略预览（只读）
+  --self <aid> --peer <X>        关系级    → relations/<peerKey>/config.json
+
+修改 agent/关系作用域后，对应范围所有会话的下一条消息即时生效。
+角色策略请通过角色策略编辑器修改。
+托管会话内省略 --self/--peer/--role 时，命令作用于当前会话。
+
+Options:
+  --self <aid>        本端 AID
+  --peer <X>          对端：channelType#channelId 或裸 aid（裸 aid 视为 aun#<aid>）
+  --role <role>       按角色过滤列表或预览有效模型（只读）
+  --effort <level>    （use 专用）同时设置推理强度
+  --format json       输出 JSON
+  --help, -h          各子命令均支持
+
+示例:
+  ec model list
+  ec model current --self bot.agentid.pub --peer aun#alice.agentid.pub
+  ec model info deepseek-v4-pro
+  ec model use opus --self bot.agentid.pub
+  ec model use deepseek-v4-pro --self bot.agentid.pub --peer alice.agentid.pub
+  ec model effort high --self bot.agentid.pub
+  ec model reset --self bot.agentid.pub --peer alice.agentid.pub
+  ec model check --self bot.agentid.pub`;
+async function dispatch(sub, args, formatJson) {
+    switch (sub) {
+        case 'list': return await cmdList(args, formatJson);
+        case 'current': return await cmdCurrent(args, formatJson);
+        case 'info': return await cmdInfo(args, formatJson);
+        case 'use': return await cmdUse(args, formatJson);
+        case 'reset': return await cmdReset(args, formatJson);
+        case 'effort': return await cmdEffort(args, formatJson);
+        case 'check': return await cmdCheck(args, formatJson);
+        default:
+            fail(formatJson, 'UNKNOWN_SUBCOMMAND', `未知子命令: ${sub}（model --help 查看用法）`);
+    }
+}
+// ── list ──────────────────────────────────────────────────────────────
+async function cmdList(args, formatJson) {
+    if (wantsHelp(args)) {
+        console.log(HELP);
+        return;
+    }
+    if (isManagedSessionEnv(args)) {
+        const out = await runCtlCommand('/model list', formatJson);
+        printCtlResult(out, formatJson);
+        return;
+    }
+    const sel = parseSelector(args, formatJson);
+    const role = explicitOrDerivedRole(args, sel);
+    const effectiveSel = selectorWithRole(sel, role);
+    const ba = activeBaseagent(sel.self);
+    const cat = await getCatalog(sel.self, ba);
+    const resolved = resolveModelConfig(effectiveSel, ba);
+    const allowedModelIds = role
+        ? filterModelsForRole(role, ba, cat.models.map(m => m.id), undefined, sel.self)
+        : null;
+    const models = allowedModelIds
+        ? allowedModelIds.map(id => cat.models.find(m => m.id === id) ?? { id })
+        : cat.models;
+    emit(formatJson, {
+        ok: true,
+        effective: { model: resolved.model ?? null, source: resolved.source ?? null },
+        role: role ?? null,
+        catalogSource: cat.source,
+        models,
+    }, () => {
+        const lines = [];
+        lines.push(`当前生效: ${resolved.model ?? '(未设置，回落 SDK 默认)'}` +
+            (resolved.source ? `  (来源: ${SCOPE_LABEL[resolved.source]})` : ''));
+        lines.push('');
+        const srcTag = cat.source === 'mock' ? ' [mock]'
+            : cat.source === 'remote' ? ' [remote]'
+                : '';
+        lines.push(`可用模型 (${models.length})${srcTag}:`);
+        for (const e of models) {
+            const live = resolved.model === e.id ? '✓' : ' ';
+            lines.push(`  ${live} ${e.id}`);
+        }
+        return lines.join('\n');
+    });
+}
+// ── current ───────────────────────────────────────────────────────────
+async function cmdCurrent(args, formatJson) {
+    if (wantsHelp(args)) {
+        console.log(HELP);
+        return;
+    }
+    if (isManagedSessionEnv(args)) {
+        const out = await runCtlCommand('/model current', formatJson);
+        printCtlResult(out, formatJson);
+        return;
+    }
+    const sel = parseSelector(args, formatJson);
+    const ba = activeBaseagent(sel.self);
+    const role = explicitOrDerivedRole(args, sel);
+    const resolved = resolveModelConfig(selectorWithRole(sel, role), ba);
+    emit(formatJson, {
+        ok: true,
+        model: resolved.model ?? null,
+        effort: resolved.effort ?? null,
+        source: resolved.source ?? null,
+        role: role ?? null,
+        chain: resolved.chain.map((c) => ({ scope: c.scope, model: c.model ?? null, hit: c.hit })),
+    }, () => {
+        const lines = [];
+        lines.push(`当前生效模型: ${resolved.model ?? '(未设置，回落 SDK 默认)'}`);
+        lines.push(`推理强度:     ${resolved.effort ?? 'auto'}`);
+        lines.push(`来源:         ${resolved.source ? SCOPE_LABEL[resolved.source] : '无'}`);
+        const chain = resolved.chain.map((c) => `${SCOPE_LABEL[c.scope]}${c.hit ? ' ✓' : ''}${c.model ? `(${c.model})` : ''}`).join(' > ');
+        lines.push(`解析链:       ${chain}`);
+        return lines.join('\n');
+    });
+}
+// ── info ──────────────────────────────────────────────────────────────
+async function cmdInfo(args, formatJson) {
+    if (wantsHelp(args)) {
+        console.log(HELP);
+        return;
+    }
+    const modelId = args[1] && !args[1].startsWith('--') ? args[1] : undefined;
+    if (!modelId)
+        fail(formatJson, 'MISSING_MODEL_ID', 'info 需要 <model-id>');
+    const sel = parseSelector(args, formatJson);
+    const self = getArgValue(args, '--self');
+    const info = await getModelInfo(modelId, self);
+    emit(formatJson, { ok: true, ...info }, () => {
+        const price = info.pricing;
+        const fmtPrice = (v) => v === null ? '— (mock)' : `$${v} / 1M tokens`;
+        return [
+            `模型: ${info.id}`,
+            `  厂商:       ${info.owned_by}`,
+            `  上下文窗口: ${info.context_window ?? '—'} tokens`,
+            `  最大输出:   ${info.max_output_tokens ?? '—'} tokens`,
+            `  输入价格:   ${fmtPrice(price?.input_per_mtok ?? null)}`,
+            `  输出价格:   ${fmtPrice(price?.output_per_mtok ?? null)}`,
+            `  支持模态:   ${info.modalities.join(', ')}${info.mocked ? ' (mock)' : ''}`,
+            `  推理强度:   ${info.supports_effort ? '支持' : '不支持'}`,
+            `  状态:       ${info.status === 'available' ? '✓ 可用' : info.status}`,
+        ].join('\n');
+    });
+}
+// ── use / effort / reset 共用写入逻辑 ───────────────────────────────────
+function describeWrite(scope, sel, model, effort, formatJson) {
+    emit(formatJson, {
+        ok: true,
+        scope,
+        self: sel.self ?? null,
+        peerKey: sel.peerKey ?? null,
+        model: model ?? undefined,
+        effort: effort ?? undefined,
+    }, () => {
+        const lines = ['✓ 已设置', `  作用域: ${SCOPE_LABEL[scope]}` +
+                (sel.peerKey ? ` (${sel.peerKey})` : '') + (sel.self ? ` [self=${sel.self}]` : '')];
+        if (model !== null)
+            lines.push(`  模型:   ${model}`);
+        if (effort !== null)
+            lines.push(`  推理强度: ${effort}`);
+        lines.push('  生效:   该范围所有会话的下一条消息起生效。');
+        return lines.join('\n');
+    });
+}
+async function cmdUse(args, formatJson) {
+    if (wantsHelp(args)) {
+        console.log(HELP);
+        return;
+    }
+    const modelId = args[1] && !args[1].startsWith('--') ? args[1] : undefined;
+    if (!modelId)
+        fail(formatJson, 'MISSING_MODEL_ID', 'use 需要 <model-id>');
+    if (isManagedSessionEnv(args)) {
+        const effort = getArgValue(args, '--effort');
+        const out = await runCtlCommand(`/model ${modelId}${effort ? ` ${effort}` : ''}`, formatJson);
+        printCtlResult(out, formatJson);
+        return;
+    }
+    const sel = parseSelector(args, formatJson);
+    const role = explicitOrDerivedRole(args, sel);
+    const scope = determineWriteScope(sel, formatJson);
+    const ba = activeBaseagent(sel.self);
+    // 校验模型在 catalog 中
+    const cat = await getCatalog(sel.self, ba);
+    if (!cat.models.some(m => m.id === modelId)) {
+        fail(formatJson, 'UNKNOWN_MODEL', `模型不在目录中: ${modelId}（model list 查看可用模型）`);
+    }
+    if (role) {
+        const decision = validateModelSelectionForRole({
+            role,
+            baseagent: ba,
+            requestedModel: modelId,
+            models: cat.models.map(m => m.id),
+            selfAid: sel.self,
+        });
+        if (!decision.ok)
+            fail(formatJson, decision.code || 'MODEL_NOT_ALLOWED', decision.message || `model not allowed: ${modelId}`);
+    }
+    const effort = getArgValue(args, '--effort');
+    if (effort !== undefined && !ALL_EFFORTS.includes(effort)) {
+        fail(formatJson, 'INVALID_EFFORT', `无效推理强度: ${effort}（${ALL_EFFORTS.join('/')})`);
+    }
+    const effortVal = effort === 'auto' ? null : (effort ?? undefined);
+    if (isManagedTargetedWriteEnv(args)) {
+        if (effortVal !== undefined) {
+            const effortKey = ba === 'codex' ? 'reasoning' : 'effort';
+            preflightManagedFieldOverride(sel, role, `baseagents.${ba}.${effortKey}`, effortVal, formatJson);
+        }
+        await setManagedModelField(sel, `baseagents.${ba}.model`, modelId, formatJson);
+        if (effortVal !== undefined) {
+            const effortKey = ba === 'codex' ? 'reasoning' : 'effort';
+            await setManagedModelField(sel, `baseagents.${ba}.${effortKey}`, effortVal, formatJson);
+        }
+        describeWrite(scope, sel, modelId, effort ?? null, formatJson);
+        return;
+    }
+    try {
+        writeScope(scope, sel, ba, { model: modelId, effort: effortVal });
+    }
+    catch (e) {
+        if (e instanceof ModelScopeError)
+            fail(formatJson, e.code, e.message);
+        throw e;
+    }
+    describeWrite(scope, sel, modelId, effort ?? null, formatJson);
+}
+async function cmdEffort(args, formatJson) {
+    if (wantsHelp(args)) {
+        console.log(HELP);
+        return;
+    }
+    const level = args[1] && !args[1].startsWith('--') ? args[1] : undefined;
+    if (!level)
+        fail(formatJson, 'INVALID_EFFORT', 'effort 需要 <level>（low|medium|high|xhigh|max|auto）');
+    if (!ALL_EFFORTS.includes(level)) {
+        fail(formatJson, 'INVALID_EFFORT', `无效推理强度: ${level}（${ALL_EFFORTS.join('/')})`);
+    }
+    if (isManagedSessionEnv(args)) {
+        const out = await runCtlCommand(`/effort ${level}`, formatJson);
+        printCtlResult(out, formatJson);
+        return;
+    }
+    const sel = parseSelector(args, formatJson);
+    const scope = determineWriteScope(sel, formatJson);
+    const ba = activeBaseagent(sel.self);
+    const val = level === 'auto' ? null : level;
+    if (isManagedTargetedWriteEnv(args)) {
+        const effortKey = ba === 'codex' ? 'reasoning' : 'effort';
+        preflightManagedFieldOverride(sel, explicitOrDerivedRole(args, sel), `baseagents.${ba}.${effortKey}`, val, formatJson);
+        await setManagedModelField(sel, `baseagents.${ba}.${effortKey}`, val, formatJson);
+        describeWrite(scope, sel, null, level, formatJson);
+        return;
+    }
+    try {
+        writeScope(scope, sel, ba, { effort: val });
+    }
+    catch (e) {
+        if (e instanceof ModelScopeError)
+            fail(formatJson, e.code, e.message);
+        throw e;
+    }
+    describeWrite(scope, sel, null, level, formatJson);
+}
+async function cmdReset(args, formatJson) {
+    if (wantsHelp(args)) {
+        console.log(HELP);
+        return;
+    }
+    if (isManagedSessionEnv(args)) {
+        const out = await runCtlCommand('/model reset', formatJson);
+        printCtlResult(out, formatJson);
+        return;
+    }
+    const sel = parseSelector(args, formatJson);
+    const scope = determineWriteScope(sel, formatJson);
+    const ba = activeBaseagent(sel.self);
+    if (isManagedTargetedWriteEnv(args)) {
+        const effortKey = ba === 'codex' ? 'reasoning' : 'effort';
+        const role = explicitOrDerivedRole(args, sel);
+        preflightManagedFieldOverride(sel, role, `baseagents.${ba}.model`, null, formatJson);
+        preflightManagedFieldOverride(sel, role, `baseagents.${ba}.${effortKey}`, null, formatJson);
+        await setManagedModelField(sel, `baseagents.${ba}.model`, null, formatJson);
+        await setManagedModelField(sel, `baseagents.${ba}.${effortKey}`, null, formatJson);
+        emit(formatJson, {
+            ok: true, scope, self: sel.self ?? null, peerKey: sel.peerKey ?? null,
+        }, () => `✓ 已清除 ${SCOPE_LABEL[scope]} 设置，回落上一级（该范围所有会话下条消息生效）`);
+        return;
+    }
+    try {
+        clearScope(scope, sel, ba);
+    }
+    catch (e) {
+        if (e instanceof ModelScopeError)
+            fail(formatJson, e.code, e.message);
+        throw e;
+    }
+    emit(formatJson, {
+        ok: true, scope, self: sel.self ?? null, peerKey: sel.peerKey ?? null,
+    }, () => {
+        return `✓ 已清除 ${SCOPE_LABEL[scope]} 设置，回落上一级（该范围所有会话下条消息生效）`;
+    });
+}
+async function cmdCheck(args, formatJson) {
+    if (wantsHelp(args)) {
+        console.log(HELP);
+        return;
+    }
+    if (isManagedSessionEnv(args)) {
+        const out = await runCtlCommand('/model check', formatJson, 60_000);
+        printCtlResult(out, formatJson);
+        return;
+    }
+    const sel = parseSelector(args, formatJson);
+    const role = explicitOrDerivedRole(args, sel);
+    const ba = activeBaseagent(sel.self);
+    const steps = [];
+    const result = await runModelCheck({
+        self: sel.self,
+        peerKey: sel.peerKey,
+        role,
+        baseagent: ba,
+        onStep: step => steps.push(step),
+    });
+    if (formatJson) {
+        emit(true, {
+            ok: true,
+            steps,
+            configuredModel: result.configuredModel ?? null,
+            configModelAvailable: result.configModelAvailable ?? null,
+            availableModels: result.availableModels,
+            role: role ?? null,
+            catalogSource: result.catalogSource,
+        }, () => '');
+        return;
+    }
+    console.log(formatModelCheck(result));
+}
+export async function cmdModel(args) {
+    const sub = args[0];
+    const formatJson = getArgValue(args, '--format') === 'json';
+    if (!sub || isHelpFlag(sub)) {
+        console.log(HELP);
+        return;
+    }
+    await dispatch(sub, args, formatJson);
+}