shennian 0.2.54 → 0.2.56

package/dist/src/agents/adapter.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'node:events';
-import type { AgentType, ExternalChannelSessionStatus } from '@shennian/wire';
+import type { AgentType, ChatAttachmentMeta, ExternalChannelSessionStatus } from '@shennian/wire';
 export type AgentEvent = {
     state: string;
     runId: string;
@@ -30,7 +30,7 @@ export declare abstract class AgentAdapter extends EventEmitter<AgentAdapterEven
         env?: NodeJS.ProcessEnv;
     }): void;
     abstract start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
-    abstract send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
+    abstract send(text: string, modelId?: string, reasoningEffort?: string, attachments?: ChatAttachmentMeta[]): Promise<void>;
     abstract resume(agentSessionId: string): Promise<void>;
     abstract stop(): Promise<void>;
 }

package/dist/src/agents/claude.d.ts

@@ -2,6 +2,8 @@ import { AgentAdapter } from './adapter.js';
 import type { ExternalChannelSessionStatus } from '@shennian/wire';
 export declare function normalizeClaudeModelId(modelId?: string | null): string;
 export declare function normalizeClaudeReasoningEffort(reasoningEffort?: string | null): string | undefined;
+export declare function resetClaudeCapabilityCacheForTests(): void;
+export declare function supportsClaudeReasoningEffort(): boolean;
 export declare class ClaudeAdapter extends AgentAdapter {
     private readonly options;
     readonly type: "claude";

package/dist/src/agents/claude.js

@@ -1,7 +1,7 @@
 import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
 import { AgentAdapter, registerAgent } from './adapter.js';
-import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
+import { resolveBuiltinCommand, spawnResolvedCommand, spawnResolvedCommandSync } from './command-spec.js';
 import { buildAgentProcessEnv } from '../agent-env.js';
 import { buildPlatformInstructions } from './platform-instructions.js';
 export function normalizeClaudeModelId(modelId) {
@@ -9,6 +9,7 @@ export function normalizeClaudeModelId(modelId) {
     return trimmed || 'default';
 }
 const CLAUDE_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+const claudeEffortSupportCache = new Map();
 export function normalizeClaudeReasoningEffort(reasoningEffort) {
     const trimmed = reasoningEffort?.trim();
     if (!trimmed)
@@ -17,6 +18,34 @@ export function normalizeClaudeReasoningEffort(reasoningEffort) {
         return trimmed;
     throw new Error(`Unsupported Claude reasoning effort "${trimmed}". Supported values: low, medium, high, xhigh, max.`);
 }
+export function resetClaudeCapabilityCacheForTests() {
+    claudeEffortSupportCache.clear();
+}
+export function supportsClaudeReasoningEffort() {
+    const spec = resolveBuiltinCommand('claude');
+    if (!spec)
+        return false;
+    const cacheKey = `${spec.kind}:${spec.path}:${spec.command}:${spec.args.join('\0')}`;
+    if (claudeEffortSupportCache.has(cacheKey)) {
+        return claudeEffortSupportCache.get(cacheKey) ?? false;
+    }
+    try {
+        const result = spawnResolvedCommandSync(spec, ['--help'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 3000,
+            env: buildAgentProcessEnv(),
+        });
+        const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
+        const supported = /(?:^|\s)--effort(?:\s|,|<)/.test(output);
+        claudeEffortSupportCache.set(cacheKey, supported);
+        return supported;
+    }
+    catch {
+        claudeEffortSupportCache.set(cacheKey, false);
+        return false;
+    }
+}
 export class ClaudeAdapter extends AgentAdapter {
     options;
     type = 'claude';
@@ -64,7 +93,7 @@ export class ClaudeAdapter extends AgentAdapter {
         }
         args.push('--model', normalizeClaudeModelId(modelId));
         const effort = normalizeClaudeReasoningEffort(reasoningEffort);
-        if (effort) {
+        if (effort && supportsClaudeReasoningEffort()) {
             args.push('--effort', effort);
         }
         if (this.agentSessionId) {

package/dist/src/agents/codex.d.ts

@@ -1,5 +1,5 @@
 import { AgentAdapter } from './adapter.js';
-import type { ExternalChannelSessionStatus } from '@shennian/wire';
+import type { ChatAttachmentMeta, ExternalChannelSessionStatus } from '@shennian/wire';
 export declare class CodexAdapter extends AgentAdapter {
     private readonly options;
     readonly type: "codex";
@@ -35,7 +35,7 @@ export declare class CodexAdapter extends AgentAdapter {
         env?: NodeJS.ProcessEnv;
     }): void;
     start(_sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
-    send(text: string, modelId?: string, reasoningEffort?: string): Promise<void>;
+    send(text: string, modelId?: string, reasoningEffort?: string, attachments?: ChatAttachmentMeta[]): Promise<void>;
     resume(agentSessionId: string): Promise<void>;
     stop(): Promise<void>;
     private spawnCodex;

package/dist/src/agents/codex.js

@@ -6,6 +6,28 @@ import { AgentAdapter, registerAgent } from './adapter.js';
 import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
 import { buildAgentProcessEnv } from '../agent-env.js';
 import { ensurePlatformInstructionsFile } from './platform-instructions.js';
+function buildCodexTextInput(text, attachments) {
+    const images = attachments
+        ?.filter((attachment) => attachment.kind === 'image')
+        .filter((attachment) => !/^https?:\/\//i.test(attachment.path))
+        .map((attachment) => {
+        if (attachment.previewData) {
+            return {
+                path: attachment.path,
+                data: attachment.previewData,
+                mimeType: attachment.mimeType,
+            };
+        }
+        return { path: attachment.path };
+    })
+        .filter((attachment) => attachment.path);
+    return {
+        type: 'text',
+        text,
+        text_elements: [],
+        ...(images?.length ? { local_images: images } : {}),
+    };
+}
 export class CodexAdapter extends AgentAdapter {
     options;
     type = 'codex';
@@ -46,7 +68,7 @@ export class CodexAdapter extends AgentAdapter {
         if (agentSessionId)
             this.agentSessionId = agentSessionId;
     }
-    async send(text, modelId, reasoningEffort) {
+    async send(text, modelId, reasoningEffort, attachments) {
         if (this.activeTurnId) {
             await this.interruptActiveTurn().catch(() => { });
             await this.killProcess();
@@ -68,7 +90,7 @@ export class CodexAdapter extends AgentAdapter {
             }).catch(() => { });
             this.namedThread = true;
         }
-        const response = await this.startTurnWithRecovery(threadId, text, codexModelId, codexReasoningEffort);
+        const response = await this.startTurnWithRecovery(threadId, text, codexModelId, codexReasoningEffort, attachments);
         this.activeTurnId = response.turn?.id ?? null;
     }
     async resume(agentSessionId) {
@@ -236,23 +258,23 @@ export class CodexAdapter extends AgentAdapter {
         this.agentSessionId = threadId;
         this.namedThread = !!response.thread?.name;
     }
-    async startTurnWithRecovery(threadId, text, codexModelId, reasoningEffort) {
+    async startTurnWithRecovery(threadId, text, codexModelId, reasoningEffort, attachments) {
         try {
-            return await this.startTurn(threadId, text, codexModelId, reasoningEffort);
+            return await this.startTurn(threadId, text, codexModelId, reasoningEffort, attachments);
         }
         catch (error) {
             if (!isMissingCodexRolloutError(error))
                 throw error;
             await this.killProcess();
             await this.ensureAppServer(codexModelId);
-            return await this.startTurn(threadId, text, codexModelId, reasoningEffort);
+            return await this.startTurn(threadId, text, codexModelId, reasoningEffort, attachments);
         }
     }
-    async startTurn(threadId, text, codexModelId, reasoningEffort) {
+    async startTurn(threadId, text, codexModelId, reasoningEffort, attachments) {
         try {
             return await this.sendRpc('turn/start', {
                 threadId,
-                input: [{ type: 'text', text, text_elements: [] }],
+                input: [buildCodexTextInput(text, attachments)],
                 approvalPolicy: 'never',
                 sandboxPolicy: { type: 'dangerFullAccess' },
                 ...(codexModelId ? { model: codexModelId } : {}),

package/dist/src/agents/config-status.d.ts

@@ -0,0 +1,17 @@
+import type { AgentConfigSummary, AgentType } from '@shennian/wire';
+export type AgentProviderConfigRecord = {
+    agent: 'codex' | 'claude';
+    baseUrl?: string;
+    token?: string;
+    updatedAt: string;
+};
+export declare function getManagedAgentProviderConfig(agent: 'codex' | 'claude'): AgentProviderConfigRecord | undefined;
+export declare function upsertManagedAgentProviderConfig(input: {
+    agent: 'codex' | 'claude';
+    baseUrl?: string;
+    token?: string;
+}): AgentProviderConfigRecord;
+export declare function deleteManagedAgentProviderConfig(agent: 'codex' | 'claude'): void;
+export declare function buildManagedAgentEnv(agent: AgentType): NodeJS.ProcessEnv;
+export declare function getAgentConfigSummary(agent: AgentType, env?: NodeJS.ProcessEnv): AgentConfigSummary | undefined;
+export declare function maskToken(token: string): string;

package/dist/src/agents/config-status.js

@@ -0,0 +1,205 @@
+// @arch docs/features/agent-provider-config.md
+// @test src/__tests__/agent-config-status.test.ts
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readLatestUserEnv } from '../agent-env.js';
+import { resolveShennianPath } from '../config/index.js';
+const MANAGED_CONFIG_PATH = resolveShennianPath('agent-provider-config.json');
+const TOKEN_SUFFIX_LENGTH = 4;
+const AGENT_ENV_KEYS = {
+    codex: {
+        baseUrl: ['OPENAI_BASE_URL', 'OPENAI_API_BASE', 'OPENAI_API_URL'],
+        token: ['OPENAI_API_KEY', 'OPENAI_TOKEN'],
+    },
+    claude: {
+        baseUrl: ['ANTHROPIC_BASE_URL', 'ANTHROPIC_API_URL'],
+        token: ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'],
+    },
+};
+export function getManagedAgentProviderConfig(agent) {
+    return loadManagedConfig().configs[agent];
+}
+export function upsertManagedAgentProviderConfig(input) {
+    const file = loadManagedConfig();
+    const existing = file.configs[input.agent];
+    const record = {
+        agent: input.agent,
+        baseUrl: input.baseUrl?.trim() || existing?.baseUrl,
+        token: input.token?.trim() || existing?.token,
+        updatedAt: new Date().toISOString(),
+    };
+    file.configs[input.agent] = record;
+    saveManagedConfig(file);
+    return record;
+}
+export function deleteManagedAgentProviderConfig(agent) {
+    const file = loadManagedConfig();
+    delete file.configs[agent];
+    saveManagedConfig(file);
+}
+export function buildManagedAgentEnv(agent) {
+    if (agent !== 'codex' && agent !== 'claude')
+        return {};
+    const config = getManagedAgentProviderConfig(agent);
+    if (!config)
+        return {};
+    if (agent === 'codex') {
+        return compactEnv({
+            OPENAI_BASE_URL: config.baseUrl,
+            OPENAI_API_KEY: config.token,
+        });
+    }
+    return compactEnv({
+        ANTHROPIC_BASE_URL: config.baseUrl,
+        ANTHROPIC_API_KEY: config.token,
+    });
+}
+export function getAgentConfigSummary(agent, env = readLatestUserEnv()) {
+    if (agent !== 'codex' && agent !== 'claude')
+        return undefined;
+    const managed = getManagedAgentProviderConfig(agent);
+    if (managed?.token || managed?.baseUrl) {
+        return toSummary({
+            agent,
+            source: 'shennian',
+            status: managed.token ? 'managed' : 'missing',
+            baseUrl: managed.baseUrl,
+            token: managed.token,
+            tokenPresent: !!managed.token,
+        });
+    }
+    const envConfig = detectFromEnv(agent, env);
+    if (envConfig.tokenPresent || envConfig.baseUrl) {
+        return toSummary({
+            agent,
+            source: 'env',
+            status: envConfig.tokenPresent ? 'detected' : 'missing',
+            baseUrl: envConfig.baseUrl,
+            token: envConfig.token,
+            tokenPresent: envConfig.tokenPresent,
+        });
+    }
+    const fileConfig = detectFromKnownConfigFiles(agent);
+    if (fileConfig.tokenPresent || fileConfig.baseUrl) {
+        return toSummary({
+            agent,
+            source: 'config-file',
+            status: fileConfig.tokenPresent ? 'detected' : 'missing',
+            baseUrl: fileConfig.baseUrl,
+            token: fileConfig.token,
+            tokenPresent: fileConfig.tokenPresent,
+        });
+    }
+    return toSummary({
+        agent,
+        source: 'unknown',
+        status: 'missing',
+        tokenPresent: false,
+    });
+}
+function loadManagedConfig() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(MANAGED_CONFIG_PATH, 'utf-8'));
+        return { configs: parsed.configs ?? {} };
+    }
+    catch {
+        return { configs: {} };
+    }
+}
+function saveManagedConfig(file) {
+    fs.mkdirSync(path.dirname(MANAGED_CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(MANAGED_CONFIG_PATH, JSON.stringify(file, null, 2), { mode: 0o600 });
+    try {
+        fs.chmodSync(MANAGED_CONFIG_PATH, 0o600);
+    }
+    catch {
+        // Best effort on filesystems without POSIX modes.
+    }
+}
+function compactEnv(env) {
+    const compacted = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value)
+            compacted[key] = value;
+    }
+    return compacted;
+}
+function detectFromEnv(agent, env) {
+    const keys = AGENT_ENV_KEYS[agent];
+    const baseUrl = firstEnv(env, keys.baseUrl);
+    const token = firstEnv(env, keys.token);
+    return { baseUrl, token, tokenPresent: !!token };
+}
+function firstEnv(env, keys) {
+    for (const key of keys) {
+        const value = env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function detectFromKnownConfigFiles(agent) {
+    const home = os.homedir();
+    const candidates = agent === 'codex'
+        ? [path.join(home, '.codex', 'config.toml'), path.join(home, '.codex', 'auth.json')]
+        : [path.join(home, '.claude', 'settings.json'), path.join(home, '.claude.json')];
+    for (const file of candidates) {
+        const text = readSmallTextFile(file);
+        if (!text)
+            continue;
+        const token = extractTokenLikeValue(text, agent);
+        const baseUrl = extractBaseUrl(text);
+        if (token || baseUrl)
+            return { token, baseUrl, tokenPresent: !!token };
+    }
+    return { tokenPresent: false };
+}
+function readSmallTextFile(file) {
+    try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile() || stat.size > 1024 * 1024)
+            return null;
+        return fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function extractBaseUrl(text) {
+    const match = text.match(/(?:base_url|baseURL|api_url|apiUrl|ANTHROPIC_BASE_URL|OPENAI_BASE_URL)["'\s:=]+([^"'\s,}]+)/i);
+    return match?.[1]?.trim();
+}
+function extractTokenLikeValue(text, agent) {
+    const prefix = agent === 'claude' ? 'sk-ant-' : 'sk-';
+    const direct = text.match(new RegExp(`${prefix.replace(/-/g, '\\-')}[A-Za-z0-9_\\-]{8,}`));
+    if (direct?.[0])
+        return direct[0];
+    const keyMatch = text.match(/(?:api[_-]?key|auth[_-]?token|token)["'\s:=]+([A-Za-z0-9_\-.]{12,})/i);
+    return keyMatch?.[1]?.trim();
+}
+function toSummary(input) {
+    return {
+        status: input.status,
+        source: input.source,
+        tokenPresent: input.tokenPresent,
+        ...(input.baseUrl ? { baseUrlHost: formatBaseUrlHost(input.baseUrl) } : {}),
+        ...(input.token ? { tokenHint: maskToken(input.token) } : {}),
+        updatedAt: new Date().toISOString(),
+    };
+}
+export function maskToken(token) {
+    const trimmed = token.trim();
+    if (!trimmed)
+        return '';
+    const suffix = trimmed.slice(-TOKEN_SUFFIX_LENGTH);
+    return `••••${suffix}`;
+}
+function formatBaseUrlHost(baseUrl) {
+    try {
+        return new URL(baseUrl).host || baseUrl;
+    }
+    catch {
+        return baseUrl.replace(/^https?:\/\//i, '').replace(/\/.*$/, '') || baseUrl;
+    }
+}

package/dist/src/agents/external-channel-instructions.js

@@ -6,23 +6,28 @@ export function buildExternalChannelInstructions(channel, workDir, sessionId) {
     const channelName = channel.name?.trim() || '外部消息通道';
     const customPrompt = channel.systemPrompt?.trim();
     const sessionHint = sessionId?.trim()
-        ? `当前对话 ID：${sessionId}。如果命令提示缺少外部通道上下文，使用：shennian external send --session-id ${sessionId} --text "<要发送的消息>"`
+        ? `当前对话 ID：${sessionId}。如果命令提示缺少外部通道上下文，在发送命令里补充 --session-id ${sessionId}。`
         : '';
     const workdirHint = workDir?.trim()
         ? `如果使用 shell_command，请设置 workdir 为 ${workDir}。不要用裸 /bin/zsh -lc 或 command_execution 运行此命令，因为那种环境可能拿不到当前对话的外部通道身份。`
         : '如果使用 shell_command，请设置 workdir 为当前对话的项目目录。不要用裸 /bin/zsh -lc 或 command_execution 运行此命令，因为那种环境可能拿不到当前对话的外部通道身份。';
     const sections = [
         `当前对话已接入外部消息通道：${channelName}。`,
-        `外部消息会以如下格式进入对话：\n外部消息\n<时间> <用户昵称>: <内容>`,
+        `外部企业微信群消息会以如下格式进入对话：\n外部企业微信群消息\n<时间> <用户昵称>: <内容>`,
         channel.canReply === false
             ? '当前通道只允许接收消息，不要尝试向外部通道发送回复。'
             : [
                 '当用户明确要求你向外部消息通道发送内容，或你需要回复一条外部消息时，调用：',
                 'shennian external send --text "<要发送的消息>"',
+                '发送图片：shennian external send-image --path "<图片绝对路径>" --caption "<可选说明>"',
+                '发送视频：shennian external send-video --path "<视频绝对路径>" --caption "<可选说明>"',
+                '发送文件：shennian external send-file --path "<文件绝对路径>" --caption "<可选说明>"',
+                '如果需要转发外部消息里的图片/视频/文件链接，先把链接下载到本地临时文件，再用对应的 --path 命令发送；不要直接发送短时效链接，也不要只口头说明已发送。',
                 sessionHint,
                 workdirHint,
                 '只发送用户可见的最终内容，不要发送内部推理、工具日志或实现细节。',
-                '对外消息必须像真人聊天：简短、概要、单段；不要使用 Markdown、编号列表、项目符号、真实换行或字面 \\n。',
+                '对外消息必须像真人聊天：短回复一条发完；内容较多时按自然段拆成 2-4 条连续消息，每条只讲一个完整主题。',
+                '避免把超过 300-500 字的内容塞进单条消息；不要使用 Markdown、编号列表、项目符号或字面 \\n。',
             ].join('\n'),
         '如果外部消息和当前任务无关，可以忽略或简短说明无需处理；如果处理需要时间，先用一句话确认，再继续完成任务。',
         customPrompt ? `本通道附加约束：${customPrompt}` : '',

package/dist/src/agents/model-registry/discovery.js

@@ -2,10 +2,10 @@
 // @test src/__tests__/model-switching.test.ts
 import { createInterface } from 'node:readline';
 import { resolveBuiltinCommand, spawnResolvedCommand } from '../command-spec.js';
-import { fallbackClaudeAliasModels, fallbackGeminiModels, parseCodexAppServerModels, parseCursorModels, parseOpenCodeModels, } from './parsers.js';
+import { fallbackClaudeAliasModels, discoverClaudeAliasModelsFromEnv, fallbackGeminiModels, parseCodexAppServerModels, parseCursorModels, parseOpenCodeModels, } from './parsers.js';
 import { runResolvedCommand } from './runner.js';
 import { DISCOVERY_WORKDIR } from './types.js';
-import { buildAgentProcessEnv } from '../../agent-env.js';
+import { buildAgentProcessEnv, readLatestUserEnv } from '../../agent-env.js';
 function sendAppServerRpc(proc, pending, id, method, params, timeoutMs) {
     if (!proc.stdin)
         return Promise.reject(new Error('codex app-server stdin unavailable'));
@@ -108,6 +108,9 @@ async function discoverOpenCodeModels() {
 async function discoverClaudeModels() {
     if (!resolveBuiltinCommand('claude'))
         return [];
+    const shellEnvModels = discoverClaudeAliasModelsFromEnv(readLatestUserEnv());
+    if (shellEnvModels.length > 0)
+        return shellEnvModels;
     return fallbackClaudeAliasModels();
 }
 async function discoverCodexModels() {

package/dist/src/agents/model-registry/parsers.d.ts

@@ -4,12 +4,14 @@ export declare function parseCursorModels(raw: string): ModelInfo[];
 export declare function parseOpenClawModels(raw: string): ModelInfo[];
 export declare function parseOpenCodeModels(raw: string): ModelInfo[];
 export declare function parseClaudeModels(raw: string): ModelInfo[];
-type EnvLike = Record<string, string | undefined>;
+export type EnvLike = Record<string, string | undefined>;
+export declare function readEnvValue(env: EnvLike, key: string): string | null;
+export declare function inferClaudeOverrideProvider(modelName: string, env: EnvLike): string;
+export declare function discoverClaudeAliasModelsFromEnv(env?: EnvLike): ModelInfo[];
 export declare function applyClaudeModelEnvOverrides(models: ModelInfo[], env?: EnvLike): ModelInfo[];
 export declare function parseClaudeBinaryModels(raw: string): ModelInfo[];
-export declare function fallbackClaudeAliasModels(): ModelInfo[];
+export declare function fallbackClaudeAliasModels(env?: EnvLike): ModelInfo[];
 export declare function parseCodexModels(raw: string): ModelInfo[];
 export declare function parseCodexAppServerModels(raw: unknown): ModelInfo[];
 export declare function parseGeminiModels(raw: string): ModelInfo[];
 export declare function fallbackGeminiModels(): ModelInfo[];
-export {};

package/dist/src/agents/model-registry/parsers.js

@@ -193,6 +193,9 @@ const CLAUDE_ALIAS_MODEL_ENV = {
     opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
     haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
 };
+const CLAUDE_DEEPSEEK_REASONING_EFFORTS = [
+    { id: 'max', name: 'Max' },
+];
 const CLAUDE_REASONING_EFFORTS = [
     { id: 'low', name: 'Low' },
     { id: 'medium', name: 'Medium' },
@@ -207,17 +210,46 @@ function withClaudeReasoningEfforts(model) {
         defaultReasoningEffort: 'medium',
     };
 }
-function readEnvValue(env, key) {
+export function readEnvValue(env, key) {
     const value = env[key]?.trim();
     return value || null;
 }
-function inferClaudeOverrideProvider(modelName, env) {
+export function inferClaudeOverrideProvider(modelName, env) {
     const baseUrl = readEnvValue(env, 'ANTHROPIC_BASE_URL')?.toLowerCase() ?? '';
     if (baseUrl.includes('deepseek.com') || modelName.toLowerCase().startsWith('deepseek-')) {
         return 'deepseek';
     }
     return baseUrl ? 'custom' : 'anthropic';
 }
+function configuredClaudeAliasModels(env) {
+    const configured = new Set();
+    for (const key of Object.values(CLAUDE_ALIAS_MODEL_ENV)) {
+        const modelName = readEnvValue(env, key);
+        if (modelName)
+            configured.add(modelName);
+    }
+    const models = Array.from(configured).map((modelName, index) => {
+        const provider = inferClaudeOverrideProvider(modelName, env);
+        const model = {
+            id: modelName,
+            name: modelName,
+            provider,
+            isDefault: index === 0,
+        };
+        if (provider === 'deepseek') {
+            return {
+                ...model,
+                supportedReasoningEfforts: CLAUDE_DEEPSEEK_REASONING_EFFORTS,
+                defaultReasoningEffort: readEnvValue(env, 'CLAUDE_CODE_EFFORT_LEVEL') ?? 'max',
+            };
+        }
+        return withClaudeReasoningEfforts(model);
+    });
+    return uniqueModels(models);
+}
+export function discoverClaudeAliasModelsFromEnv(env = process.env) {
+    return configuredClaudeAliasModels(env);
+}
 export function applyClaudeModelEnvOverrides(models, env = process.env) {
     return models.map((model) => {
         if (!['default', 'sonnet', 'opus', 'haiku'].includes(model.id))
@@ -268,13 +300,16 @@ export function parseClaudeBinaryModels(raw) {
     }
     return uniqueModels(models);
 }
-export function fallbackClaudeAliasModels() {
+export function fallbackClaudeAliasModels(env = process.env) {
+    const configuredModels = configuredClaudeAliasModels(env);
+    if (configuredModels.length > 0)
+        return configuredModels;
     return applyClaudeModelEnvOverrides([
         { id: 'default', name: 'Default (recommended)', provider: 'anthropic', isDefault: true },
         { id: 'sonnet', name: 'Sonnet', provider: 'anthropic' },
         { id: 'opus', name: 'Opus', provider: 'anthropic' },
         { id: 'haiku', name: 'Haiku', provider: 'anthropic' },
-    ]).map(withClaudeReasoningEfforts);
+    ], env).map(withClaudeReasoningEfforts);
 }
 export function parseCodexModels(raw) {
     const clean = stripAnsi(raw);

package/dist/src/agents/model-registry/service.js

@@ -1,5 +1,6 @@
 // @arch docs/architecture/cli/model-discovery.md
 // @test src/__tests__/model-switching.test.ts
+import { getAgentConfigSummary } from '../config-status.js';
 import { isCacheFresh, readCache, writeCache } from './cache.js';
 import { discoverModelsForAgent } from './discovery.js';
 function uniqueModels(models) {
@@ -15,10 +16,14 @@ function uniqueModels(models) {
 }
 export function getCachedAgentInfos(detectedAgents) {
     const cache = readCache();
-    return detectedAgents.map((agent) => ({
-        type: agent.type,
-        models: cache.agents[agent.type]?.models ?? agent.models ?? [],
-    }));
+    return detectedAgents.map((agent) => {
+        const config = getAgentConfigSummary(agent.type);
+        return {
+            type: agent.type,
+            models: cache.agents[agent.type]?.models ?? agent.models ?? [],
+            ...(config ? { config } : {}),
+        };
+    });
 }
 export async function refreshAgentInfos(detectedAgents, context) {
     const cache = readCache();
@@ -59,9 +64,11 @@ export async function resolveAgentInfos(detectedAgents, context) {
                 }
             }
         }
+        const config = getAgentConfigSummary(agent.type);
         infos.push({
             type: agent.type,
             models,
+            ...(config ? { config } : {}),
         });
     }
     if (changed) {

package/dist/src/agents/model-registry.d.ts

@@ -1,8 +1,10 @@
 export { getCachedAgentInfos, refreshAgentInfos, resolveAgentInfos, } from './model-registry/service.js';
-import { applyClaudeModelEnvOverrides, parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi } from './model-registry/parsers.js';
+import { applyClaudeModelEnvOverrides, discoverClaudeAliasModelsFromEnv, fallbackClaudeAliasModels, parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi } from './model-registry/parsers.js';
 /** Used by Vitest / `model-switching-e2e.ts` — not a stable public API. */
 export declare const modelSwitchingTestExports: {
     readonly applyClaudeModelEnvOverrides: typeof applyClaudeModelEnvOverrides;
+    readonly discoverClaudeAliasModelsFromEnv: typeof discoverClaudeAliasModelsFromEnv;
+    readonly fallbackClaudeAliasModels: typeof fallbackClaudeAliasModels;
     readonly parseClaudeBinaryModels: typeof parseClaudeBinaryModels;
     readonly parseClaudeModels: typeof parseClaudeModels;
     readonly parseCodexModels: typeof parseCodexModels;

package/dist/src/agents/model-registry.js

@@ -1,10 +1,12 @@
 // @arch docs/architecture/cli/model-discovery.md
 // @test src/__tests__/model-switching.test.ts
 export { getCachedAgentInfos, refreshAgentInfos, resolveAgentInfos, } from './model-registry/service.js';
-import { applyClaudeModelEnvOverrides, parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi, } from './model-registry/parsers.js';
+import { applyClaudeModelEnvOverrides, discoverClaudeAliasModelsFromEnv, fallbackClaudeAliasModels, parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi, } from './model-registry/parsers.js';
 /** Used by Vitest / `model-switching-e2e.ts` — not a stable public API. */
 export const modelSwitchingTestExports = {
     applyClaudeModelEnvOverrides,
+    discoverClaudeAliasModelsFromEnv,
+    fallbackClaudeAliasModels,
     parseClaudeBinaryModels,
     parseClaudeModels,
     parseCodexModels,

package/dist/src/channels/reply-split.d.ts

@@ -0,0 +1 @@
+export declare function splitExternalReplyText(text: string): string[];