c0de-agent 1.12.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,17 +41,34 @@ 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: '列出可用斜杠命令',
     execute: async (_args, ctx) => {
         // 从 registry 动态生成，避免静态文案随命令增删漂移；
-        // 尊重 slashCommands.enabled 过滤（空 = 全部启用，与消费方语义一致）。
-        const enabledList = ctx.config.slashCommands?.enabled ?? [];
-        const enabledSet = new Set(enabledList.map((n) => (n.startsWith('/') ? n.slice(1) : n)));
+        // 尊重 slashCommands.enabled 过滤（含 ['*'] = 全部启用；空 = 全部禁用）。
+        const enabledList = ctx.config.slashCommands?.enabled;
         const commands = createSlashRegistry()
             .list()
-            .filter((c) => enabledSet.size === 0 || enabledSet.has(c.name));
+            .filter((c) => isSlashCommandEnabled(enabledList, c.name));
         const width = Math.max(...commands.map((c) => `/${c.name}`.length));
         const lines = ['可用命令：'];
         for (const cmd of commands) {
@@ -104,6 +139,12 @@ 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',
@@ -122,7 +163,7 @@ const clearCommand = {
         }
         return {
             _tag: 'success',
-            message: `已清空 ${ids.length} 条消息（原内容已归档，可在会话页「归档」面板查看）`,
+            message: `已清空 ${ids.length} 条消息（原内容已归档，可在会话页「归档」面板查看；历史 token/成本仍计入本会话用量统计）`,
         };
     },
 };
@@ -132,14 +173,14 @@ const forkCommand = {
     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;
             }
         }
