c0de-agent 1.11.0 → 1.12.0

package/dist/core/loop/stream-collect.js

@@ -1,4 +1,5 @@
 import { isContextOverflowFailure } from '../../llm/provider-error.js';
+import { buildFallbackChain } from '../../llm/routing.js';
 import { isLLMError } from '../../llm/schema/errors.js';
 import { recoverFromOverflow } from './compaction.js';
 /** 入参是否为协议层/loop 标记的解析失败（携带 _parseError / _raw 容错标记）。
@@ -60,10 +61,17 @@ export async function* collectStreamChunks(state, deps, streamFn, request, overf
         ...over,
     });
     try {
+        // config.fallback 接线：enabled 时按配置重试参数 + 声明同模型的其他 provider 回退。
+        // 未启用时保持内置默认（3 次重试、无跨 provider 回退），行为与以往一致。
+        const fallback = buildFallbackChain(deps.config, state.config.provider, state.config.model);
         for await (const chunk of streamFn({
             registry: deps.llmRegistry,
             signal: state.abortController.signal,
-        }, request, { provider: state.config.provider, model: state.config.model })) {
+        }, request, {
+            provider: state.config.provider,
+            model: state.config.model,
+            ...(fallback ? { fallback } : {}),
+        })) {
             if (firstTokenTime === null && chunk._tag !== 'done') {
                 firstTokenTime = Date.now();
             }

package/dist/core/loop/subagent.js

@@ -1,5 +1,5 @@
 import { appendMessage } from '../../session/message.js';
-import { createSession } from '../../session/session.js';
+import { createSession, updateSessionLastRun } from '../../session/session.js';
 import { generateId } from '../../shared/index.js';
 import { createAgent, runAgent } from '../agent.js';
 import { applyPatchToParent, captureBaseline, captureDeltaPatch, createWorktree, removeWorktree, } from '../worktree.js';
@@ -35,10 +35,11 @@ export async function runSubAgent(deps, parent, request) {
         description: request.description ?? '',
         background: request.background ?? false,
     });
-    // 2. 创建子 session（记录 agentType）
+    // 2. 创建子 session（记录 agentType；parentId 挂到父会话——树内嵌套、
+    //    删除父会话时级联，不再是游离根节点）
     let childSession;
     try {
-        childSession = await createSession(deps.db, title, parent.session.projectId ?? undefined, request.agentType);
+        childSession = await createSession(deps.db, title, parent.session.projectId ?? undefined, request.agentType, parent.session.source ?? undefined, parent.session.id);
     }
     catch (e) {
         return { _tag: 'error', error: e instanceof Error ? e.message : String(e) };
@@ -147,13 +148,30 @@ export async function runSubAgent(deps, parent, request) {
     // 6. background 模式：fork 异步运行，立即返回 running；完成时向父 session 注入合成通知
     if (request.background) {
         const jobId = childSession.id;
+        // P2：落库 running 标记——进程崩溃后 markDeadBackgroundJobs 可识别悬空任务
+        // 并给父会话发失败通知（此前仅内存 jobId，重启即静默丢失）。
+        // 此写 await 完成再返回：保证「返回 running」时 DB 已记录；同时避免与
+        // 子 loop 的并发写入叠加。
+        await updateSessionLastRun(deps.db, childSession.id, {
+            status: 'running',
+            agentName: request.agentType,
+            startedAt: Date.now(),
+        }).catch(() => { });
         void runBody()
-            .then((result) => {
+            .then(async (result) => {
+            // 无论成败都置 completed：任务已终结，状态体现在合成通知里。
+            // 顺序 await（不并发发起）：PGLite WASM 对同实例并发查询会忙等，
+            // 与 appendMessage 并发叠加曾导致 100% CPU 自旋（loop.test.ts 复现）。
+            await updateSessionLastRun(deps.db, childSession.id, {
+                status: 'completed',
+                agentName: request.agentType,
+                startedAt: Date.now(),
+            }).catch(() => { });
             const success = result._tag === 'success';
             const output = success ? result.output : result.error;
             const tag = success ? 'task_result' : 'task_error';
             const synthetic = `<task id="${childSession.id}" state="${success ? 'completed' : 'failed'}">\n<${tag}>\n${output}\n</${tag}>\n</task>`;
-            void appendMessage(deps.db, parent.session.id, {
+            await appendMessage(deps.db, parent.session.id, {
                 role: 'user',
                 content: [{ _tag: 'text', text: synthetic }],
             }).catch((e) => {

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,23 +25,28 @@ function createSlashRegistry() {
 }
 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 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。
@@ -50,20 +55,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);
@@ -75,7 +107,7 @@ const clearCommand = {
         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,12 +120,15 @@ 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} 条消息（原内容已归档，可在会话页「归档」面板查看）`,
+        };
     },
 };
 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);
@@ -126,7 +161,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 +173,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) };
@@ -164,13 +209,13 @@ const configCommand = {
         await saveConfigScoped('project', ctx.cwd, next);
         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' },
@@ -201,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>           — 编辑工作流源码');
@@ -220,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 {
@@ -246,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) {
@@ -258,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') {
@@ -267,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}"` };
-            }
-            const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
-            try {
-                const { spawnSync } = await import('node:child_process');
-                spawnSync(editor, [wf.filePath], { stdio: 'inherit' });
+                return { _tag: 'error', message: `工作流 "${name}" 的文件路径不可用` };
             }
-            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];
@@ -305,7 +347,7 @@ const workflowCommand = {
                 ].join(', ');
                 return {
                     _tag: 'error',
-                    message: `Unknown workflow: "${name}". Available: ${available || '(none)'}`,
+                    message: `未知工作流："${name}"。可用：${available || '(无)'}`,
                 };
             }
             const agentConfig = {
@@ -328,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;

package/dist/core/types.d.ts

@@ -90,6 +90,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 = {

package/dist/db/schema.d.ts

@@ -307,6 +307,23 @@ export declare const sessions: import("drizzle-orm/pg-core").PgTableWithColumns<
             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

@@ -31,8 +31,10 @@ export const sessions = pgTable('sessions', {
     worktreePath: text('worktree_path'),
     /** 会话来源：'web'（Web UI）/ 'cli'（CLI print 模式）；null=旧数据视为 web。 */
     source: text('source').default(sql `null`),
