c0de-agent 1.10.0 → 1.12.0

package/dist/core/redact.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 敏感字段脱敏工具：/config 斜杠命令与 `c0de config get` 展示配置时使用，
+ * 防止 apiKey / token 等明文出现在聊天界面或终端输出中。
+ */
+export declare function isSecretKey(key: string): boolean;
+/** 掩码敏感值：短值整体掩码；长值保留首尾各 4 位。非字符串统一返回 ****。 */
+export declare function maskSecret(value: unknown): unknown;
+/** 递归脱敏：键名命中敏感模式的字段被掩码，其余结构原样保留。 */
+export declare function redactSecrets(value: unknown, key?: string): unknown;
+/** 判断对象树中是否含非空敏感值（用于「配置文件含密钥」类警告）。 */
+export declare function containsSecrets(value: unknown): boolean;

package/dist/core/redact.js

@@ -0,0 +1,49 @@
+/**
+ * 敏感字段脱敏工具：/config 斜杠命令与 `c0de config get` 展示配置时使用，
+ * 防止 apiKey / token 等明文出现在聊天界面或终端输出中。
+ */
+/** 敏感字段名模式（大小写不敏感，匹配完整键名）。 */
+const SECRET_KEY_RE = /(api[_-]?key|token|password|passwd|secret|authorization|auth[_-]?token)$/i;
+export function isSecretKey(key) {
+    return SECRET_KEY_RE.test(key);
+}
+/** 掩码敏感值：短值整体掩码；长值保留首尾各 4 位。非字符串统一返回 ****。 */
+export function maskSecret(value) {
+    if (typeof value !== 'string')
+        return '****';
+    if (value.length <= 8)
+        return '****';
+    return `${value.slice(0, 4)}****${value.slice(-4)}`;
+}
+/** 递归脱敏：键名命中敏感模式的字段被掩码，其余结构原样保留。 */
+export function redactSecrets(value, key) {
+    if (typeof key === 'string' && isSecretKey(key))
+        return maskSecret(value);
+    if (Array.isArray(value))
+        return value.map((v) => redactSecrets(v));
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = redactSecrets(v, k);
+        }
+        return out;
+    }
+    return value;
+}
+/** 判断对象树中是否含非空敏感值（用于「配置文件含密钥」类警告）。 */
+export function containsSecrets(value) {
+    if (Array.isArray(value))
+        return value.some((v) => containsSecrets(v));
+    if (value !== null && typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            if (isSecretKey(k)) {
+                if (typeof v === 'string' ? v.length > 0 : v != null)
+                    return true;
+                continue;
+            }
+            if (containsSecrets(v))
+                return true;
+        }
+    }
+    return false;
+}

package/dist/core/slash.js