@@ -149,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');
@@ -203,10 +250,29 @@ 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 ? '已取消设置' : '已设置'} ${key} (scope: project)`,
@@ -235,11 +301,29 @@ 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]));
@@ -286,20 +370,52 @@ 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: `无法读取文件：${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',
@@ -350,14 +466,28 @@ const workflowCommand = {
                     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,

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;
@@ -108,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 的目标层级。 */

package/dist/core/workflows/discovery.js

@@ -1,11 +1,9 @@
 import { mkdir, readdir, readFile, unlink, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { resolveGlobalConfigDir } from '../config.js';
 /** 项目级工作流目录相对路径。 */
 const PROJECT_WORKFLOWS_DIR = '.c0de/workflows';
-/** 用户级（全局）工作流目录：~/.c0de/workflows。 */
-const GLOBAL_WORKFLOWS_DIR = join('.c0de', 'workflows');
 /**
  * 扫描指定目录下的 `*.js` 工作流文件，dynamic import 后转为 WorkflowEntry。
  * import 失败的文件跳过（warn），不阻塞其他工作流加载。
@@ -60,11 +58,11 @@ async function discoverWorkflows(projectDir) {
     return discoverFromDir(join(projectDir, PROJECT_WORKFLOWS_DIR), 'project');
 }
 /**
- * 扫描全局 `~/.c0de/workflows/*.js` 文件，source 标记为 'user'。
- * 目录不存在时返回空数组（与项目级一致）。
+ * 扫描全局工作流目录（默认 `~/.c0de/workflows/*.js`，C0DE_CONFIG_DIR 可重定向），
+ * source 标记为 'user'。目录不存在时返回空数组（与项目级一致）。
  */
 async function discoverGlobalWorkflows() {
-    return discoverFromDir(join(homedir(), GLOBAL_WORKFLOWS_DIR), 'user');
+    return discoverFromDir(join(resolveGlobalConfigDir(), 'workflows'), 'user');
 }
 /** 合法工作流名称：仅小写字母、数字、连字符。 */
 const WORKFLOW_NAME_RE = /^[a-z0-9-]+$/;
@@ -82,7 +80,7 @@ async function saveWorkflow(name, source, target = 'project', projectDir) {
     }
     const dir = target === 'project'
         ? join(projectDir ?? '.', PROJECT_WORKFLOWS_DIR)
-        : join(homedir(), GLOBAL_WORKFLOWS_DIR);
+        : join(resolveGlobalConfigDir(), 'workflows');
     await mkdir(dir, { recursive: true });
     const filePath = join(dir, `${name}.js`);
     await writeFile(filePath, source, 'utf-8');

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

@@ -4,5 +4,6 @@ export type { SaveResult, SaveTarget } from './discovery.js';
 export { discoverGlobalWorkflows, discoverWorkflows, saveWorkflow } from './discovery.js';
 export type { WorkflowRegistry } from './registry.js';
 export { createAndPopulateRegistry, createWorkflowRegistry, reloadRegistry } from './registry.js';
-export { executeWorkflow } from './runtime.js';
+export { resolveWorkflow } from './resolve.js';
+export { executeWorkflow, workflowSessionTitle } from './runtime.js';
 export type { WorkflowAgentResult, WorkflowContext, WorkflowEntry, WorkflowMeta, WorkflowModule, WorkflowResult, WorkflowSource, WorkflowUtils, } from './types.js';

package/dist/core/workflows/index.js

@@ -2,4 +2,5 @@ export { BUILTIN_WORKFLOWS, createBuiltinWorkflows } from './builtins.js';
 export { buildWorkflowContext } from './context.js';
 export { discoverGlobalWorkflows, discoverWorkflows, saveWorkflow } from './discovery.js';
 export { createAndPopulateRegistry, createWorkflowRegistry, reloadRegistry } from './registry.js';
-export { executeWorkflow } from './runtime.js';
+export { resolveWorkflow } from './resolve.js';
+export { executeWorkflow, workflowSessionTitle } from './runtime.js';

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

@@ -10,18 +10,28 @@ declare function createWorkflowRegistry(): {
     clear(): void;
 };
 type WorkflowRegistry = ReturnType<typeof createWorkflowRegistry>;
+type RegistryPopulateOptions = {
+    /**
+     * 项目是否当前可信任（P0 信任边界）：false 时跳过项目级
+     * `.c0de/workflows/*.js` 发现（不 dynamic import 仓库代码）。
+     * 缺省为 false——调用方必须显式确认信任后才放行（fail-closed）。
+     * 内置与全局 `~/.c0de/workflows` 是用户本机显式安装，始终加载。
+     */
+    projectTrusted?: boolean;
+};
 /**
  * 创建并填充工作流注册表（三级发现，后注册覆盖同名）：
  *  1. 注册内置工作流（builtin）
  *  2. 发现并注册全局 `~/.c0de/workflows/*.js`（user）
- *  3. 发现并注册项目 `.c0de/workflows/*.js`（project）
+ *  3. 发现并注册项目 `.c0de/workflows/*.js`（project；仅 projectTrusted 时）
  * 覆盖优先级：project > user > builtin。
  */
-declare function createAndPopulateRegistry(projectDir: string): Promise<WorkflowRegistry>;
+declare function createAndPopulateRegistry(projectDir: string, opts?: RegistryPopulateOptions): Promise<WorkflowRegistry>;
 /**
  * 重新填充已有注册表：清空 → 三级发现 → 注册。
  * 用于 create/save 后热重载，保留同一 registry 引用。
+ * 项目级发现同样受 projectTrusted 门禁（fail-closed）。
  */
-declare function reloadRegistry(registry: WorkflowRegistry, projectDir: string): Promise<void>;
+declare function reloadRegistry(registry: WorkflowRegistry, projectDir: string, opts?: RegistryPopulateOptions): Promise<void>;
 export type { WorkflowRegistry };
 export { createAndPopulateRegistry, createWorkflowRegistry, reloadRegistry };

package/dist/core/workflows/registry.js

@@ -29,10 +29,10 @@ function createWorkflowRegistry() {
  * 创建并填充工作流注册表（三级发现，后注册覆盖同名）：
  *  1. 注册内置工作流（builtin）
  *  2. 发现并注册全局 `~/.c0de/workflows/*.js`（user）
- *  3. 发现并注册项目 `.c0de/workflows/*.js`（project）
+ *  3. 发现并注册项目 `.c0de/workflows/*.js`（project；仅 projectTrusted 时）
  * 覆盖优先级：project > user > builtin。
  */
-async function createAndPopulateRegistry(projectDir) {
+async function createAndPopulateRegistry(projectDir, opts = {}) {
     const registry = createWorkflowRegistry();
     // 1. 内置（由源码字符串动态导入生成，show === run）
     for (const wf of await createBuiltinWorkflows()) {
@@ -43,18 +43,21 @@ async function createAndPopulateRegistry(projectDir) {
     for (const wf of globalWorkflows) {
         registry.register(wf);
     }
-    // 3. 项目级（.c0de/workflows）
-    const projectWorkflows = await discoverWorkflows(projectDir);
-    for (const wf of projectWorkflows) {
-        registry.register(wf);
+    // 3. 项目级（.c0de/workflows）——未信任项目绝不 import（任意代码执行面）
+    if (opts.projectTrusted) {
+        const projectWorkflows = await discoverWorkflows(projectDir);
+        for (const wf of projectWorkflows) {
+            registry.register(wf);
+        }
     }
     return registry;
 }
 /**
  * 重新填充已有注册表：清空 → 三级发现 → 注册。
  * 用于 create/save 后热重载，保留同一 registry 引用。
+ * 项目级发现同样受 projectTrusted 门禁（fail-closed）。
  */
-async function reloadRegistry(registry, projectDir) {
+async function reloadRegistry(registry, projectDir, opts = {}) {
     registry.clear();
     for (const wf of await createBuiltinWorkflows()) {
         registry.register(wf);
@@ -62,8 +65,10 @@ async function reloadRegistry(registry, projectDir) {
     for (const wf of await discoverGlobalWorkflows()) {
         registry.register(wf);
     }
-    for (const wf of await discoverWorkflows(projectDir)) {
-        registry.register(wf);
+    if (opts.projectTrusted) {
+        for (const wf of await discoverWorkflows(projectDir)) {
+            registry.register(wf);
+        }
     }
 }
 export { createAndPopulateRegistry, createWorkflowRegistry, reloadRegistry };

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

@@ -0,0 +1,22 @@
+import type { WorkflowRegistry } from './registry.js';
+import type { WorkflowEntry } from './types.js';
+/**
+ * 统一工作流解析：按「项目（已信任）> 用户 > 内置」优先级查找同名工作流。
+ *
+ * 此前各消费方口径分裂：列表（GET /、/workflow list）项目级覆盖注册表，
+ * 而运行/查看（REST GET /:name、POST /:name/run、chat 斜杠、slash resolveEntry）
+ * 是注册表优先——项目级同名工作流被用户级/内置条目遮蔽，UI 显示项目版、
+ * 实际执行另一份。全部调用点必须经此函数收敛。
+ *
+ * 项目级发现受信任门禁：discoverWorkflows 会 dynamic import 仓库代码
+ * （模块顶层即刻执行），未信任/漂移的项目绝不发现（fail-closed，回退注册表）。
+ */
+declare function resolveWorkflow(opts: {
+    name: string;
+    registry?: WorkflowRegistry | null;
+    /** 项目目录（agent cwd / 项目 worktree）；缺省不发现项目级工作流。 */
+    projectDir?: string;
+    /** 项目当前是否可信（trustedAt + 指纹一致）。false/缺省 → 跳过项目级发现。 */
+    projectTrusted?: boolean;
+}): Promise<WorkflowEntry | undefined>;
+export { resolveWorkflow };

package/dist/core/workflows/resolve.js

@@ -0,0 +1,23 @@
+import { discoverWorkflows } from './discovery.js';
+/**
+ * 统一工作流解析：按「项目（已信任）> 用户 > 内置」优先级查找同名工作流。
+ *
+ * 此前各消费方口径分裂：列表（GET /、/workflow list）项目级覆盖注册表，
+ * 而运行/查看（REST GET /:name、POST /:name/run、chat 斜杠、slash resolveEntry）
+ * 是注册表优先——项目级同名工作流被用户级/内置条目遮蔽，UI 显示项目版、
+ * 实际执行另一份。全部调用点必须经此函数收敛。
+ *
+ * 项目级发现受信任门禁：discoverWorkflows 会 dynamic import 仓库代码
+ * （模块顶层即刻执行），未信任/漂移的项目绝不发现（fail-closed，回退注册表）。
+ */
+async function resolveWorkflow(opts) {
+    const { name, registry, projectDir, projectTrusted } = opts;
+    if (projectDir && projectTrusted) {
+        const discovered = await discoverWorkflows(projectDir);
+        const projectEntry = discovered.find((w) => w.meta.name === name);
+        if (projectEntry)
+            return projectEntry;
+    }
+    return registry?.get(name);
+}
+export { resolveWorkflow };

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

@@ -1,6 +1,11 @@
 import type { AgentDependencies, AgentState, CommandResult } from '../types.js';
 import type { WorkflowRegistry } from './registry.js';
 import type { WorkflowEntry } from './types.js';
+/**
+ * 工作流运行会话标题：`workflow:<name> MM-DD HH:mm`。
+ * 同名工作流多次运行在会话树里可区分，不再是无时间戳的同名行。
+ */
+declare function workflowSessionTitle(name: string, now?: Date): string;
 /** executeWorkflow 的参数。 */
 type ExecuteWorkflowOpts = {
     registry: WorkflowRegistry;
@@ -18,4 +23,4 @@ type ExecuteWorkflowOpts = {
  * 工作流 return 的 output 作为 text 返回；异常捕获为 error。
  */
 declare function executeWorkflow(opts: ExecuteWorkflowOpts): Promise<CommandResult>;
-export { executeWorkflow };
+export { executeWorkflow, workflowSessionTitle };

package/dist/core/workflows/runtime.js

@@ -14,6 +14,14 @@ function createTimeoutPromise(timeoutMs, timeoutSeconds) {
             timer.unref();
     });
 }
+/**
+ * 工作流运行会话标题：`workflow:<name> MM-DD HH:mm`。
+ * 同名工作流多次运行在会话树里可区分，不再是无时间戳的同名行。
+ */
+function workflowSessionTitle(name, now = new Date()) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `workflow:${name} ${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}`;
+}
 /**
  * 执行工作流：查注册表 → 构建 ctx → 调用 entry.execute → 返回 CommandResult。
  *
@@ -56,9 +64,18 @@ async function executeWorkflow(opts) {
     }
     catch (e) {
         if (e instanceof WorkflowTimeoutError) {
+            // 超时必须真正终止执行，而不是只对用户报错——此前仅 race reject，
+            // 工作流的子 agent 仍在后台继续调 LLM/改文件（继续计费且无中止手柄）。
+            // 与 abortAgent 同语义；内联实现避免 import 循环
+            // （agent.ts → loop.ts → prompt-registry.ts → slash.ts → workflows/index.ts → 本文件）。
+            // 父 abort 经 runSubAgent 的 abort 级联传递给全部子 agent。
+            parent.abortController.abort();
+            if (parent.status._tag === 'running' || parent.status._tag === 'paused') {
+                parent.status = { _tag: 'stopped', reason: 'aborted' };
+            }
             return {
                 _tag: 'error',
-                message: `Workflow "${name}" timed out after ${timeoutSeconds}s`,
+                message: `Workflow "${name}" timed out after ${timeoutSeconds}s（执行已中止）`,
             };
         }
         return {
@@ -67,4 +84,4 @@ async function executeWorkflow(opts) {
         };
     }
 }
-export { executeWorkflow };
+export { executeWorkflow, workflowSessionTitle };