c0de-agent 1.11.0 → 1.13.0

package/dist/core/slash.js

@@ -1,6 +1,8 @@
-import { createSession } from '../session/session.js';
+import { resolve } from 'node:path';
+import { createSession, getSession } from '../session/session.js';
+import { PROJECT_BOUND_TOOLS, resolveEnabledToolNames } from '../tools/index.js';
 import { createAgent } from './agent.js';
-import { BUILTIN_WORKFLOWS, createWorkflowRegistry, discoverWorkflows, executeWorkflow, reloadRegistry, saveWorkflow, } from './workflows/index.js';
+import { BUILTIN_WORKFLOWS, createWorkflowRegistry, discoverWorkflows, executeWorkflow, reloadRegistry, saveWorkflow, workflowSessionTitle, } from './workflows/index.js';
 function parseSlashInput(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/'))
@@ -11,6 +13,22 @@ function parseSlashInput(input) {
     }
     return { name: trimmed.slice(1, spaceIdx), args: trimmed.slice(spaceIdx + 1).trim() };
 }
+/** 校验跨会话操作的归属：目标会话必须存在；当前会话与目标均挂项目时须同项目，
+ *  防 Web 端误输/被注入 id 清空或分支其他项目的会话。CLI 无当前会话上下文
+ *  （sessionId 缺省）时放行——终端单用户显式操作。 */
+async function assertSameProjectSession(db, currentId, targetId) {
+    const target = await getSession(db, targetId);
+    if (!target)
+        throw new Error(`目标会话不存在：${targetId}`);
+    if (!currentId || currentId === targetId)
+        return;
+    const current = await getSession(db, currentId);
+    const currentProject = current?.projectId ?? null;
+    const targetProject = target.projectId ?? null;
+    if (currentProject !== null && targetProject !== null && currentProject !== targetProject) {
+        throw new Error(`会话 ${targetId} 属于其他项目，不能从当前会话操作`);
+    }
+}
 function createSlashRegistry() {
     const commands = new Map();
     for (const cmd of builtinCommands) {
@@ -23,25 +41,47 @@ function createSlashRegistry() {
         register: (cmd) => commands.set(cmd.name, cmd),
     };
 }
+/**
+ * P0-2：统一斜杠命令启用判定（Web chat / CLI chat / 命令列表 / /help 共用）。
+ * 语义（fail-closed，与 tools.enabled 对齐）：
+ *  - enabled 含 '*'（通配）→ 全部启用。
+ *  - enabled 为显式名单 → 仅名单内启用（名称兼容带/不带前缀斜杠）。
+ *  - enabled 为空数组/缺失 → 全部禁用（旧版含义「空=全部启用」，升级告警见
+ *    collectConfigMigrationWarnings——两处同形键不再语义相反）。
+ * `enabled` 已含 '/' 前缀或裸名均可。
+ */
+export function isSlashCommandEnabled(enabled, name) {
+    const list = enabled ?? [];
+    if (list.length === 0)
+        return false;
+    if (list.includes('*'))
+        return true;
+    const norm = name.startsWith('/') ? name.slice(1) : name;
+    return list.some((n) => (n.startsWith('/') ? n.slice(1) : n) === norm);
+}
 const helpCommand = {
     name: 'help',
-    description: 'List available slash commands',
-    execute: async () => {
-        const lines = [
-            'Available commands:',
-            '  /compact         Manually trigger context compaction',
-            '  /clear [id] --yes  Clear session messages (default: current session; archives originals)',
-            '  /help            Show this help',
-            '  /fork [id] [index]  Fork session (default: current session, latest message)',
-            '  /config [key] [value]  View or set configuration (dot paths supported)',
-            '  /workflow        Manage and run workflows',
-        ];
+    description: '列出可用斜杠命令',
+    execute: async (_args, ctx) => {
+        // 从 registry 动态生成，避免静态文案随命令增删漂移；
+        // 尊重 slashCommands.enabled 过滤（含 ['*'] = 全部启用；空 = 全部禁用）。
+        const enabledList = ctx.config.slashCommands?.enabled;
+        const commands = createSlashRegistry()
+            .list()
+            .filter((c) => isSlashCommandEnabled(enabledList, c.name));
+        const width = Math.max(...commands.map((c) => `/${c.name}`.length));
+        const lines = ['可用命令：'];
+        for (const cmd of commands) {
+            const hint = cmd.argsHint ? ` ${cmd.argsHint}` : '';
+            const pad = ' '.repeat(Math.max(1, width - `/${cmd.name}`.length));
+            lines.push(`  /${cmd.name}${pad}${hint}  ${cmd.description}`);
+        }
         return { _tag: 'text', text: lines.join('\n') };
     },
 };
 const compactCommand = {
     name: 'compact',
-    description: 'Manually trigger context compaction',
+    description: '手动触发上下文压缩',
     execute: async () => {
         // 仅声明意图：真正的压缩由消费方（loop.compactContext / chat 路由）执行，
         // 复用 createSummarizer + runCompaction，且不把 /compact 当作 user 消息发给 LLM。
@@ -50,20 +90,47 @@ const compactCommand = {
 };
 const modelCommand = {
     name: 'model',
-    description: 'Model selection guidance',
+    description: '查看当前会话使用的模型',
     argsHint: '',
-    execute: async () => {
-        // 诚实化：模型由前端 ModelSelector 决定并随请求 body 传递，服务端不保存会话级模型覆盖。
-        // 此前返回 "Model set to X" 但什么都不生效。
+    execute: async (_args, ctx) => {
+        // P2：诚实化——此前返回「Model set to X」但什么都不生效，后改为引导文案。
+        // 现在提供真实信息：优先读本会话活跃段的 provider/model（若存在），
+        // 否则回退默认配置。会话模型切换由底部 ModelSelector 完成（Web）；
+        // CLI 按渠道给出可操作指引（P3：此前 CLI 输出指向 Web-only 控件，是死路）。
+        const model = async () => {
+            if (!ctx.sessionId)
+                return null;
+            try {
+                const { getLLMSegments } = await import('../session/session.js');
+                const segs = await getLLMSegments(ctx.deps.db, ctx.sessionId);
+                const last = segs[segs.length - 1];
+                if (last)
+                    return `${last.model}（provider: ${last.provider}）`;
+            }
+            catch {
+                // 段查询失败回退默认值展示
+            }
+            return null;
+        };
+        const sessionModel = await model();
+        if (ctx.channel === 'cli') {
+            return {
+                _tag: 'text',
+                text: `${sessionModel ? `当前会话模型：${sessionModel}` : `默认模型：${ctx.config.defaultModel}（provider: ${ctx.config.defaultProvider}）`}\n` +
+                    'CLI 模式不支持会话内切换模型：新会话用 c0de chat --model <model>，' +
+                    '或 c0de config set defaultModel <model> 修改默认模型。',
+            };
+        }
         return {
             _tag: 'text',
-            text: '会话模型请在聊天页底部的模型选择器中切换（/model 不再直接生效）。',
+            text: `${sessionModel ? `当前会话模型：${sessionModel}` : `默认模型：${ctx.config.defaultModel}（provider: ${ctx.config.defaultProvider}）`}\n` +
+                '切换模型请使用聊天页底部的模型选择器。',
         };
     },
 };
 const clearCommand = {
     name: 'clear',
-    description: 'Clear session messages (archives originals first)',
+    description: '清空会话消息（先归档原始内容）',
     argsHint: '[session-id] [--yes]',
     execute: async (args, ctx) => {
         const parts = args.split(/\s+/).filter(Boolean);
@@ -72,10 +139,16 @@ const clearCommand = {
         if (!sessionId) {
             return { _tag: 'error', message: 'Usage: /clear [session-id] --yes（当前会话可省略 id）' };
         }
+        try {
+            await assertSameProjectSession(ctx.deps.db, ctx.sessionId, sessionId);
+        }
+        catch (error) {
+            return { _tag: 'error', message: error instanceof Error ? error.message : String(error) };
+        }
         if (!yes) {
             return {
                 _tag: 'error',
-                message: '清空消息不可逆。原始消息将归档保存，确认请执行 /clear --yes（或 /clear <session-id> --yes）。',
+                message: '清空消息不可逆。原始消息将归档到「会话归档」面板（会话页顶部「归档」按钮可查看/搜索），确认请执行 /clear --yes（或 /clear <session-id> --yes）。',
             };
         }
         const { getEntries, deleteEntriesByIds } = await import('../session/message.js');
@@ -88,23 +161,26 @@ const clearCommand = {
             await archiveOriginalEntries(ctx.deps.db, sessionId, entries, 'clear', `Cleared ${ids.length} entries`, generateId());
             await deleteEntriesByIds(ctx.deps.db, ids);
         }
-        return { _tag: 'success', message: `Cleared ${ids.length} entries (archived)` };
+        return {
+            _tag: 'success',
+            message: `已清空 ${ids.length} 条消息（原内容已归档，可在会话页「归档」面板查看；历史 token/成本仍计入本会话用量统计）`,
+        };
     },
 };
 const forkCommand = {
     name: 'fork',
-    description: 'Fork session from a message index',
+    description: '从指定消息处分支会话',
     argsHint: '[session-id] [message-index]',
     execute: async (args, ctx) => {
         const parts = args.split(/\s+/).filter(Boolean);
-        // 默认当前会话；第一个参数若是 session id（非纯数字）则用它。
+        // 默认当前会话；第一个非纯数字参数视为 session id 覆盖（fork 其他会话）。
         let sessionId = ctx.sessionId;
         let messageIndex;
         for (const p of parts) {
             if (/^\d+$/.test(p)) {
                 messageIndex = Number.parseInt(p, 10);
             }
-            else if (!sessionId) {
+            else {
                 sessionId = p;
             }
         }
@@ -114,6 +190,12 @@ const forkCommand = {
                 message: 'Usage: /fork [session-id] [message-index]（当前会话可省略 id）',
             };
         }
+        try {
+            await assertSameProjectSession(ctx.deps.db, ctx.sessionId, sessionId);
+        }
+        catch (error) {
+            return { _tag: 'error', message: error instanceof Error ? error.message : String(error) };
+        }
         // 未指定 index → 默认最新一条消息处分支（与 web fork API 语义一致，不再是 index 0）
         if (messageIndex === undefined) {
             const { getMessages } = await import('../session/message.js');
@@ -126,7 +208,7 @@ const forkCommand = {
         const { forkSession } = await import('../session/branch.js');
         try {
             const forked = await forkSession(ctx.deps.db, sessionId, messageIndex);
-            return { _tag: 'success', message: `Forked to new session: ${forked.id}` };
+            return { _tag: 'success', message: `已分支到新会话：${forked.id}` };
         }
         catch (error) {
             return {
@@ -138,19 +220,29 @@ const forkCommand = {
 };
 const configCommand = {
     name: 'config',
-    description: 'View or set configuration',
+    description: '查看或设置配置（支持点路径）',
     argsHint: '[key] [value]',
     execute: async (args, ctx) => {
         const { getByPath, setPathPatch, coerce } = await import('./config-path.js');
+        // 展示前脱敏：apiKey/token 等敏感字段绝不原样出现在聊天里（P0 密钥暴露）。
+        const { redactSecrets } = await import('./redact.js');
         if (!args) {
-            return { _tag: 'text', text: JSON.stringify(ctx.config, null, 2) };
+            return {
+                _tag: 'text',
+                text: `（合并视图：global + project 作用域；修改请用 /config <key> <value>，写入 project 作用域）\n${JSON.stringify(redactSecrets(ctx.config), null, 2)}`,
+            };
         }
         const parts = args.split(/\s+/);
         const key = parts[0] ?? '';
         if (parts.length === 1) {
             try {
-                const value = getByPath(ctx.config, key);
-                return { _tag: 'text', text: `${key}: ${JSON.stringify(value)}` };
+                // 用点路径末段作为键名参与脱敏判定：/config security.token 等单键读取同样掩码。
+                const leaf = key.split('.').pop();
+                const value = redactSecrets(getByPath(ctx.config, key), leaf);
+                return {
+                    _tag: 'text',
+                    text: `${key}: ${JSON.stringify(value)}（合并视图：global + project 作用域）`,
+                };
             }
             catch (error) {
                 return { _tag: 'error', message: error instanceof Error ? error.message : String(error) };
@@ -158,19 +250,38 @@ const configCommand = {
         }
         // 点路径写值：与 CLI config set 同语义（project 作用域最小落盘，null=unset）
         const { applyScopedPatch, loadConfigScopes, saveConfigScoped } = await import('./config.js');
+        // 作用域收敛：security 是服务端全局参数，项目作用域写入会被加载时剥离（不生效），
+        // 直接拒绝并给出正解路径（与 CLI config set --global / Web PATCH /api/config 同语义）。
+        if (key.split('.')[0] === 'security') {
+            return {
+                _tag: 'error',
+                message: 'security 是服务端全局参数，仅在全局作用域生效。请在全局配置（~/.c0de/config.json）中设置，或用 c0de config set --global 写入。',
+            };
+        }
         const scopes = loadConfigScopes(ctx.cwd);
         const value = coerce(parts.slice(1).join(' '));
         const next = applyScopedPatch(scopes.project ?? {}, setPathPatch(key, value));
         await saveConfigScoped('project', ctx.cwd, next);
+        // P1：/config 写入项目作用域是用户显式操作——已信任项目刷新风险指纹，
+        // 防「信任 → 改设置 → 再信任」自锁复检（与 /workflow create 同口径）。
+        try {
+            const { getByDirectory, trustProject } = await import('../project/index.js');
+            const p = await getByDirectory(ctx.deps.db, ctx.cwd);
+            if (p?.trustedAt != null)
+                await trustProject(ctx.deps.db, p.id);
+        }
+        catch {
+            // 指纹刷新失败不阻塞配置写入结果（最坏回到 fail-closed 复检路径）
+        }
         return {
             _tag: 'success',
-            message: `${value === null ? 'Unset' : 'Set'} ${key} (scope: project)`,
+            message: `${value === null ? '已取消设置' : '已设置'} ${key} (scope: project)`,
         };
     },
 };
 const workflowCommand = {
     name: 'workflow',
-    description: 'Manage and run workflows',
+    description: '管理并运行工作流',
     argsHint: '[list|run|show|create|edit] [name] [args]',
     subcommands: [
         { name: 'list', description: 'List available workflows' },
@@ -190,24 +301,42 @@ const workflowCommand = {
                 registry.register(wf);
             }
         }
-        // 项目级工作流：从 agent cwd（= project worktree）动态发现。
-        // registry 是 server 单例（含 builtin + global + server-cwd），不含其他项目的工作流。
-        const projectWorkflows = await discoverWorkflows(ctx.cwd);
+        // 项目级工作流：从 agent cwd（= project worktree）动态发现。发现即执行
+        // 仓库代码（dynamic import 顶层即刻运行）——必须与信任门禁同口径：仅在
+        // 目录已注册为项目且 trustedAt + 指纹一致时发现（fail-closed，回退注册表）。
+        // 此前无条件发现：Web 未注册目录的会话/CLI 路径会在未信任仓库执行工作流代码。
+        let projectWorkflows = [];
+        try {
+            const { getByDirectory } = await import('../project/index.js');
+            const { projectTrustCurrent } = await import('../project/trust.js');
+            const { loadConfigScopes } = await import('./config.js');
+            const p = await getByDirectory(ctx.deps.db, ctx.cwd);
+            if (p?.trustedAt != null) {
+                const scopes = loadConfigScopes(ctx.cwd);
+                if (projectTrustCurrent(scopes.project, p.trustedAt, p.riskFingerprint, ctx.cwd)) {
+                    projectWorkflows = await discoverWorkflows(ctx.cwd);
+                }
+            }
+        }
+        catch {
+            // 信任查询失败 → 不发现项目级（fail-closed）
+        }
         const projectByName = new Map(projectWorkflows.map((w) => [w.meta.name, w]));
-        const resolveEntry = (name) => registry?.get(name) ?? projectByName.get(name);
+        // 统一优先级：项目 > 用户 > 内置（与列表/resolveWorkflow 一致；此前注册表优先）。
+        const resolveEntry = (name) => projectByName.get(name) ?? registry?.get(name);
         if (subcommand === 'list') {
             // 合并 registry + 项目级（去重：同名项目级覆盖）
             const byName = new Map(registry.list().map((w) => [w.meta.name, w]));
             for (const wf of projectWorkflows)
                 byName.set(wf.meta.name, wf);
             const workflows = Array.from(byName.values());
-            const lines = ['Available workflows:'];
+            const lines = ['可用工作流：'];
             for (const wf of workflows) {
                 const phases = wf.meta.phases ? ` [${wf.meta.phases.join('→')}]` : '';
                 lines.push(`  /${wf.meta.name}${phases}  — ${wf.meta.description} (${wf.source})`);
             }
             lines.push('');
-            lines.push('Usage:');
+            lines.push('用法：');
             lines.push('  /workflow run <name> [args]     — 执行工作流');
             lines.push('  /workflow create <name> --file <path>  — 从文件创建工作流');
             lines.push('  /workflow edit <name>           — 编辑工作流源码');
@@ -220,7 +349,7 @@ const workflowCommand = {
                 return { _tag: 'error', message: 'Usage: /workflow show <name>' };
             const wf = resolveEntry(name);
             if (!wf) {
-                return { _tag: 'error', message: `Unknown workflow: ${name}` };
+                return { _tag: 'error', message: `未知工作流：${name}` };
             }
             const code = wf.sourceCode ?? '// source not available';
             return {
@@ -241,24 +370,56 @@ const workflowCommand = {
                 };
             }
             const filePath = parts[fileIdx + 1] ?? '';
+            // 相对路径以 agent 的 cwd（项目 worktree / CLI 工作目录）解析，而非 serve 进程 cwd——
+            // 否则 Web 端 `/workflow create wf --file ./wf.md` 会读错基准目录。
+            const resolvedPath = resolve(ctx.cwd, filePath);
+            // 同名工作流已存在时覆盖需显式确认——否则误输名称会静默替换
+            // 用户级/项目级既有工作流（尤其跨层级：项目级同名会遮蔽用户级）。
+            const existing = registry?.get(name) ?? projectByName.get(name);
+            if (existing && !parts.includes('--yes')) {
+                return {
+                    _tag: 'error',
+                    message: `工作流 "${name}" 已存在（${existing.source} 级），覆盖会替换其内容。` +
+                        '确认覆盖请加 --yes：/workflow create <name> --file <path> --yes',
+                };
+            }
             let source;
             try {
-                source = await import('node:fs/promises').then((fs) => fs.readFile(filePath, 'utf-8'));
+                source = await import('node:fs/promises').then((fs) => fs.readFile(resolvedPath, 'utf-8'));
             }
             catch {
-                return { _tag: 'error', message: `Cannot read file: ${filePath}` };
+                return { _tag: 'error', message: `无法读取文件：${resolvedPath}` };
             }
             const result = await saveWorkflow(name, source, 'project', ctx.cwd);
             if (!result.ok) {
                 return { _tag: 'error', message: result.error };
             }
-            // 热重载注册表
-            if (ctx.workflowRegistry) {
-                await reloadRegistry(ctx.workflowRegistry, ctx.cwd);
+            // 先刷新信任指纹（用户刚写入的 workflow 是自己写的代码）再热重载：
+            // reload 的项目级发现按 projectTrustCurrent 判定，新文件未入指纹时会
+            // 误判漂移而跳过，且「信任 → 新建 → 漂移复检」会把自己锁出门禁。
+            let projectTrusted = false;
+            try {
+                const { getByDirectory, trustProject } = await import('../project/index.js');
+                const { projectTrustCurrent } = await import('../project/trust.js');
+                const { loadConfigScopes } = await import('./config.js');
+                const p = await getByDirectory(ctx.deps.db, ctx.cwd);
+                if (p?.trustedAt != null)
+                    await trustProject(ctx.deps.db, p.id);
+                projectTrusted =
+                    p?.trustedAt != null &&
+                        projectTrustCurrent(loadConfigScopes(ctx.cwd).project, p.trustedAt, p.riskFingerprint, ctx.cwd);
+                if (ctx.workflowRegistry) {
+                    await reloadRegistry(ctx.workflowRegistry, ctx.cwd, { projectTrusted });
+                }
+            }
+            catch {
+                // 信任查询/指纹刷新失败不阻塞创建结果（fail-closed：项目级不 import）
+                if (ctx.workflowRegistry)
+                    await reloadRegistry(ctx.workflowRegistry, ctx.cwd);
             }
             return {
                 _tag: 'success',
-                message: `Workflow "${name}" saved to ${result.filePath}\n现在可以用 /workflow run ${name} 执行，或在对话中输入 /${name} 调用。`,
+                message: `工作流 "${name}" 已保存到 ${result.filePath}\n现在可以用 /workflow run ${name} 执行，或在对话中输入 /${name} 调用。`,
             };
         }
         if (subcommand === 'edit') {
@@ -267,30 +428,27 @@ const workflowCommand = {
                 return { _tag: 'error', message: 'Usage: /workflow edit <name>' };
             const wf = resolveEntry(name);
             if (!wf) {
-                return { _tag: 'error', message: `Unknown workflow: ${name}` };
+                return { _tag: 'error', message: `未知工作流：${name}` };
             }
             if (wf.source === 'builtin') {
                 return {
                     _tag: 'error',
-                    message: 'Cannot edit builtin workflow. Fork it first: /workflow create <new-name> --file <path>',
+                    message: '内置工作流不可编辑。请先复制：/workflow create <新名称> --file <路径>',
                 };
             }
             if (!wf.filePath) {
-                return { _tag: 'error', message: `Workflow file path not available for "${name}"` };
-            }
-            const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
-            try {
-                const { spawnSync } = await import('node:child_process');
-                spawnSync(editor, [wf.filePath], { stdio: 'inherit' });
-            }
-            catch {
-                return { _tag: 'error', message: `Failed to launch editor: ${editor}` };
-            }
-            // 编辑后热重载
-            if (ctx.workflowRegistry) {
-                await reloadRegistry(ctx.workflowRegistry, ctx.cwd);
+                return { _tag: 'error', message: `工作流 "${name}" 的文件路径不可用` };
             }
-            return { _tag: 'success', message: `Workflow "${name}" reloaded after edit.` };
+            // 斜杠命令经 Web SSE 执行，无法在浏览器里交互式打开终端编辑器——
+            // 在 serve 进程 spawn vi 会让用户既看不到也无法输入，SSE 流还会阻塞。
+            // 改为给出文件路径引导用户在本地编辑器/文件面板中编辑。
+            return {
+                _tag: 'error',
+                message: `Web 端不支持交互式编辑器。请用本地编辑器打开工作流文件后保存：\n` +
+                    `  ${wf.filePath}\n` +
+                    `保存后下次 /workflow run ${name} 会读取最新内容（项目工作流按需从磁盘发现）。` +
+                    `或使用 /workflow create <name> --file <path> 覆盖。`,
+            };
         }
         if (subcommand === 'run') {
             const name = parts[1];
@@ -305,17 +463,31 @@ const workflowCommand = {
                 ].join(', ');
                 return {
                     _tag: 'error',
-                    message: `Unknown workflow: "${name}". Available: ${available || '(none)'}`,
+                    message: `未知工作流："${name}"。可用：${available || '(无)'}`,
                 };
             }
+            // 工作流会话绑定 projectId + worktreePath（P1-1）：此前丢失项目归属，
+            // 子 agent 会话继承 null projectId，且后续继续该会话时代理会回退到
+            // serve 启动目录执行。
+            let workflowProjectId;
+            try {
+                const { getByDirectory } = await import('../project/index.js');
+                workflowProjectId = (await getByDirectory(ctx.deps.db, ctx.cwd))?.id ?? undefined;
+            }
+            catch {
+                workflowProjectId = undefined;
+            }
+            // P2-5：runner 工具集传配置解析结果（与 Web 斜杠/REST/CLI print 同口径），
+            // 作为子 agent 工具集交集基准——config.tools.enabled 的 fail-closed 语义
+            // 对工作流派发的子 agent 成立。runner 自身不进 agentLoop，无 LLM 影响。
             const agentConfig = {
                 provider: ctx.config.defaultProvider,
                 model: ctx.config.defaultModel,
-                tools: [],
+                tools: resolveEnabledToolNames(ctx.deps.toolRegistry, ctx.config).filter((n) => Boolean(workflowProjectId) || !PROJECT_BOUND_TOOLS.has(n)),
                 plugins: ctx.config.plugins.enabled,
                 agentName: 'default',
             };
-            const session = await createSession(ctx.deps.db, `workflow:${name}`, undefined, 'workflow');
+            const session = await createSession(ctx.deps.db, workflowSessionTitle(name), workflowProjectId, 'workflow', undefined, undefined, ctx.cwd);
             const parent = await createAgent(session, agentConfig, ctx.deps);
             return executeWorkflow({
                 registry,
@@ -328,7 +500,7 @@ const workflowCommand = {
         }
         return {
             _tag: 'error',
-            message: `Unknown subcommand: ${subcommand}. Use: list, run, show, create, edit`,
+            message: `未知子命令：${subcommand}。可用：list, run, show, create, edit`,
         };
     },
 };

package/dist/core/title.js

@@ -1,4 +1,5 @@
 import { chat as defaultChat } from '../llm/provider.js';
+import { buildFallbackChain } from '../llm/routing.js';
 import { updateSessionTitle } from '../session/session.js';
 /** 会话默认占位标题；仍是该值时才有资格自动生成。 */
 const DEFAULT_SESSION_TITLE = 'New Session';
@@ -102,7 +103,12 @@ async function generateSessionTitle(deps, sessionId, firstMessage, chatProvider,
             stream: true,
             system: TITLE_PROMPT,
         };
-        const text = await chatFn({ registry: llmRegistry }, request, { provider, model });
+        const fallback = buildFallbackChain(config, provider, model);
+        const text = await chatFn({ registry: llmRegistry }, request, {
+            provider,
+            model,
+            ...(fallback ? { fallback } : {}),
+        });
         const title = cleanTitle(text);
         if (title.length === 0)
             return;

package/dist/core/types.d.ts

@@ -9,6 +9,20 @@ import type { PermissionChecker, ToolRegistry } from '../tools/types.js';
 import type { AgentRegistry } from './agents/types.js';
 import type { Config } from './config.js';
 /** Runtime services injected into every core function (DI pattern). */
+/** 子 agent run 句柄：注册到宿主 run 跟踪器所需的最小信息。
+ *  deps 为子 agent 的 LoopDeps（cwd=隔离 worktree/父 cwd、深度注入等），
+ *  宿主据此执行 pause/resume/abort（与主 run 同口径）。 */
+type ChildRunHandle = {
+    sessionId: string;
+    /** 父会话 id——树级联（删除父中止全部后代、权限超时暂停主 run + 子 run）的依据。 */
+    parentSessionId?: string;
+    /** 后台任务 jobId（= 子会话 id，仅 background 模式）。 */
+    jobId?: string;
+    state: AgentState;
+    deps: AgentDependencies;
+};
+/** 注册子 agent run 到宿主 run 跟踪器；返回注销函数（幂等）。 */
+type RegisterChildRun = (run: ChildRunHandle) => () => void;
 type AgentDependencies = {
     db: DB;
     llmRegistry: Registry;
@@ -30,6 +44,11 @@ type AgentDependencies = {
     debugSpawn?: (config: unknown) => DebugTransport;
     /** Agent 类型注册表（spec: multi-agent-design）。注入后 task 工具可按类型派发。 */
     agentRegistry?: AgentRegistry;
+    /** 子 agent run 注册回调（P1：此前子 run 从未入宿主 run 跟踪器，暂停/热更新/
+     *  删除会话/权限超时级联全部绕过同步与后台子 agent）。宿主注入实现：
+     *  Web = agentManager.register/unregister；CLI 无 run 跟踪器，不注入即 no-op。
+     *  返回注销函数（幂等），子 agent run 终止时（finally）调用。 */
+    registerChildRun?: RegisterChildRun;
 };
 type ProjectInfo = {
     name: string;
@@ -90,6 +109,8 @@ type CommandContext = {
     /** 当前会话 id（Web chat 路由注入）：/clear /fork 等命令默认作用于当前会话。 */
     sessionId?: string;
     workflowRegistry?: import('./workflows/registry.js').WorkflowRegistry;
+    /** 消费渠道（P3）：/model 等命令按渠道给可操作指引（CLI 无底部模型选择器）。 */
+    channel?: 'web' | 'cli';
 };
 /** Declarative subcommand definition for commands like /workflow. */
 type SubcommandDef = {
@@ -106,4 +127,4 @@ type SlashCommand = {
     subcommands?: SubcommandDef[];
     execute: (args: string, ctx: CommandContext) => Promise<CommandResult>;
 };
-export type { AgentConfig, AgentDependencies, AgentError, AgentEvent, AgentState, AgentStatus, ChatTool, CommandContext, CommandResult, HookRunner, LLMSegment, PendingToolCall, ProjectInfo, PromptBuildContext, PromptContext, PromptRegistry, PromptSection, SlashCommand, SubcommandDef, TokenBudget, };
+export type { AgentConfig, AgentDependencies, AgentError, AgentEvent, AgentState, AgentStatus, ChatTool, ChildRunHandle, CommandContext, CommandResult, HookRunner, LLMSegment, PendingToolCall, ProjectInfo, PromptBuildContext, PromptContext, PromptRegistry, PromptSection, RegisterChildRun, SlashCommand, SubcommandDef, TokenBudget, };

package/dist/core/workflows/context.js

@@ -84,10 +84,47 @@ function buildWorkflowContext(opts) {
     };
 }
 // ── 工具函数 ──
-/** 递归 glob（简单实现，匹配文件名后缀或通配符）。 */
+/** 把 glob 模式编译为正则：双星号跨目录，单星号与问号不跨路径分隔符，其余字符转义。 */
+function globToRegExp(pattern) {
+    let re = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i] ?? '';
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // `**/` 须能匹配零层目录（globstar 语义：src/**/*.ts 命中 src/a.ts）
+                if (pattern[i + 2] === '/') {
+                    re += '(?:.*/)?';
+                    i += 2;
+                }
+                else {
+                    re += '.*';
+                    i++;
+                }
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (ch === '?') {
+            re += '[^/]';
+        }
+        else if (/[.+^${}()|[\]\\]/.test(ch)) {
+            re += `\\${ch}`;
+        }
+        else {
+            re += ch;
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+/**
+ * 递归 glob。模式含路径分隔符时按相对路径匹配（双星号跨目录，如「src 下任意层级的 .ts」）；
+ * 不含分隔符时按文件名匹配（与旧行为兼容：星号 .ts 命中任意层级）。
+ */
 async function globRecursive(rootDir, pattern) {
     const results = [];
-    const regex = new RegExp(pattern.replace(/\./g, '\\.').replace(/\*/g, '.*'));
+    const regex = globToRegExp(pattern);
+    const matchRel = pattern.includes('/');
     async function walk(dir) {
         let entries;
         try {
@@ -103,8 +140,11 @@ async function globRecursive(rootDir, pattern) {
             if (entry.isDirectory()) {
                 await walk(fullPath);
             }
-            else if (regex.test(entry.name)) {
-                results.push(relative(rootDir, fullPath));
+            else {
+                const rel = relative(rootDir, fullPath);
+                if (regex.test(matchRel ? rel : entry.name)) {
+                    results.push(rel);
+                }
             }
         }
     }

package/dist/core/workflows/discovery.d.ts

@@ -4,8 +4,8 @@ import type { WorkflowEntry, WorkflowMeta } from './types.js';
  */
 declare function discoverWorkflows(projectDir: string): Promise<WorkflowEntry[]>;
 /**
- * 扫描全局 `~/.c0de/workflows/*.js` 文件，source 标记为 'user'。
- * 目录不存在时返回空数组（与项目级一致）。
+ * 扫描全局工作流目录（默认 `~/.c0de/workflows/*.js`，C0DE_CONFIG_DIR 可重定向），
+ * source 标记为 'user'。目录不存在时返回空数组（与项目级一致）。
  */
 declare function discoverGlobalWorkflows(): Promise<WorkflowEntry[]>;
 /** saveWorkflow 的目标层级。 */