@@ -25,24 +25,28 @@ function createSlashRegistry() {
 }
 const helpCommand = {
     name: 'help',
-    description: 'List available slash commands',
-    execute: async () => {
-        const lines = [
-            'Available commands:',
-            '  /compact        Manually trigger context compaction',
-            '  /model <name>   Switch the current session model',
-            '  /clear          Clear session messages',
-            '  /help           Show this help',
-            '  /fork [index]   Fork session from a message',
-            '  /config [k][v]  View or set configuration',
-            '  /workflow       Manage and run workflows',
-        ];
+    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)));
+        const commands = createSlashRegistry()
+            .list()
+            .filter((c) => enabledSet.size === 0 || enabledSet.has(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。
@@ -51,64 +55,167 @@ const compactCommand = {
 };
 const modelCommand = {
     name: 'model',
-    description: 'Switch the current session model',
-    argsHint: '<model-name>',
-    execute: async (args) => {
-        if (!args)
-            return { _tag: 'error', message: 'Usage: /model <model-name>' };
-        return { _tag: 'success', message: `Model set to ${args} (takes effect next turn)` };
+    description: '查看当前会话使用的模型',
+    argsHint: '',
+    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: `${sessionModel ? `当前会话模型：${sessionModel}` : `默认模型：${ctx.config.defaultModel}（provider: ${ctx.config.defaultProvider}）`}\n` +
+                '切换模型请使用聊天页底部的模型选择器。',
+        };
     },
 };
 const clearCommand = {
     name: 'clear',
-    description: 'Clear session messages',
+    description: '清空会话消息（先归档原始内容）',
+    argsHint: '[session-id] [--yes]',
     execute: async (args, ctx) => {
-        if (!args)
-            return { _tag: 'error', message: 'Usage: /clear <session-id>' };
-        const { deleteEntriesByIds, getEntries } = await import('../session/message.js');
-        const entries = await getEntries(ctx.deps.db, args);
+        const parts = args.split(/\s+/).filter(Boolean);
+        const yes = parts.includes('--yes');
+        const sessionId = parts.find((p) => p !== '--yes') ?? ctx.sessionId;
+        if (!sessionId) {
+            return { _tag: 'error', message: 'Usage: /clear [session-id] --yes（当前会话可省略 id）' };
+        }
+        if (!yes) {
+            return {
+                _tag: 'error',
+                message: '清空消息不可逆。原始消息将归档到「会话归档」面板（会话页顶部「归档」按钮可查看/搜索），确认请执行 /clear --yes（或 /clear <session-id> --yes）。',
+            };
+        }
+        const { getEntries, deleteEntriesByIds } = await import('../session/message.js');
+        const entries = await getEntries(ctx.deps.db, sessionId);
         const ids = entries.map((e) => ('id' in e ? e.id : '')).filter(Boolean);
         if (ids.length > 0) {
+            // 归档原始内容（与 shake 同机制），删除才有后悔路径
+            const { archiveOriginalEntries } = await import('../session/archive.js');
+            const { generateId } = await import('../shared/index.js');
+            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` };
+        return {
+            _tag: 'success',
+            message: `已清空 ${ids.length} 条消息（原内容已归档，可在会话页「归档」面板查看）`,
+        };
     },
 };
 const forkCommand = {
     name: 'fork',
-    description: 'Fork session from a message index',
-    argsHint: '<session-id> [message-index]',
+    description: '从指定消息处分支会话',
+    argsHint: '[session-id] [message-index]',
     execute: async (args, ctx) => {
-        if (!args)
-            return { _tag: 'error', message: 'Usage: /fork <session-id> [message-index]' };
-        const parts = args.split(/\s+/);
-        const sessionId = parts[0] ?? '';
-        const messageIndex = parts[1] !== undefined ? Number.parseInt(parts[1], 10) : 0;
+        const parts = args.split(/\s+/).filter(Boolean);
+        // 默认当前会话；第一个参数若是 session id（非纯数字）则用它。
+        let sessionId = ctx.sessionId;
+        let messageIndex;
+        for (const p of parts) {
+            if (/^\d+$/.test(p)) {
+                messageIndex = Number.parseInt(p, 10);
+            }
+            else if (!sessionId) {
+                sessionId = p;
+            }
+        }
+        if (!sessionId) {
+            return {
+                _tag: 'error',
+                message: 'Usage: /fork [session-id] [message-index]（当前会话可省略 id）',
+            };
+        }
+        // 未指定 index → 默认最新一条消息处分支（与 web fork API 语义一致，不再是 index 0）
+        if (messageIndex === undefined) {
+            const { getMessages } = await import('../session/message.js');
+            const messages = await getMessages(ctx.deps.db, sessionId);
+            if (messages.length === 0) {
+                return { _tag: 'error', message: 'EMPTY_SESSION: 空会话无法分支' };
+            }
+            messageIndex = messages.length - 1;
+        }
         const { forkSession } = await import('../session/branch.js');
-        const forked = await forkSession(ctx.deps.db, sessionId, messageIndex);
-        return { _tag: 'success', message: `Forked to new session: ${forked.id}` };
+        try {
+            const forked = await forkSession(ctx.deps.db, sessionId, messageIndex);
+            return { _tag: 'success', message: `已分支到新会话：${forked.id}` };
+        }
+        catch (error) {
+            return {
+                _tag: 'error',
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
     },
 };
 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) {
-            const value = ctx.config[key];
-            return { _tag: 'text', text: `${key}: ${JSON.stringify(value)}` };
+            try {
+                // 用点路径末段作为键名参与脱敏判定：/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) };
+            }
         }
-        return { _tag: 'success', message: 'Config updates are handled via the config API' };
+        // 点路径写值：与 CLI config set 同语义（project 作用域最小落盘，null=unset）
+        const { applyScopedPatch, loadConfigScopes, saveConfigScoped } = await import('./config.js');
+        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);
+        return {
+            _tag: 'success',
+            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' },
@@ -139,13 +246,13 @@ const workflowCommand = {
             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>           — 编辑工作流源码');
@@ -158,7 +265,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 {
@@ -184,7 +291,7 @@ const workflowCommand = {
                 source = await import('node:fs/promises').then((fs) => fs.readFile(filePath, 'utf-8'));
             }
             catch {
-                return { _tag: 'error', message: `Cannot read file: ${filePath}` };
+                return { _tag: 'error', message: `无法读取文件：${filePath}` };
             }
             const result = await saveWorkflow(name, source, 'project', ctx.cwd);
             if (!result.ok) {
@@ -196,7 +303,7 @@ const workflowCommand = {
             }
             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') {
@@ -205,30 +312,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}"` };
+                return { _tag: 'error', message: `工作流 "${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: '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];
@@ -243,7 +347,7 @@ const workflowCommand = {
                 ].join(', ');
                 return {
                     _tag: 'error',
-                    message: `Unknown workflow: "${name}". Available: ${available || '(none)'}`,
+                    message: `未知工作流："${name}"。可用：${available || '(无)'}`,
                 };
             }
             const agentConfig = {
@@ -266,7 +370,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;
@@ -111,6 +117,21 @@ async function generateSessionTitle(deps, sessionId, firstMessage, chatProvider,
     catch (e) {
         // 标题生成是尽力而为的辅助功能：失败不阻塞主对话流，但记录以便排查。
         console.warn('[title] generateSessionTitle failed:', e instanceof Error ? e.message : String(e));
+        // P2-12：失败时回退到首条消息摘要，避免列表出现大量同名 "New Session"。
+        await fallbackTitleFromMessage(db, sessionId, firstMessage);
     }
 }
+/** 从首条消息生成回退标题：取首个非空行，超长截断（与 cleanTitle 一致）。 */
+async function fallbackTitleFromMessage(db, sessionId, firstMessage) {
+    const firstLine = firstMessage
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => l.length > 0);
+    if (!firstLine)
+        return;
+    const title = firstLine.length > TITLE_MAX_LENGTH
+        ? `${firstLine.slice(0, TITLE_MAX_LENGTH - 3)}...`
+        : firstLine;
+    await updateSessionTitle(db, sessionId, title).catch(() => { });
+}
 export { DEFAULT_SESSION_TITLE, generateSessionTitle, isDefaultTitle };

package/dist/core/types.d.ts

@@ -87,7 +87,11 @@ type CommandContext = {
     cwd: string;
     config: Config;
     deps: AgentDependencies;
+    /** 当前会话 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 = {

package/dist/db/client.d.ts

@@ -5,10 +5,14 @@ import type { DBConfig } from './types.js';
  * Unified database handle.
  * `db` is the Drizzle ORM instance with schema bound.
  * `close()` cleans up the connection.
+ * `sync()` (PGLite only) flushes WAL to filesystem — periodic call 缩短
+ * 突然停机（kill -9）时的数据丢失窗口，是 WAL 之外的额外保险。
  */
 type DB = {
     db: PgliteDatabase<typeof schema>;
     close(): Promise<void>;
+    /** PGLite：syncToFs(false) 全量刷盘；PostgreSQL 模式下为 no-op（服务端自行管理）。 */
+    sync?(): Promise<void>;
 };
 /**
  * Create a database connection.

package/dist/db/client.js

@@ -23,6 +23,11 @@ async function createDB(config) {
             async close() {
                 await client.close();
             },
+            async sync() {
+                // P2-15：主动把 WAL 刷到文件系统（默认非 relaxedDurability 全量 fsync），
+                // 使 kill -9 等非优雅退出时已提交事务不丢。失败吞掉（尽力而为）。
+                await client.syncToFs().catch(() => { });
+            },
         };
     }
     // PostgreSQL mode — cast to PgliteDatabase for a unified interface.

package/dist/db/schema.d.ts

@@ -273,6 +273,57 @@ export declare const sessions: import("drizzle-orm/pg-core").PgTableWithColumns<
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deletedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deleted_at";
+            tableName: "sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deletedBatchId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deleted_batch_id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
             tableName: "sessions";

package/dist/db/schema.js

@@ -29,6 +29,12 @@ export const sessions = pgTable('sessions', {
     metadata: jsonb('metadata').notNull().default({}),
     agentType: text('agent_type'),
     worktreePath: text('worktree_path'),
+    /** 会话来源：'web'（Web UI）/ 'cli'（CLI print 模式）；null=旧数据视为 web。 */
+    source: text('source').default(sql `null`),
+    /** 软删除时间戳；null=未删除。回收站保留 60 天后物理清除。 */
+    deletedAt: timestamp('deleted_at', { withTimezone: true }).default(sql `null`),
+    /** 删除级联批次号：同一次 softDeleteSession 的父+后代共享；恢复时仅还原同批次后代。 */
+    deletedBatchId: uuid('deleted_batch_id'),
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
 }, (table) => [

package/dist/kanban/index.d.ts

@@ -1 +1 @@
-export { createKanbanStore } from './store.js';
+export { createKanbanStore, KanbanColumnInUseError } from './store.js';

package/dist/kanban/index.js

@@ -1 +1 @@
-export { createKanbanStore } from './store.js';
+export { createKanbanStore, KanbanColumnInUseError } from './store.js';

package/dist/kanban/store.d.ts

@@ -1,8 +1,12 @@
 import type { DB } from '../db/client.js';
 import type { KanbanStore } from '../shared/types/kanban.js';
+/** 列内仍有卡片时禁止删除该列（否则卡片静默不可见）。 */
+declare class KanbanColumnInUseError extends Error {
+    constructor(columnNames: string[], cardCount: number);
+}
 /**
  * Create a project-scoped KanbanStore backed by the given db handle.
  * The board is created on first access (lazy) with the default 5 columns.
  */
 declare function createKanbanStore(handle: DB, projectId: string): KanbanStore;
-export { createKanbanStore };
+export { createKanbanStore, KanbanColumnInUseError };