-    /** 软删除时间戳；null=未删除。回收站保留 30 天后物理清除。 */
+    /** 软删除时间戳；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 };

package/dist/kanban/store.js

@@ -5,6 +5,13 @@ import { DEFAULT_KANBAN_COLUMNS } from '../shared/types/kanban.js';
 const DEFAULT_COLUMN_ID = 'todo';
 /** Position increment — large gap avoids frequent re-indexing on reorder. */
 const POSITION_GAP = 1000;
+/** 列内仍有卡片时禁止删除该列（否则卡片静默不可见）。 */
+class KanbanColumnInUseError extends Error {
+    constructor(columnNames, cardCount) {
+        super(`列 [${columnNames.join(', ')}] 中仍有 ${cardCount} 张卡片，无法删除。` +
+            '请先移动或删除这些卡片。');
+    }
+}
 // ── Row → API mappers ──────────────────────────────────────
 function rowToBoard(row) {
     return {
@@ -140,7 +147,39 @@ function createKanbanStore(handle, projectId) {
             await db.delete(kanbanCards).where(eq(kanbanCards.id, id));
         },
         async updateBoard(patch) {
-            await getOrCreateBoardId();
+            const boardId = await getOrCreateBoardId();
+            // P1-4：删除列前校验该列内是否有卡片；删除标签前把悬空 labelId 从卡片上清掉。
+            if (patch.columns !== undefined) {
+                const cards = await db
+                    .select({ columnId: kanbanCards.columnId })
+                    .from(kanbanCards)
+                    .where(eq(kanbanCards.boardId, boardId));
+                const newColumnIds = new Set(patch.columns.map((c) => c.id));
+                const removedWithCards = new Map();
+                for (const card of cards) {
+                    if (!newColumnIds.has(card.columnId)) {
+                        removedWithCards.set(card.columnId, (removedWithCards.get(card.columnId) ?? 0) + 1);
+                    }
+                }
+                if (removedWithCards.size > 0) {
+                    const total = Array.from(removedWithCards.values()).reduce((a, b) => a + b, 0);
+                    throw new KanbanColumnInUseError(Array.from(removedWithCards.keys()), total);
+                }
+            }
+            if (patch.labels !== undefined) {
+                const labelIds = new Set(patch.labels.map((l) => l.id));
+                const cards = await db
+                    .select({ id: kanbanCards.id, labels: kanbanCards.labels })
+                    .from(kanbanCards)
+                    .where(eq(kanbanCards.boardId, boardId));
+                for (const card of cards) {
+                    const current = (card.labels ?? []);
+                    const kept = current.filter((lid) => labelIds.has(lid));
+                    if (kept.length !== current.length) {
+                        await db.update(kanbanCards).set({ labels: kept }).where(eq(kanbanCards.id, card.id));
+                    }
+                }
+            }
             const [boardRow] = await db
                 .update(kanbanBoards)
                 .set({
@@ -153,6 +192,41 @@ function createKanbanStore(handle, projectId) {
             const row = boardRow;
             return rowToBoard(row);
         },
+        /** 整板替换（导入）：board 配置 + 卡片在单事务内重建；中途失败整体回滚，
+         *  不残留「配置已换、卡片半新半旧」的混合状态。 */
+        async replaceBoard(input) {
+            const boardId = await getOrCreateBoardId();
+            await db.transaction(async (tx) => {
+                await tx.delete(kanbanCards).where(eq(kanbanCards.boardId, boardId));
+                await tx
+                    .update(kanbanBoards)
+                    .set({ columns: input.columns, labels: input.labels, updatedAt: new Date() })
+                    .where(eq(kanbanBoards.id, boardId));
+                if (input.cards.length > 0) {
+                    await tx.insert(kanbanCards).values(input.cards.map((c) => ({
+                        boardId,
+                        title: c.title,
+                        description: c.description ?? null,
+                        columnId: c.columnId,
+                        priority: c.priority,
+                        position: c.position,
+                        labels: c.labels,
+                    })));
+                }
+            });
+            const boardRow = await db
+                .select()
+                .from(kanbanBoards)
+                .where(eq(kanbanBoards.id, boardId))
+                .limit(1);
+            const board = boardRow[0];
+            const cards = await db
+                .select()
+                .from(kanbanCards)
+                .where(eq(kanbanCards.boardId, boardId))
+                .orderBy(asc(kanbanCards.columnId), asc(kanbanCards.position));
+            return { ...rowToBoard(board), cards: cards.map(rowToCard) };
+        },
     };
 }
-export { createKanbanStore };
+export { createKanbanStore, KanbanColumnInUseError };

package/dist/llm/index.d.ts

@@ -8,6 +8,6 @@ export { builtinCapabilities, createRegistry, DEFAULT_MODEL_CAPABILITIES, overri
 export type { Retryable, RetryOptions } from './retry.js';
 export { delay, retryable, withRetry } from './retry.js';
 export type { FallbackChain } from './routing.js';
-export { runWithFallback, shouldFallOver } from './routing.js';
+export { buildFallbackChain, runWithFallback, shouldFallOver } from './routing.js';
 export * from './schema/index.js';
 export { estimateTokens } from './token.js';

package/dist/llm/index.js

@@ -3,6 +3,6 @@ export { buildInternalRequest, chat, chatStream, toInternalMessage, toStreamChun
 export { isContextOverflow, isContextOverflowFailure } from './provider-error.js';
 export { builtinCapabilities, createRegistry, DEFAULT_MODEL_CAPABILITIES, overrideToCapabilities, registerProvider, resolveModelByRole, resolveRoute, setRole, } from './registry.js';
 export { delay, retryable, withRetry } from './retry.js';
-export { runWithFallback, shouldFallOver } from './routing.js';
+export { buildFallbackChain, runWithFallback, shouldFallOver } from './routing.js';
 export * from './schema/index.js';
 export { estimateTokens } from './token.js';

package/dist/llm/provider.js

@@ -135,7 +135,7 @@ const streamTarget = async function* (ctx, request, target, chain) {
         headers: { authorization: `Bearer ${authHeader}`, ...resolved.route.headers() },
         signal: ctx.signal,
         fetchImpl: ctx.fetchImpl,
-    }), { maxRetries: chain.maxRetries, sleep: chain.sleep });
+    }), { maxRetries: chain.maxRetries, sleep: chain.sleep, initialDelayMs: chain.retryDelay });
     let state = initialStepState();
     for await (const frame of sseFraming(stream)) {
         const chunk = parseChunk(resolved.route.id, frame);