c0de-agent 1.11.0 → 1.13.0

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/segment.d.ts

@@ -5,4 +5,6 @@ import type { StreamCollectResult } from './stream-collect.js';
 /** 段管理：判断段边界（pending trigger / model / systemPrompt / tools 变化），
  *  构造本轮 LLMCall 并 push 到当前段，持久化 segments。直接修改 state.segments（引用语义）。
  *  trigger 判定用于新段元数据；needSegment 决定是否真正开新段（否则复用 activeSeg）。 */
-export declare function manageSegment(state: AgentState, deps: LoopDeps, systemPrompt: string, tools: ChatTool[], requestStartTime: number, totalLatency: number, collectedUsage: StreamCollectResult['usage'], collectedText: string[], collectedThinking: string[], truncated: FinishReason | null, firstTokenTime: number | null, contextWindow: number | undefined, computedCost: number): Promise<void>;
+export declare function manageSegment(state: AgentState, deps: LoopDeps, systemPrompt: string, tools: ChatTool[], requestStartTime: number, totalLatency: number, collectedUsage: StreamCollectResult['usage'], collectedText: string[], collectedThinking: string[], truncated: FinishReason | null, firstTokenTime: number | null, contextWindow: number | undefined, 
+/** null = 价格未知（loop 层已判定），按 $0 计入并由聚合层计数提示。 */
+computedCost: number | null): Promise<void>;

package/dist/core/loop/segment.js

@@ -1,9 +1,12 @@
+import { usageEvents } from '../../db/schema.js';
 import { saveLLMSegments, segmentFingerprint } from '../../session/session.js';
 import { generateId } from '../../shared/index.js';
 /** 段管理：判断段边界（pending trigger / model / systemPrompt / tools 变化），
  *  构造本轮 LLMCall 并 push 到当前段，持久化 segments。直接修改 state.segments（引用语义）。
  *  trigger 判定用于新段元数据；needSegment 决定是否真正开新段（否则复用 activeSeg）。 */
-export async function manageSegment(state, deps, systemPrompt, tools, requestStartTime, totalLatency, collectedUsage, collectedText, collectedThinking, truncated, firstTokenTime, contextWindow, computedCost) {
+export async function manageSegment(state, deps, systemPrompt, tools, requestStartTime, totalLatency, collectedUsage, collectedText, collectedThinking, truncated, firstTokenTime, contextWindow, 
+/** null = 价格未知（loop 层已判定），按 $0 计入并由聚合层计数提示。 */
+computedCost) {
     // —— 段管理：判断是否开新段 ——
     const fp = segmentFingerprint(systemPrompt, tools);
     const activeSeg = state.segments[state.segments.length - 1];
@@ -69,4 +72,24 @@ export async function manageSegment(state, deps, systemPrompt, tools, requestSta
     };
     currentSeg.calls.push(call);
     await saveLLMSegments(deps.db, state.session.id, state.segments);
+    // P2 成本账本：每个 LLM 调用同时落独立 usage_events 表（与 session 生命周期解耦——
+    // 会话物理清除后花费记录仍在，账本不随回收站到期/彻底删除而消失）。
+    await deps.db.db
+        .insert(usageEvents)
+        .values({
+        callId: call.id,
+        sessionId: state.session.id,
+        projectId: state.session.projectId ?? null,
+        provider: state.config.provider,
+        model: state.config.model,
+        inputTokens: call.usage.input,
+        outputTokens: call.usage.output,
+        cacheRead: call.usage.cacheRead ?? 0,
+        cost: computedCost,
+        timestamp: call.timestamp,
+    })
+        .catch((err) => {
+        // 账本写入失败不致命（会话元数据仍含 segments 备份）；告警便于排查。
+        console.warn(`[loop] usage_events 写入失败（成本账本将缺失本次调用）：${err instanceof Error ? err.message : String(err)}`);
+    });
 }

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) };
@@ -56,41 +57,74 @@ export async function runSubAgent(deps, parent, request) {
         }
     }
     const childCwd = worktreePath ?? deps.cwd;
