c0de-agent 1.10.0 → 1.12.0

package/dist/cli/index.js

@@ -6,11 +6,13 @@ import { loadConfig } from '../core/config.js';
 import { createDB, migrateDB } from '../db/index.js';
 import { acquireDevDbLock, releaseDevDbLock, resolveDbDir } from '../server/server.js';
 import { runAcpCommand } from './commands/acp.js';
+import { runAuthCommand } from './commands/auth.js';
 import { runChatCommand } from './commands/chat.js';
 import { runConfigCommand } from './commands/config.js';
 import { runInitCommand } from './commands/init.js';
 import { runPluginCommand } from './commands/plugin.js';
 import { runServeCommand } from './commands/serve.js';
+import { runSessionsCommand } from './commands/sessions.js';
 import { runUpdateCommand } from './commands/update.js';
 import { buildAgentDeps } from './deps.js';
 import { parseCommand } from './parser.js';
@@ -23,6 +25,9 @@ const COMMANDS = [
             { name: 'format', type: 'string' },
             { name: 'yes', type: 'boolean', short: 'y' },
             { name: 'continue', type: 'string' },
+            // P2 修复：serve 运行时持久库被占用，此前静默退化为内存库（会话不保存，
+            // 仅 stderr 一行提示极易错过）。现须显式 --temp 才允许临时模式。
+            { name: 'temp', type: 'boolean' },
         ],
     },
     {
@@ -50,10 +55,23 @@ const COMMANDS = [
         description: 'List or enable plugins.',
         options: [],
     },
+    {
+        name: 'auth',
+        description: 'Manage authorized devices (list / revoke / reset).',
+        options: [],
+    },
+    {
+        name: 'sessions',
+        description: 'Manage CLI/web sessions (list / delete / restore / deleted).',
+        options: [{ name: 'project', type: 'string' }],
+    },
     {
         name: 'acp',
         description: 'Run in Agent Client Protocol mode (editor integration).',
-        options: [],
+        options: [
+            // serve 占用持久库时的显式临时模式开关（与 chat --temp 同语义）。
+            { name: 'temp', type: 'boolean' },
+        ],
     },
     {
         name: 'update',
@@ -96,11 +114,23 @@ async function withAgentDeps(cwd, opts, fn) {
         holdLock = false;
         if (!isDbLockConflict(err))
             throw err;
+        if (opts.requirePersistent) {
+            throw new Error('c0de serve 正在运行并占用会话库，CLI 会话管理暂不可用（单写者限制）。\n' +
+                '  1) 在 Web 界面管理会话；\n' +
+                '  2) 或停止 serve（Ctrl+C）后重试本命令。');
+        }
         if (opts.continueSessionId) {
             throw new Error(`无法续聊会话 ${opts.continueSessionId}：持久库被 c0de serve 占用，内存模式无法续聊。\n` +
                 `请停止 serve 后重试，或去掉 --continue 开启新会话。`);
         }
-        process.stderr.write('[c0de] c0de serve 正在运行，本次会话不持久化（内存模式）\n');
+        if (!opts.allowTemp) {
+            // P2 修复：锁冲突不再静默降级为不保存会话的内存模式（用户极易错过 stderr
+            // 提示导致对话丢失）。必须显式 --temp 确认放弃持久化。
+            throw new Error('c0de serve 正在运行并占用会话库，本次对话将无法保存。\n' +
+                '  1) 停止 serve 后重试（对话可持久化，推荐）；\n' +
+                '  2) 或加 --temp 显式接受临时模式（消息与工具调用不会保存）。');
+        }
+        process.stderr.write('[c0de] ⚠ 临时模式：消息与工具调用不会保存。停止 serve 后重试可持久化，或直接使用浏览器界面。\n');
         db = await createDB({ driver: 'pglite' });
         await migrateDB(db);
     }
@@ -139,7 +169,12 @@ async function dispatch(argv, overrides = {}) {
             // --yes / -y 显式放行写操作；否则按 config.permission.defaultMode 决定（默认 safe）。
             const strategy = args.options.yes ? 'full-auto' : undefined;
             const continueId = args.options.continue;
-            await withAgentDeps(cwd, { ...(strategy ? { strategy } : {}), ...(continueId ? { continueSessionId: continueId } : {}) }, (config, deps) => runChatCommand({ args, config, deps }));
+            const allowTemp = args.options.temp === true;
+            await withAgentDeps(cwd, {
+                ...(strategy ? { strategy } : {}),
+                ...(continueId ? { continueSessionId: continueId } : {}),
+                ...(allowTemp ? { allowTemp } : {}),
+            }, (config, deps) => runChatCommand({ args, config, deps }));
             return;
         }
         case 'init': {
@@ -154,9 +189,21 @@ async function dispatch(argv, overrides = {}) {
             await runPluginCommand({ args, cwd });
             return;
         }
+        case 'auth': {
+            await runAuthCommand({ args });
+            return;
+        }
+        case 'sessions': {
+            // 需要持久库列出/清理会话；serve 运行时内存库不含数据，直接失败而不是列空表。
+            await withAgentDeps(cwd, { requirePersistent: true }, (_config, deps) => runSessionsCommand({ args, db: deps.db }));
+            return;
+        }
         case 'acp': {
             // ACP 非交互：所有工具放行（编辑器侧自行控制执行授权）。
-            await withAgentDeps(cwd, { strategy: 'full-auto' }, (config, deps) => runAcpCommand({ config, deps }));
+            await withAgentDeps(cwd, {
+                strategy: 'full-auto',
+                ...(args.options.temp === true ? { allowTemp: true } : {}),
+            }, (config, deps) => runAcpCommand({ config, deps }));
             return;
         }
         case 'update': {

package/dist/cli/modes/print.js

@@ -1,5 +1,6 @@
 import { createAgent, runAgent } from '../../core/agent.js';
-import { createSession, getSession } from '../../session/session.js';
+import { resolveRoute } from '../../llm/registry.js';
+import { createSession, getSession, upgradeTemporarySession } from '../../session/session.js';
 import { resolveEnabledToolNames } from '../../tools/index.js';
 /** 从事件流累积 assistant 文本。纯函数。 */
 function collectAssistantText(events) {
@@ -23,10 +24,17 @@ async function runPrintMode(config, message, deps, opts = {}) {
         const existing = await getSession(deps.db, opts.sessionId);
         if (!existing)
             throw new Error(`session not found: ${opts.sessionId}`);
+        // 续接即升级为持久会话：30 天临时清理不再触及（P1：此前 --continue 的
+        // 会话同样会在 30 天不活动后被物理删除，用户显式续接的历史静默丢失）。
+        if (existing.agentType === 'print') {
+            await upgradeTemporarySession(deps.db, opts.sessionId);
+        }
         session = existing;
     }
     else {
-        session = await createSession(deps.db, 'cli-print');
+        // agentType='print'：一次性 print 会话标记。purgeTemporarySessions 仅清理
+        // print/workflow 会话；普通 CLI 会话（ACP 等）与 --continue 续接的历史永不误删。
+        session = await createSession(deps.db, 'cli-print', undefined, 'print', 'cli');
     }
     const agentConfig = {
         provider: config.defaultProvider,
@@ -36,6 +44,15 @@ async function runPrintMode(config, message, deps, opts = {}) {
         plugins: config.plugins.enabled,
         ...(opts.maxTokens !== undefined ? { maxTokens: opts.maxTokens } : {}),
     };
+    // P3：首跑友好报错——未配置 provider 时不再让底层 NoRoute 异常裸抛，
+    // 给出与 Web 端一致的引导（c0de serve → 设置 → Provider）。
+    try {
+        resolveRoute(deps.llmRegistry, agentConfig.provider, agentConfig.model);
+    }
+    catch {
+        throw new Error('未配置可用的 AI 服务。请运行 `c0de serve` 并在「设置 → Provider」中添加 API 服务并测试连接，' +
+            '或使用 `c0de config set` 配置 providers。');
+    }
     const state = await createAgent(session, agentConfig, deps);
     const events = [];
     for await (const event of runAgent(state, [{ _tag: 'text', text: message }], deps)) {

package/dist/core/compact.d.ts

@@ -1,10 +1,12 @@
 import type { DB } from '../db/client.js';
 import type { Registry } from '../llm/registry.js';
+import type { FallbackChain } from '../llm/routing.js';
 import type { CompactionConfig, CompactionResult, Summarizer } from '../session/types.js';
 /** Create a Summarizer backed by an LLM streaming call. */
 declare function createSummarizer(registry: Registry, provider: string, model: string, opts?: {
     maxTokens?: number;
     signal?: AbortSignal;
+    fallback?: FallbackChain;
 }): Summarizer;
 /** Run compaction on a session using the provided summarizer. */
 declare function runCompaction(db: DB, sessionId: string, summarizer: Summarizer, config?: Partial<CompactionConfig>): Promise<CompactionResult>;

package/dist/core/compact.js

@@ -13,6 +13,7 @@ function createSummarizer(registry, provider, model, opts) {
         for await (const chunk of chatStream({ registry, signal: opts?.signal }, request, {
             provider,
             model,
+            ...(opts?.fallback ? { fallback: opts.fallback } : {}),
         })) {
             if (chunk._tag === 'text') {
                 chunks.push(chunk);

package/dist/core/config-path.d.ts

@@ -0,0 +1,9 @@
+/** 按 a.b.c 点路径从对象取值；找不到抛错。 */
+declare function getByPath(obj: unknown, path: string): unknown;
+/** 按 a.b.c 点路径写值（创建中间对象）。 */
+declare function setByPath(obj: Record<string, unknown>, path: string, value: unknown): void;
+/** 把字符串解析为合适的标量类型。 */
+declare function coerce(value: string): unknown;
+/** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
+declare function setPathPatch(path: string, value: unknown): Record<string, unknown>;
+export { coerce, getByPath, setByPath, setPathPatch };

package/dist/core/config-path.js

@@ -0,0 +1,48 @@
+// 配置点路径（a.b.c）读写工具：CLI `config set/get` 与斜杠 `/config` 共用。
+/** 按 a.b.c 点路径从对象取值；找不到抛错。 */
+function getByPath(obj, path) {
+    const parts = path.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== 'object')
+            throw new Error(`config: key "${path}" not found`);
+        cur = cur[p];
+        if (cur === undefined)
+            throw new Error(`config: key "${path}" not found`);
+    }
+    return cur;
+}
+/** 按 a.b.c 点路径写值（创建中间对象）。 */
+function setByPath(obj, path, value) {
+    const parts = path.split('.');
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const k = parts[i];
+        const next = cur[k];
+        cur[k] = (next !== null && typeof next === 'object' ? next : {});
+        cur = cur[k];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+/** 把字符串解析为合适的标量类型。 */
+function coerce(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^-?\d+(\.\d+)?$/.test(value))
+        return Number(value);
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+/** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
+function setPathPatch(path, value) {
+    const root = {};
+    setByPath(root, path, value);
+    return root;
+}
+export { coerce, getByPath, setByPath, setPathPatch };

package/dist/core/config.d.ts

@@ -10,15 +10,32 @@ declare function loadConfigScopes(projectDir?: string): {
     global: Partial<Config> | undefined;
     project: Partial<Config> | undefined;
 };
+/**
+ * 把 patch 应用到某个作用域的原始配置（scoped patch，null=删除）：
+ * - 深合并：嵌套普通对象递归合并，数组整体替换（providers 等列表语义）；
+ * - 值为 undefined 的键跳过；
+ * - 值为 null 的键从结果中**删除**——作用域内取消覆盖，回落到另一作用域/默认值。
+ *   Config 各字段均无合法的 null 值（可选字段用 undefined），null 作为「unset」标记是安全的。
+ * 不注入默认值。CLI config set / 服务端 PATCH /api/config 共用。
+ */
+declare function applyScopedPatch(base: Record<string, unknown> | undefined, patch: Record<string, unknown>): Record<string, unknown>;
 /**
  * 不注入默认值的深合并：仅合并传入对象的自有键。
  * 数组整体替换（providers 等列表语义）；嵌套普通对象递归合并。
  * 用于「patch 合并进某个作用域的原始文件」后再写盘。
  */
 declare function mergeRaw(...cfgs: (Record<string, unknown> | undefined)[]): Record<string, unknown>;
-/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。 */
+/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。
+ *  - 落盘前对 providers[].apiKey 加密（已带 enc: 前缀/空值透传）——
+ *    CLI config set 与 /config 斜杠命令共用此路径，保证「apiKey 不明文落盘」全链路成立。
+ *  - 写入后 chmod 600：配置文件可能含 token/加密密钥，默认 0644 同机可读。 */
 declare function saveConfigScoped(scope: 'global' | 'project', projectDir: string | undefined, data: Record<string, unknown>): Promise<void>;
 declare function loadConfig(projectDir?: string): Promise<Config>;
-declare function saveConfig(config: Config, scope: 'global' | 'project', projectDir?: string): Promise<void>;
+/** Config 全部顶层键（DEFAULT_CONFIG + 可选键）。未知顶层键校验与告警共用。 */
+declare const KNOWN_CONFIG_KEYS: Set<string>;
+/** 收集对象中不属于 Config 顶层键的未知键。 */
+declare function collectUnknownConfigKeys(data: Record<string, unknown> | undefined): string[];
+/** 加载配置时对未知顶层键告警（拼写错误/旧版键静默失效的唯一提示）。 */
+declare function warnUnknownConfigKeys(scope: 'global' | 'project', data: Record<string, unknown> | undefined): void;
 export type { AgentsConfig, CompactionConfig, Config, MCPServerConfig, PermissionConfig, SecurityConfig, ToolMetricsConfig, UpdateConfig, WebSearchConfig, };
-export { DEFAULT_CONFIG, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfig, saveConfigScoped, };
+export { applyScopedPatch, collectUnknownConfigKeys, DEFAULT_CONFIG, KNOWN_CONFIG_KEYS, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped, warnUnknownConfigKeys, };

package/dist/core/config.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { encryptSecret, isEncryptedSecret } from './secret.js';
 const GLOBAL_CONFIG_DIR = '.c0de';
 const CONFIG_FILENAME = 'config.json';
 const DEFAULT_CONFIG = {
@@ -21,7 +22,9 @@ const DEFAULT_CONFIG = {
     tools: { enabled: [], disabled: [] },
     plugins: { enabled: [] },
     mcpServers: [],
-    slashCommands: { enabled: ['/compact', '/model', '/clear', '/help', '/fork', '/config'] },
+    slashCommands: {
+        enabled: ['/compact', '/model', '/clear', '/help', '/fork', '/config', '/workflow'],
+    },
     toolMetrics: { enabled: true, threshold: 0.8, minSamples: 5 },
     security: { authEnabled: true, allowedOrigins: [] },
     websearch: { provider: 'auto' },
@@ -29,7 +32,6 @@ const DEFAULT_CONFIG = {
     permission: { defaultMode: 'default' },
     update: { enabled: true, intervalMs: 60 * 60 * 1000, initialDelayMs: 10_000 },
     theme: 'system',
-    locale: 'en',
 };
 function mergeConfig(...configs) {
     const result = structuredClone(DEFAULT_CONFIG);
@@ -78,6 +80,37 @@ function loadConfigScopes(projectDir) {
     const projectPath = join(projectDir ?? process.cwd(), '.c0de', CONFIG_FILENAME);
     return { global: readJsonIfExists(globalPath), project: readJsonIfExists(projectPath) };
 }
+/**
+ * 把 patch 应用到某个作用域的原始配置（scoped patch，null=删除）：
+ * - 深合并：嵌套普通对象递归合并，数组整体替换（providers 等列表语义）；
+ * - 值为 undefined 的键跳过；
+ * - 值为 null 的键从结果中**删除**——作用域内取消覆盖，回落到另一作用域/默认值。
+ *   Config 各字段均无合法的 null 值（可选字段用 undefined），null 作为「unset」标记是安全的。
+ * 不注入默认值。CLI config set / 服务端 PATCH /api/config 共用。
+ */
+function applyScopedPatch(base, patch) {
+    const result = { ...(base ?? {}) };
+    for (const [key, val] of Object.entries(patch)) {
+        if (val === undefined)
+            continue;
+        if (val === null) {
+            delete result[key];
+            continue;
+        }
+        const current = result[key];
+        if (typeof val === 'object' &&
+            !Array.isArray(val) &&
+            current !== null &&
+            typeof current === 'object' &&
+            !Array.isArray(current)) {
+            result[key] = applyScopedPatch(current, val);
+        }
+        else {
+            result[key] = val;
+        }
+    }
+    return result;
+}
 /**
  * 不注入默认值的深合并：仅合并传入对象的自有键。
  * 数组整体替换（providers 等列表语义）；嵌套普通对象递归合并。
@@ -107,7 +140,10 @@ function mergeRaw(...cfgs) {
     }
     return result;
 }
-/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。 */
+/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。
+ *  - 落盘前对 providers[].apiKey 加密（已带 enc: 前缀/空值透传）——
+ *    CLI config set 与 /config 斜杠命令共用此路径，保证「apiKey 不明文落盘」全链路成立。
+ *  - 写入后 chmod 600：配置文件可能含 token/加密密钥，默认 0644 同机可读。 */
 async function saveConfigScoped(scope, projectDir, data) {
     const dir = scope === 'global'
         ? join(homedir(), GLOBAL_CONFIG_DIR)
@@ -115,22 +151,75 @@ async function saveConfigScoped(scope, projectDir, data) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     const path = join(dir, CONFIG_FILENAME);
-    writeFileSync(path, JSON.stringify(data, null, 2), 'utf-8');
+    const hardened = redactSensitiveOnSave(data);
+    writeFileSync(path, JSON.stringify(hardened, null, 2), 'utf-8');
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // 平台不支持（Windows 等）时忽略；内容仍已加密。
+    }
+}
+/** 落盘前的敏感值处理：providers[].apiKey 与 websearch 后端 key 明文 → enc: 加密
+ *  （spec §24.2；此前 websearch.tavilyApiKey/braveApiKey 明文落盘，与 provider
+ *  apiKey 安全叙事不一致——git 误提交警告会命中它们，加密却不会）。 */
+function redactSensitiveOnSave(data) {
+    const out = {};
+    for (const [key, val] of Object.entries(data)) {
+        if (key === 'providers' && Array.isArray(val)) {
+            out[key] = val.map((p) => {
+                if (p === null || typeof p !== 'object')
+                    return p;
+                const apiKey = p.apiKey;
+                if (typeof apiKey === 'string' && apiKey.length > 0 && !isEncryptedSecret(apiKey)) {
+                    return { ...p, apiKey: encryptSecret(apiKey) };
+                }
+                return p;
+            });
+            continue;
+        }
+        if (key === 'websearch' && val !== null && typeof val === 'object') {
+            const ws = { ...val };
+            for (const k of ['tavilyApiKey', 'braveApiKey']) {
+                const v = ws[k];
+                if (typeof v === 'string' && v.length > 0 && !isEncryptedSecret(v)) {
+                    ws[k] = encryptSecret(v);
+                }
+            }
+            out[key] = ws;
+            continue;
+        }
+        out[key] = val;
+    }
+    return out;
 }
 async function loadConfig(projectDir) {
     const globalPath = join(homedir(), GLOBAL_CONFIG_DIR, CONFIG_FILENAME);
     const projectPath = join(projectDir ?? process.cwd(), '.c0de', CONFIG_FILENAME);
     const global = readJsonIfExists(globalPath);
     const project = readJsonIfExists(projectPath);
+    warnUnknownConfigKeys('global', global);
+    warnUnknownConfigKeys('project', project);
     return mergeConfig(global, project);
 }
-async function saveConfig(config, scope, projectDir) {
-    const dir = scope === 'global'
-        ? join(homedir(), GLOBAL_CONFIG_DIR)
-        : join(projectDir ?? process.cwd(), '.c0de');
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const path = join(dir, CONFIG_FILENAME);
-    writeFileSync(path, JSON.stringify(config, null, 2), 'utf-8');
+/** Config 全部顶层键（DEFAULT_CONFIG + 可选键）。未知顶层键校验与告警共用。 */
+const KNOWN_CONFIG_KEYS = new Set([
+    ...Object.keys(DEFAULT_CONFIG),
+    // 可选键不在 DEFAULT_CONFIG 中（缺失=未配置），但属于合法键。
+    'commitModel',
+]);
+/** 收集对象中不属于 Config 顶层键的未知键。 */
+function collectUnknownConfigKeys(data) {
+    if (!data)
+        return [];
+    return Object.keys(data).filter((k) => !KNOWN_CONFIG_KEYS.has(k));
+}
+/** 加载配置时对未知顶层键告警（拼写错误/旧版键静默失效的唯一提示）。 */
+function warnUnknownConfigKeys(scope, data) {
+    const unknown = collectUnknownConfigKeys(data);
+    if (unknown.length === 0)
+        return;
+    console.warn(`[config] ${scope} 配置包含未知键：${unknown.join(', ')}。` +
+        `这些键不会生效——请检查拼写，或移除过时配置。有效顶层键：${[...KNOWN_CONFIG_KEYS].join(', ')}`);
 }
-export { DEFAULT_CONFIG, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfig, saveConfigScoped, };
+export { applyScopedPatch, collectUnknownConfigKeys, DEFAULT_CONFIG, KNOWN_CONFIG_KEYS, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped, warnUnknownConfigKeys, };

package/dist/core/index.d.ts

@@ -1,7 +1,7 @@
 export { abortAgent, createAgent, getAgentStatus, isAgentPaused, pauseAgent, resumeAgent, runAgent, } from './agent.js';
 export { createSummarizer, runCompaction } from './compact.js';
 export type { CompactionConfig, Config, MCPServerConfig } from './config.js';
-export { DEFAULT_CONFIG, loadConfig, mergeConfig, saveConfig } from './config.js';
+export { DEFAULT_CONFIG, loadConfig, mergeConfig } from './config.js';
 export { calibrateEstimate, createTokenBudget, estimateBudget, fitToBudget, shouldCompact, } from './context.js';
 export { agentLoop } from './loop.js';
 export { buildSystemPrompt } from './prompt.js';

package/dist/core/index.js

@@ -2,7 +2,7 @@
 // steering, slash commands, and compaction bridge.
 export { abortAgent, createAgent, getAgentStatus, isAgentPaused, pauseAgent, resumeAgent, runAgent, } from './agent.js';
 export { createSummarizer, runCompaction } from './compact.js';
-export { DEFAULT_CONFIG, loadConfig, mergeConfig, saveConfig } from './config.js';
+export { DEFAULT_CONFIG, loadConfig, mergeConfig } from './config.js';
 export { calibrateEstimate, createTokenBudget, estimateBudget, fitToBudget, shouldCompact, } from './context.js';
 export { agentLoop } from './loop.js';
 export { buildSystemPrompt } from './prompt.js';

package/dist/core/loop/compaction.d.ts

@@ -27,5 +27,6 @@ export declare function recoverFromOverflow(state: AgentState, deps: LoopDeps):
  *    死锁在下一轮用户输入（agentLoop 重入）时重置。
  *  - mid-turn：midTurnEnabled 单独 opt-in（默认关闭）时按 enabled:true 阈值静默压缩，
  *    复用 shouldCompact 逻辑但不发 error/warning，压缩后刷新内存消息视图。
- *  两者都静默消费 compactContext 的 text_delta 通知（不透传给用户）。 */
+ *  两者都静默消费 compactContext 的 text_delta 通知，但把 compaction_done 透传给前端，
+ *  让用户在上下文被改写时得到提示（可在归档面板查看原始内容）。 */
 export declare function runCompactionIfNeeded(state: AgentState, deps: LoopDeps, latestMessages: Message[]): AsyncGenerator<AgentEvent>;

package/dist/core/loop/compaction.js

@@ -1,3 +1,4 @@
+import { buildFallbackChain } from '../../llm/routing.js';
 import { getMessages } from '../../session/message.js';
 import { createSummarizer, runCompaction } from '../compact.js';
 import { estimateBudget, shouldCompact } from '../context.js';
@@ -13,7 +14,13 @@ import { estimateBudget, shouldCompact } from '../context.js';
 export async function* compactContext(state, deps) {
     // summarizer 优先用 compactionModel 覆盖，否则回退当前会话 provider/model。
     const cm = state.compactionModel;
-    const summarizer = createSummarizer(deps.llmRegistry, cm ? cm.provider : state.config.provider, cm ? cm.model : state.config.model, { signal: state.abortController.signal });
+    const provider = cm ? cm.provider : state.config.provider;
+    const model = cm ? cm.model : state.config.model;
+    const fallback = buildFallbackChain(deps.config, provider, model);
+    const summarizer = createSummarizer(deps.llmRegistry, provider, model, {
+        signal: state.abortController.signal,
+        ...(fallback ? { fallback } : {}),
+    });
     const result = await runCompaction(deps.db, state.session.id, summarizer, {
         keepRecentTokens: deps.config.compaction.keepRecentTokens,
     });
@@ -77,15 +84,19 @@ export async function recoverFromOverflow(state, deps) {
  *    死锁在下一轮用户输入（agentLoop 重入）时重置。
  *  - mid-turn：midTurnEnabled 单独 opt-in（默认关闭）时按 enabled:true 阈值静默压缩，
  *    复用 shouldCompact 逻辑但不发 error/warning，压缩后刷新内存消息视图。
- *  两者都静默消费 compactContext 的 text_delta 通知（不透传给用户）。 */
+ *  两者都静默消费 compactContext 的 text_delta 通知，但把 compaction_done 透传给前端，
+ *  让用户在上下文被改写时得到提示（可在归档面板查看原始内容）。 */
 export async function* runCompactionIfNeeded(state, deps, latestMessages) {
     // 死锁时跳过自动压缩：上一轮压缩已证明无法释放足够空间，重试只会无限循环。
     if (!state.compactionDeadEnd &&
         shouldCompact(latestMessages, state.tokenBudget, deps.config.compaction)) {
         // 自动压缩：复用 compactContext；失败非致命，仅记录警告不中断主循环。
         try {
-            for await (const _ev of compactContext(state, deps)) {
-                // 静默消费压缩通知事件，不透传给用户（保持自动压缩的原有静默语义）
+            for await (const ev of compactContext(state, deps)) {
+                // 静默消费 text_delta 通知，但把 compaction_done 透传给前端——
+                // 上下文被改写，用户应被告知（可在归档面板查看原始内容），而非悄然失忆。
+                if (ev._tag === 'compaction_done')
+                    yield ev;
             }
             // 进度保护：compactContext 已重算 state.tokenBudget.used。若压缩后仍超阈值
             // （典型成因：keepRecentTokens 本身已超 historyBudget），压缩无法再释放足够
@@ -124,8 +135,10 @@ export async function* runCompactionIfNeeded(state, deps, latestMessages) {
         // 中轮压缩静默执行：compactContext 内部已发 text_delta 通知，
         // 不再 yield error/warning（与 turn-end 自动压缩的进度保护语义不同）。
         try {
-            for await (const _ev of compactContext(state, deps)) {
-                // 静默消费压缩通知，不透传给用户
+            for await (const ev of compactContext(state, deps)) {
+                // 静默消费 text_delta 通知，透传 compaction_done（与 turn-end 一致）。
+                if (ev._tag === 'compaction_done')
+                    yield ev;
             }
             // 压缩改写了消息历史 → 刷新内存视图，供下一轮上下文重建使用
             state.messages = await getMessages(deps.db, state.session.id);

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/loop.js

@@ -3,6 +3,7 @@ import { resolveRoute } from '../llm/registry.js';
 import { detectProjectInfo } from '../project/detect.js';
 import { entriesToChatMessages, getSessionContext } from '../session/context.js';
 import { getMessages } from '../session/message.js';
+import { updateSessionLastRun } from '../session/session.js';
 import { estimateTokens } from '../session/token.js';
 import { calibrateEstimate, createTokenBudget, estimateBudget } from './context.js';
 import { runCompactionIfNeeded } from './loop/compaction.js';
@@ -69,11 +70,20 @@ export async function* agentLoop(state, deps) {
             return;
         }
         if (state.status._tag === 'paused') {
-            state.status = { _tag: 'running', turnCount: turn };
+            // 暂停点：上一轮原子操作（工具执行批次）已完成。
+            // 持久化 paused 状态供热更新/重启后恢复，随后阻塞等待 resume。
+            state.pauseYielded = false;
             yield { _tag: 'status_change', status: state.status };
+            await updateSessionLastRun(deps.db, state.session.id, {
+                status: 'paused',
+                agentName: state.config.agentName,
+                provider: state.config.provider,
+                model: state.config.model,
+                startedAt: state.lastRunStartedAt ?? Date.now(),
+            }).catch(() => { });
             await waitForResume(state);
-            if (state.status._tag !== 'running')
-                return;
+            if (state.status._tag === 'paused')
+                return; // 等待期间被 abort 等终结
         }
         state.status = { _tag: 'running', turnCount: turn };
         const steering = drainSteering(state);