-    // 实际运行子 agent 的内部函数（sync 与 background 共用）
+    // 4. 构建子 agent 配置：工具集隔离 + 模型覆盖 + 递归限制 + yield
+    const parentDepth = deps._subagentDepth ?? 0;
+    const childDepth = parentDepth + 1;
+    // P1/P2-5：子 agent 工具集无条件取交集（def.tools ∩ 父工具集）——父工具集
+    // 已统一为 resolveEnabledToolNames 的配置解析结果（chat 主 run、CLI print、
+    // 工作流 runner 三处同口径），config.tools.enabled 的 fail-closed 语义对一切
+    // 派生路径成立：全禁时交集为空，子 agent 仅持 yield，写/执行能力不再被
+    // def 固定名单绕过。此前 length>0 例外为工作流 runner 恒 tools=[] 而设，
+    // 子 agent 因而拿到全套固定名单——现 runner 传解析结果，例外不再需要。
+    const declaredTools = def.tools
+        ? def.tools.filter((t) => parent.config.tools.includes(t))
+        : parent.config.tools;
+    const maxRec = def.maxRecursion ?? 0;
+    const baseTools = childDepth > maxRec ? declaredTools.filter((t) => t !== 'task') : declaredTools;
+    const childTools = Array.from(new Set([...baseTools, 'yield']));
+    const childConfig = {
+        ...parent.config,
+        systemPrompt: def.systemPrompt,
+        // 子 agent 走整段 systemPrompt 替换，清除父的 role override 避免干扰
+        agentRolePrompt: undefined,
+        tools: childTools,
+        ...(def.model ? { model: def.model } : {}),
+        ...(request.model ? { model: request.model } : {}),
+    };
+    // 子 agent 的 deps：覆盖 cwd（worktree）+ 注入 yield 收集器 + 递归深度
+    const childDeps = {
+        ...deps,
+        cwd: childCwd,
+        _subagentYieldCollector: (data) => {
+            yielded.push(data);
+        },
+        _subagentDepth: childDepth,
+    };
+    const childState = await createAgent(childSession, childConfig, childDeps);
+    // 继承父 agent 的「预算已确认超支」标记：父 run 已因预算暂停、用户点「恢复」
+    // 继续后，子 agent 不应再因同一预算超支提前中止（用户已知情继续）；父未超支
+    // 时标记为 undefined，子 agent 自跑其 loop 仍会按轮次独立检查预算。
+    childState.budgetPauseTriggered = parent.budgetPauseTriggered;
+    // abort 链接：父 abort 则子 abort
+    if (parent.abortController.signal.aborted) {
+        childState.abortController.abort();
+    }
+    else {
+        parent.abortController.signal.addEventListener('abort', () => childState.abortController.abort(), { once: true });
+    }
+    // P1：把子 run（同步 + 后台）注册进宿主 run 跟踪器（Web=agentManager）。
+    // 此前子 run 完全游离：暂停（权限超时/用户/预算）、热更新 pauseAll、
+    // 删除父会话的中止级联、更新影响面列表全部绕过后台子 agent。
+    // 注册必须先于 dispatch：background 路径「返回 running」时子 run 已可被控制。
+    const unregisterChild = deps.registerChildRun?.({
+        sessionId: childSession.id,
+        parentSessionId: parent.session.id,
+        ...(request.background ? { jobId: childSession.id } : {}),
+        state: childState,
+        deps: childDeps,
+    });
+    // 实际运行子 agent 的内部函数（sync 与 background 共用）。
+    // 无论正常完成/出错/被中止，finally 中注销宿主注册，避免 run 槽位泄漏。
     const runBody = async () => {
-        // 4. 构建子 agent 配置：工具集隔离 + 模型覆盖 + 递归限制 + yield
-        const parentDepth = deps._subagentDepth ?? 0;
-        const childDepth = parentDepth + 1;
-        const declaredTools = def.tools ?? parent.config.tools;
-        const maxRec = def.maxRecursion ?? 0;
-        const baseTools = childDepth > maxRec ? declaredTools.filter((t) => t !== 'task') : declaredTools;
-        const childTools = Array.from(new Set([...baseTools, 'yield']));
-        const childConfig = {
-            ...parent.config,
-            systemPrompt: def.systemPrompt,
-            // 子 agent 走整段 systemPrompt 替换，清除父的 role override 避免干扰
-            agentRolePrompt: undefined,
-            tools: childTools,
-            ...(def.model ? { model: def.model } : {}),
-            ...(request.model ? { model: request.model } : {}),
-        };
-        // 子 agent 的 deps：覆盖 cwd（worktree）+ 注入 yield 收集器 + 递归深度
-        const childDeps = {
-            ...deps,
-            cwd: childCwd,
-            _subagentYieldCollector: (data) => {
-                yielded.push(data);
-            },
-            _subagentDepth: childDepth,
-        };
-        const childState = await createAgent(childSession, childConfig, childDeps);
-        // abort 链接：父 abort 则子 abort
-        if (parent.abortController.signal.aborted) {
-            childState.abortController.abort();
+        try {
+            return await runChildBody(childState, childDeps, childSession, title, baseline, worktreePath);
         }
-        else {
-            parent.abortController.signal.addEventListener('abort', () => childState.abortController.abort(), { once: true });
+        finally {
+            unregisterChild?.();
         }
+    };
+    // 子 agent loop 执行体：运行 loop → worktree delta 回传 → 发射结束事件。
+    const runChildBody = async (childState, childDeps, childSession, title, baseline, worktreePath) => {
         // 运行子 agent loop
         const childPrompt = request.context
             ? `CONTEXT\n${request.context}\n\nASSIGNMENT\n${request.prompt}`
@@ -147,13 +181,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.d.ts

@@ -12,6 +12,13 @@ type LoopDeps = AgentDependencies & {
     readonly _subagentEventSink?: (event: AgentEvent) => void;
     /** 当前递归深度（0=顶层主 agent）。用于 maxRecursion 控制（spec §4.5 step 4）。 */
     readonly _subagentDepth?: number;
+    /** P3 成本护栏：Web 会话「启用预算检查」的门禁。具体 pause/abort 由
+     *  budgetOverageParts 按超支轴配置动作判定（abort > pause），此处仅表启用。
+     *  由 chat 路由按 usage 任一轴动作为 'pause'/'abort' 注入。 */
+    readonly budgetPause?: boolean;
+    /** 预算护栏的 CLI 变体：无恢复 UI，超支时**中止 run**并产出 error（而非暂停挂起）。
+     *  由 CLI deps 组装（buildAgentDeps）按 usage 动作注入，替代 budgetPause（恒 abort）。 */
+    readonly budgetAbort?: boolean;
 };
 export type { LoopDeps };
 export declare function agentLoop(state: AgentState, deps: LoopDeps): AsyncGenerator<AgentEvent>;

package/dist/core/loop.js

@@ -3,8 +3,9 @@ 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 { markBudgetPause, updateSessionLastRun } from '../session/session.js';
 import { estimateTokens } from '../session/token.js';
+import { budgetOverageParts } from '../session/usage.js';
 import { calibrateEstimate, createTokenBudget, estimateBudget } from './context.js';
 import { runCompactionIfNeeded } from './loop/compaction.js';
 import { persistAssistantAndTools } from './loop/persist.js';
@@ -22,6 +23,8 @@ const FALLBACK_CONTEXT_WINDOW = 32_000;
 /** 每个 agent 已解析的有效 contextWindow 缓存（真实值或保守估计）。
  *  避免每轮重复解析/告警，并防止估计值随每轮 input token 抖动导致预算基准漂移。 */
 const effectiveContextWindowCache = new WeakMap();
+/** 已记录「金额口径低估」告警的 agent（每 run 至多记一次，防逐轮刷屏）。 */
+const budgetWarnedStates = new WeakSet();
 /**
  * 解析本轮有效 contextWindow，确保 shouldCompact 始终有合理基准：
  *  - provider 已声明（capabilities.contextWindow 为正数）→ 原样采用，不改变正常配置行为。
@@ -85,6 +88,82 @@ export async function* agentLoop(state, deps) {
             if (state.status._tag === 'paused')
                 return; // 等待期间被 abort 等终结
         }
+        // 预算护栏：金额 + token 双口径（token 兜底价格未知的自建网关/未登记模型），
+        // 每轮 LLM 请求前检查。每 run 至多触发一次（budgetPauseTriggered），恢复后
+        // 用户已知情继续。deps.budgetPause 由 Web 路由按配置注入；deps.budgetAbort
+        // 由 CLI 组装注入（无恢复 UI，超支中止而非暂停挂起）。
+        // 顶层 agent：超支 → 暂停（Web，可恢复）/ 中止（CLI，产出 error）。
+        // 子 agent：无恢复 UI，超支 → 提前中止自身（把超支作为错误回报父 agent，父
+        //   run 下一轮检查将暂停）——收紧子 agent 单轮内 fan-out 的超支粒度。
+        if ((deps.budgetPause === true || deps.budgetAbort === true) && !state.budgetPauseTriggered) {
+            try {
+                const { parts, action, warnings } = await budgetOverageParts(deps.db, deps.config.usage, state.session.projectId);
+                if (parts.length > 0) {
+                    state.budgetPauseTriggered = true;
+                    const reason = `月度预算超支（${parts.join('；')}）${warnings.length > 0 ? `；注意：${warnings.join('；')}` : ''}`;
+                    if (deps._subagentDepth === undefined) {
+                        // CLI（budgetAbort）恒中止；Web 按超支轴配置动作判定（abort > pause）。
+                        if (deps.budgetAbort === true || action === 'abort') {
+                            state.status = {
+                                _tag: 'stopped',
+                                reason: 'error',
+                                error: { _tag: 'unexpected', message: reason },
+                            };
+                            yield { _tag: 'error', error: { _tag: 'unexpected', message: reason } };
+                            return;
+                        }
+                        state.status = { _tag: 'paused', pauseReason: reason };
+                        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(() => { });
+                        // P2-3：暂停原因落盘——热更新/重启后 run 重建，消费此标记还原
+                        // budgetPauseTriggered，避免同一超支原因二次暂停打断用户。
+                        await markBudgetPause(deps.db, state.session.id, reason).catch(() => { });
+                        await waitForResume(state);
+                        if (state.status._tag === 'paused')
+                            return;
+                    }
+                    else {
+                        state.status = {
+                            _tag: 'stopped',
+                            reason: 'error',
+                            error: { _tag: 'unexpected', message: reason },
+                        };
+                        yield { _tag: 'error', error: { _tag: 'unexpected', message: reason } };
+                        return;
+                    }
+                }
+                else if (warnings.length > 0 && !budgetWarnedStates.has(state)) {
+                    // P2-2：未超支但金额口径不可靠（价格未知调用无 token 兜底）——每 run
+                    // 记日志一次，不阻断。用户主动看日志即可发现「预算未真正兜底」。
+                    budgetWarnedStates.add(state);
+                    console.warn(`[usage] 预算金额口径低估告警：${warnings.join('；')}`);
+                }
+            }
+            catch (err) {
+                // 账本查询失败：记录告警。'warn'/'pause' 路径 fail-open（可用性优先）；
+                // 'abort' 路径（用户显式要求硬封顶）保守 fail-closed——账本不可用即无法
+                // 保证「绝不超限」，宁可本轮中止并明示，而非静默放行继续烧钱。
+                console.error('[usage] 预算护栏账本查询失败：', err);
+                const abortSeverity = deps.config.usage.budgetAction === 'abort' ||
+                    deps.config.usage.tokenBudgetAction === 'abort';
+                if (abortSeverity) {
+                    const reason = '月度预算账本查询失败且预算动作为 abort（硬封顶）：无法确认是否超支，出于安全中止本轮';
+                    state.status = {
+                        _tag: 'stopped',
+                        reason: 'error',
+                        error: { _tag: 'unexpected', message: reason },
+                    };
+                    yield { _tag: 'error', error: { _tag: 'unexpected', message: reason } };
+                    return;
+                }
+            }
+        }
         state.status = { _tag: 'running', turnCount: turn };
         const steering = drainSteering(state);
         const { entries, snapshots } = await getSessionContext(deps.db, state.session.id, deps.cwd);
@@ -198,18 +277,23 @@ export async function* agentLoop(state, deps) {
         }
         const totalLatency = Date.now() - requestStartTime;
         let contextWindow;
-        let computedCost = 0;
+        // H2：价格未知时 cost=null（聚合按 $0 计 + 显式计数），不再静默记 0。
+        // 未知判定：provider 未注册/解析失败，或模型价目全为 0（未声明价格的
+        // 自建网关模型回退到 DEFAULT_MODEL_CAPABILITIES 的 0 价）。
+        let computedCost = null;
         try {
             const { capabilities } = resolveRoute(deps.llmRegistry, state.config.provider, state.config.model);
             contextWindow = capabilities.contextWindow;
             const inputTokens = collected.usage?.inputTokens ?? 0;
             const outputTokens = collected.usage?.outputTokens ?? 0;
-            computedCost =
-                (inputTokens / 1000) * capabilities.costPer1kInput +
-                    (outputTokens / 1000) * capabilities.costPer1kOutput;
+            if (capabilities.costPer1kInput > 0 || capabilities.costPer1kOutput > 0) {
+                computedCost =
+                    (inputTokens / 1000) * capabilities.costPer1kInput +
+                        (outputTokens / 1000) * capabilities.costPer1kOutput;
+            }
         }
         catch {
-            // provider 未注册或模型未知：保留 contextWindow=undefined、cost=0
+            // provider 未注册：保留 contextWindow=undefined、cost=null
         }
         // —— contextWindow 兜底 + token 预算同步 ——
         // provider 未声明 contextWindow 时回填保守估计（见 resolveEffectiveContextWindow），

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.d.ts

@@ -10,6 +10,16 @@ type SlashRegistry = {
     register: (cmd: SlashCommand) => void;
 };
 declare function createSlashRegistry(): SlashRegistry;
+/**
+ * P0-2：统一斜杠命令启用判定（Web chat / CLI chat / 命令列表 / /help 共用）。
+ * 语义（fail-closed，与 tools.enabled 对齐）：
+ *  - enabled 含 '*'（通配）→ 全部启用。
+ *  - enabled 为显式名单 → 仅名单内启用（名称兼容带/不带前缀斜杠）。
+ *  - enabled 为空数组/缺失 → 全部禁用（旧版含义「空=全部启用」，升级告警见
+ *    collectConfigMigrationWarnings——两处同形键不再语义相反）。
+ * `enabled` 已含 '/' 前缀或裸名均可。
+ */
+export declare function isSlashCommandEnabled(enabled: string[] | undefined, name: string): boolean;
 declare const builtinCommands: SlashCommand[];
 export type { SlashRegistry };
 export { builtinCommands, createSlashRegistry, parseSlashInput };