dskcode 0.1.28 → 0.1.30

package/dist/index.js

@@ -772,7 +772,7 @@ async function getAllSkills(cwd) {
 
 // src/cli/index.tsx
 import { readFile as readFile11 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 
 // src/ui/RenderScope.tsx
 import { render } from "ink";
@@ -807,7 +807,7 @@ var LOGO_LINES = [
 // src/ui/ChatSession.tsx
 import { Box as Box9, Text as Text10, useInput, Static } from "ink";
 import TextInput from "ink-text-input";
-import { useEffect as useEffect3, useState as useState3, useCallback as useCallback2, useMemo, useRef as useRef2 } from "react";
+import { useEffect as useEffect4, useState as useState4, useCallback as useCallback2, useMemo, useRef as useRef3 } from "react";
 
 // src/ui/useDoubleCtrlC.ts
 import { useState as useState2, useCallback, useEffect as useEffect2, useRef } from "react";
@@ -842,6 +842,7 @@ import InkSpinner2 from "ink-spinner";
 
 // src/ui/AssistantMessage.tsx
 import { Box as Box5, Text as Text6 } from "ink";
+import { useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
 
 // src/provider/cost-tracker.ts
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
@@ -1674,12 +1675,90 @@ function HighlightedText({ children: text }) {
 }
 
 // src/ui/AssistantMessage.tsx
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function formatElapsed(ms) {
   if (ms < 1e3) return `${ms}ms`;
   const seconds = (ms / 1e3).toFixed(1);
   return `${seconds}s`;
 }
+function AnimatedUsage({ usage, cost }) {
+  const targetTokens = usage ? usage.promptTokens + usage.completionTokens : 0;
+  const targetCost = cost ?? 0;
+  const [displayedTokens, setDisplayedTokens] = useState3(targetTokens);
+  const [displayedCost, setDisplayedCost] = useState3(targetCost);
+  const startRef = useRef2(null);
+  const rafRef = useRef2(null);
+  useEffect3(() => {
+    if (startRef.current && startRef.current.toTokens === targetTokens && startRef.current.toCost === targetCost) {
+      return;
+    }
+    if (targetTokens <= displayedTokens && targetCost <= displayedCost) {
+      setDisplayedTokens(targetTokens);
+      setDisplayedCost(targetCost);
+      startRef.current = {
+        fromTokens: targetTokens,
+        fromCost: targetCost,
+        toTokens: targetTokens,
+        toCost: targetCost,
+        startMs: Date.now(),
+        durationMs: 0
+      };
+      return;
+    }
+    const tokensDelta = targetTokens - displayedTokens;
+    const costDelta = targetCost - displayedCost;
+    const durationMs = Math.min(
+      600,
+      Math.max(220, Math.max(tokensDelta, 0) * 1.2 + 220)
+    );
+    startRef.current = {
+      fromTokens: displayedTokens,
+      fromCost: displayedCost,
+      toTokens: targetTokens,
+      toCost: targetCost,
+      startMs: Date.now(),
+      durationMs
+    };
+    if (rafRef.current) clearInterval(rafRef.current);
+    rafRef.current = setInterval(() => {
+      const s = startRef.current;
+      if (!s) return;
+      const elapsed = Date.now() - s.startMs;
+      if (elapsed >= s.durationMs) {
+        setDisplayedTokens(s.toTokens);
+        setDisplayedCost(s.toCost);
+        if (rafRef.current) {
+          clearInterval(rafRef.current);
+          rafRef.current = null;
+        }
+        return;
+      }
+      const t = elapsed / s.durationMs;
+      const eased = 1 - Math.pow(1 - t, 3);
+      const tokens = s.fromTokens + (s.toTokens - s.fromTokens) * eased;
+      const cost2 = s.fromCost + (s.toCost - s.fromCost) * eased;
+      setDisplayedTokens(tokens);
+      setDisplayedCost(cost2);
+    }, 33);
+    return () => {
+      if (rafRef.current) {
+        clearInterval(rafRef.current);
+        rafRef.current = null;
+      }
+    };
+  }, [targetTokens, targetCost]);
+  return /* @__PURE__ */ jsxs5(Fragment, { children: [
+    usage && /* @__PURE__ */ jsxs5(Text6, { color: "#888888", children: [
+      Math.round(displayedTokens).toLocaleString(),
+      " tokens"
+    ] }),
+    cost !== void 0 && cost > 0 && /* @__PURE__ */ jsxs5(Text6, { color: "#888888", children: [
+      " \xB7 ",
+      "\xA5",
+      displayedCost.toFixed(4)
+    ] })
+  ] });
+}
 function AssistantMessage({
   content,
   toolCalls,
@@ -1701,6 +1780,11 @@ function AssistantMessage({
       ] })
     ] }),
     toolCalls && toolCalls.length > 0 && /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: toolCalls.map((tc, i) => /* @__PURE__ */ jsx5(ToolCallBlock, { call: tc }, tc.id ?? i)) }),
+    isStreaming && (usage || cost !== void 0) && /* @__PURE__ */ jsx5(Box5, { flexDirection: "row", marginTop: 1, marginLeft: 3, children: /* @__PURE__ */ jsxs5(Text6, { color: "#666666", dimColor: true, children: [
+      "\u23F3 \u5DF2\u6D88\u8017",
+      " ",
+      /* @__PURE__ */ jsx5(AnimatedUsage, { usage, cost })
+    ] }) }),
     !isStreaming && (usage || elapsed !== void 0) && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, marginLeft: 3, children: [
       /* @__PURE__ */ jsx5(Text6, { color: "#555555", children: "\u2500".repeat(36) }),
       /* @__PURE__ */ jsxs5(Box5, { flexDirection: "row", gap: 2, children: [
@@ -2114,6 +2198,389 @@ var ToolRegistry = class {
   }
 };
 
+// src/agent/tool-executor.ts
+var ToolExecutor = class {
+  /** 工具注册表（只读引用） */
+  #registry;
+  /** 权限门（只读引用） */
+  #gate;
+  /** 工具执行上下文（每次执行都共用） */
+  #baseCtx;
+  /** 并行执行的最大同时执行数（默认 8） */
+  #maxParallel;
+  /**
+   * 构造一个 ToolExecutor。
+   *
+   * @param deps — 注入依赖（registry / gate / baseCtx / maxParallel）
+   * @pure 仅保存引用，不调用任何外部 IO
+   */
+  constructor(deps) {
+    this.#registry = deps.registry;
+    this.#gate = deps.gate;
+    this.#baseCtx = {
+      cwd: deps.baseCtx.cwd,
+      signal: deps.baseCtx.signal,
+      writeRoots: deps.baseCtx.writeRoots,
+      ...deps.baseCtx.timeout !== void 0 ? { timeout: deps.baseCtx.timeout } : {}
+    };
+    this.#maxParallel = deps.maxParallel ?? 8;
+  }
+  /**
+   * 执行一批工具调用。
+   *
+   * 自动选择并行 / 串行：
+   * - 全部为只读工具 且 calls.length > 1：分批并行（每批最多 #maxParallel 个）
+   * - 其他：严格串行
+   *
+   * @param calls — LLM 决定的本轮工具调用列表
+   * @returns items（全部结果）+ records（仅失败项，用于风暴检测）
+   *
+   * @sideEffect 调用 registry / gate / tool.execute；不修改 Session.messages
+   */
+  async executeBatch(calls) {
+    if (calls.length === 0) return { items: [], records: [] };
+    if (this.#allReadOnly(calls) && calls.length > 1) {
+      return this.#executeParallel(calls);
+    }
+    return this.#executeSequential(calls);
+  }
+  // -------------------------------------------------------------------------
+  // 内部
+  // -------------------------------------------------------------------------
+  /**
+   * 判定这一批调用是否全部为只读工具。
+   * 工具未找到时按"只读"处理（不会因为没注册就拒绝并行）。
+   *
+   * @pure 不修改任何状态
+   */
+  #allReadOnly(calls) {
+    return calls.every((tc) => {
+      const tool = this.#registry.get(tc.name);
+      return tool ? isReadOnly(tool.kind) : true;
+    });
+  }
+  /**
+   * 并行执行：按 #maxParallel 分批，每批内 Promise.all。
+   * 用于"全部只读 + 多于 1 个"的场景。
+   *
+   * @param calls — 全部只读的工具调用
+   * @returns items + records
+   *
+   * @sideEffect 调用 tool.execute
+   */
+  async #executeParallel(calls) {
+    const items = [];
+    const records = [];
+    for (let i = 0; i < calls.length; i += this.#maxParallel) {
+      const batch = calls.slice(i, i + this.#maxParallel);
+      const results = await Promise.all(batch.map((tc) => this.#executeOne(tc)));
+      for (const r of results) {
+        items.push(r.item);
+        if (!r.record.success) records.push(r.record);
+      }
+    }
+    return { items, records };
+  }
+  /**
+   * 串行执行：按 calls 顺序逐个执行。
+   * 用于含写工具的场景（保证副作用顺序与 LLM 给出顺序一致）。
+   *
+   * @param calls — 工具调用列表
+   * @returns items + records
+   *
+   * @sideEffect 按序调用 tool.execute
+   */
+  async #executeSequential(calls) {
+    const items = [];
+    const records = [];
+    for (const tc of calls) {
+      const r = await this.#executeOne(tc);
+      items.push(r.item);
+      if (!r.record.success) records.push(r.record);
+    }
+    return { items, records };
+  }
+  /**
+   * 执行单个工具调用，包含查找 / 参数解析 / 权限门 / 写工具 preview / 异常捕获。
+   *
+   * 失败映射：
+   * - 工具不存在或被禁用 → `TOOL_NOT_FOUND`
+   * - 权限门拒绝       → `GATE_DENIED`
+   * - 工具 execute 抛错 → `EXECUTION_ERROR`
+   *
+   * @param tc — 单个工具调用（含 id / name / arguments 字符串）
+   * @returns { item, record } — item 喂回 Session；record 用于风暴检测
+   *
+   * @sideEffect 调 tool.execute、可能调 tool.preview；不抛错给调用方
+   */
+  async #executeOne(tc) {
+    const toolName = tc.name;
+    const timestamp = Date.now();
+    const tool = this.#registry.get(toolName);
+    if (!tool) {
+      const errMsg = `\u5DE5\u5177 "${toolName}" \u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u7981\u7528`;
+      return {
+        item: { name: toolName, callId: tc.id, result: { success: false, data: errMsg, error: "TOOL_NOT_FOUND" } },
+        record: { name: toolName, success: false, error: "TOOL_NOT_FOUND", timestamp }
+      };
+    }
+    let toolArgs;
+    try {
+      toolArgs = tc.arguments ? JSON.parse(tc.arguments) : {};
+    } catch {
+      toolArgs = {};
+    }
+    const gateResult = await this.#gate.check(toolName, toolArgs);
+    if (!gateResult) {
+      const errMsg = `\u5DE5\u5177 "${toolName}" \u88AB\u6743\u9650\u95E8\u62D2\u7EDD`;
+      return {
+        item: { name: toolName, callId: tc.id, result: { success: false, data: errMsg, error: "GATE_DENIED" } },
+        record: { name: toolName, success: false, error: "GATE_DENIED", timestamp }
+      };
+    }
+    if (!isReadOnly(tool.kind)) {
+      const maybePreview = tool.preview;
+      if (typeof maybePreview === "function") {
+        try {
+          await maybePreview(toolArgs, this.#baseCtx);
+        } catch {
+        }
+      }
+    }
+    try {
+      const result = await this.#invokeTool(tool, toolArgs);
+      return {
+        item: { name: toolName, callId: tc.id, result },
+        record: { name: toolName, success: result.success, error: result.error, timestamp }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const errorResult = {
+        success: false,
+        data: `\u5DE5\u5177 "${toolName}" \u6267\u884C\u5F02\u5E38\uFF1A${message}`,
+        error: "EXECUTION_ERROR"
+      };
+      return {
+        item: { name: toolName, callId: tc.id, result: errorResult },
+        record: { name: toolName, success: false, error: "EXECUTION_ERROR", timestamp }
+      };
+    }
+  }
+  /**
+   * 真正调 tool.execute 的薄包装（拆出来便于以后插入横切关注点，如重试 / 计时）。
+   *
+   * @param tool — 类型擦除后的工具
+   * @param args — 解析后的参数（unknown）
+   * @returns 工具的 ToolResult
+   *
+   * @sideEffect 调 tool.execute
+   */
+  async #invokeTool(tool, args) {
+    return tool.execute(args, this.#baseCtx);
+  }
+};
+
+// src/agent/storm-detector.ts
+var StormDetector = class {
+  /** 触发风暴需要的最少连续失败次数（默认 3） */
+  #threshold;
+  /**
+   * 构造一个 StormDetector。
+   *
+   * @param opts — 判定选项（threshold）
+   * @pure 仅保存配置
+   */
+  constructor(opts = {}) {
+    this.#threshold = opts.threshold ?? 3;
+  }
+  /**
+   * 判定本轮是否应该中断风暴。
+   *
+   * @param recentRecords — 历史的失败记录（不含成功的；通常来自 ToolExecutor 的 records）
+   * @param currentCalls — 本轮 LLM 决定调用的工具
+   * @returns true 表示触发风暴，调用方应放弃本轮工具执行并提示切换策略
+   *
+   * @pure 不修改任何状态，仅做比较判断
+   */
+  shouldBreak(recentRecords, currentCalls) {
+    if (recentRecords.length < this.#threshold) return false;
+    const lastN = recentRecords.slice(-this.#threshold);
+    if (lastN.length < this.#threshold) return false;
+    const first = lastN[0];
+    const allSame = lastN.every((r) => r.name === first.name && r.error === first.error && !r.success);
+    if (!allSame) return false;
+    return currentCalls.some((tc) => tc.name === first.name);
+  }
+};
+
+// src/agent/reflector.ts
+var Reflector = class {
+  /** 触发 R1 需要的最小连续失败次数 */
+  #repeatThreshold;
+  /** 注入到 prompt 的最大反射数 */
+  #maxReflections;
+  /** 单条 hint 的最大字符数 */
+  #maxHintChars;
+  /**
+   * 构造一个 Reflector。
+   *
+   * @param options — 限流与阈值配置
+   * @pure 仅保存配置
+   */
+  constructor(options = {}) {
+    this.#repeatThreshold = options.repeatThreshold ?? 2;
+    this.#maxReflections = options.maxReflections ?? 5;
+    this.#maxHintChars = options.maxHintChars ?? 800;
+  }
+  /**
+   * 分析一批工具执行结果，返回要注入的反射列表。
+   *
+   * 行为：
+   * - 成功项直接跳过
+   * - 失败项按 R1 → R2 → R3 → R4 顺序检查，先命中先用，单条目最多产生 1 条
+   * - 总数超过 maxReflections 时截断到前 N 条
+   *
+   * @param items — 本轮工具执行结果列表
+   * @param ctx — 上下文（writeRoots / cwd，用于生成 hint）
+   * @returns 反射列表（可能为空；最多 maxReflections 条）
+   *
+   * @pure 不修改任何状态
+   */
+  analyze(items, ctx) {
+    const reflections = [];
+    for (const item of items) {
+      if (item.result.success) continue;
+      const r = this.#ruleRepeatedFailure(item) ?? this.#ruleFileNotFound(item) ?? this.#rulePermissionDenied(item) ?? this.#ruleOutOfWriteRoot(item, ctx.writeRoots);
+      if (r) reflections.push(r);
+      if (reflections.length >= this.#maxReflections) break;
+    }
+    return reflections;
+  }
+  /**
+   * 把反射列表拼成"反思"section，追加到 system prompt 末尾。
+   *
+   * 输出格式：
+   * ```
+   * {原 prompt}
+   *
+   * ## ⚠️ 上一轮工具调用的反思
+   * - 工具 `<tool>`：<hint>
+   * - 工具 `<tool>`：<hint>
+   * ```
+   *
+   * @param systemPrompt — 原始 system prompt
+   * @param reflections — 反射列表（空数组时原样返回）
+   * @returns 拼装后的新 prompt
+   *
+   * @pure 不修改入参
+   */
+  injectIntoPrompt(systemPrompt, reflections) {
+    if (reflections.length === 0) return systemPrompt;
+    const lines = reflections.map((r) => {
+      const hint = this.#truncate(r.hint);
+      return `- \u5DE5\u5177 \`${r.toolName}\` \u5931\u8D25\uFF1A${hint}`;
+    });
+    const section = [
+      "## \u26A0\uFE0F \u4E0A\u4E00\u8F6E\u5DE5\u5177\u8C03\u7528\u7684\u53CD\u601D",
+      "\u4EE5\u4E0B\u662F\u672C\u8F6E\u5DE5\u5177\u6267\u884C\u5931\u8D25\u7684\u539F\u56E0\u5206\u6790\u3002\u8BF7\u5728\u4E0B\u4E00\u6B21\u8C03\u7528\u524D\u5148\u89E3\u51B3\u8FD9\u4E9B\u95EE\u9898\uFF0C\u4E0D\u8981\u91CD\u590D\u76F8\u540C\u7684\u9519\u8BEF\u8C03\u7528\u3002",
+      ...lines
+    ].join("\n");
+    return systemPrompt + "\n\n" + section;
+  }
+  // -------------------------------------------------------------------------
+  // 规则实现（按 R1 → R2 → R3 → R4 顺序）
+  // -------------------------------------------------------------------------
+  /**
+   * R1 连续失败：同一工具连续 ≥#repeatThreshold 次相同错误码失败。
+   *
+   * @pure 仅读入参
+   */
+  #ruleRepeatedFailure(item) {
+    const recent = item.recentSameTool;
+    if (recent.length < this.#repeatThreshold) return null;
+    const lastN = recent.slice(-this.#repeatThreshold);
+    const first = lastN[0];
+    if (!lastN.every((r) => !r.success && r.error === first.error)) {
+      return null;
+    }
+    const errText = first.error ?? "\u672A\u77E5\u9519\u8BEF";
+    return {
+      category: "repeated_failure",
+      toolName: item.name,
+      hint: `\u4F60\u5DF2\u8FDE\u7EED ${this.#repeatThreshold} \u6B21\u8C03\u7528 \`${item.name}\` \u5931\u8D25\uFF08\u9519\u8BEF\uFF1A${errText}\uFF09\u3002\u8BF7\u5148 \`read_file\` \u770B\u6E05\u73B0\u573A\u6216\u6362\u5176\u4ED6\u5DE5\u5177\uFF0C\u4E0D\u8981\u7EE7\u7EED\u540C\u6837\u7684\u9519\u8BEF\u8C03\u7528\u3002`
+    };
+  }
+  /**
+   * R2 文件不存在：TOOL_NOT_FOUND 错误码 或 data 含 ENOENT / not found / No such file。
+   *
+   * @pure 仅读入参
+   */
+  #ruleFileNotFound(item) {
+    const isToolNotFound = item.result.error === "TOOL_NOT_FOUND";
+    const data = item.result.data ?? "";
+    const hasKeyword = data.includes("ENOENT") || data.includes("No such file") || /\bnot found\b/i.test(data);
+    if (!isToolNotFound && !hasKeyword) return null;
+    return {
+      category: "file_not_found",
+      toolName: item.name,
+      hint: `\`${item.name}\` \u5931\u8D25\uFF1A\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u7528 \`ls\` / \`glob\` \u770B\u4E00\u4E0B\u76EE\u5F55\u7ED3\u6784\uFF0C\u6216\u786E\u8BA4\u8DEF\u5F84\u62FC\u5199\uFF08\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u89C1 system prompt\uFF09\u3002`
+    };
+  }
+  /**
+   * R3 权限拒绝：GATE_DENIED 错误码 或 data 含 EACCES / permission / denied（不区分大小写）。
+   *
+   * @pure 仅读入参
+   */
+  #rulePermissionDenied(item) {
+    const isGateDenied = item.result.error === "GATE_DENIED";
+    const data = item.result.data ?? "";
+    const hasKeyword = data.includes("EACCES") || /\bpermission\b/i.test(data) || /\bdenied\b/i.test(data);
+    if (!isGateDenied && !hasKeyword) return null;
+    return {
+      category: "permission_denied",
+      toolName: item.name,
+      hint: `\`${item.name}\` \u88AB\u6743\u9650\u7CFB\u7EDF\u62D2\u7EDD\u3002\u8BF7\u68C0\u67E5\uFF1A1) \u8DEF\u5F84\u662F\u5426\u5728\u5141\u8BB8\u6839\u76EE\u5F55\u5185\uFF1B2) \u662F\u5426\u9700\u8981\u5207\u6362\u6388\u6743\u6A21\u5F0F\uFF1B3) \u6539\u7528\u5176\u4ED6\u4E0D\u9700\u8981\u6743\u9650\u7684\u5DE5\u5177\u3002`
+    };
+  }
+  /**
+   * R4 写根外：kind ∈ Edit/Delete/Move 且失败。
+   *
+   * @pure 仅读入参
+   */
+  #ruleOutOfWriteRoot(item, writeRoots) {
+    const isWriteKind = item.kind === "edit" /* Edit */ || item.kind === "delete" /* Delete */ || item.kind === "move" /* Move */;
+    if (!isWriteKind) return null;
+    const primary = writeRoots[0] ?? "<\u672A\u914D\u7F6E>";
+    return {
+      category: "out_of_write_root",
+      toolName: item.name,
+      hint: `\`${item.name}\` \u662F\u5199\u64CD\u4F5C\u4F46\u76EE\u6807\u8DEF\u5F84\u4E0D\u5728\u5141\u8BB8\u7684\u6839\u76EE\u5F55\u5185\u3002\u8BF7\u6539\u7528 \`${primary}\` \u4E0B\u7684\u8DEF\u5F84\uFF0C\u6216\u8C03\u6574\u9879\u76EE\u7684 \`writeRoots\` \u914D\u7F6E\u3002`
+    };
+  }
+  /**
+   * 截断超长 hint，末尾加省略号。
+   *
+   * @pure 字符串处理
+   */
+  #truncate(text) {
+    if (text.length <= this.#maxHintChars) return text;
+    return text.slice(0, this.#maxHintChars - 3) + "...";
+  }
+};
+
+// src/agent/tool-definitions.ts
+function buildToolDefinitions(registry2, mode) {
+  const tools = mode === "plan" ? registry2.listReadTools() : registry2.list();
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+
 // src/checkpoint/git-checkpoint.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -2277,21 +2744,271 @@ function isENOENT(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
+// src/logger/logger.ts
+import { mkdir as mkdir5, appendFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { join as join5, basename, sep } from "path";
+var LOGGER_DIR = "logger";
+var MAX_DATA_LEN = 2e3;
+var MAX_QUEUE = 500;
+function defaultLogsDir() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "~";
+  return join5(home, ".dskcode", "logs");
+}
+function projectNameFromCwd(cwd) {
+  const name = basename(cwd);
+  return name || "_root";
+}
+var ConversationLogger = class _ConversationLogger {
+  /** 所有活跃的 logger 实例（用于退出时统一 flush） */
+  static #instances = /* @__PURE__ */ new Set();
+  /**
+   * 刷新所有活跃 logger 实例的缓冲，确保事件落盘。
+   * 进程退出前调用。
+   */
+  static async flushAll() {
+    const promises = [];
+    for (const logger of _ConversationLogger.#instances) {
+      promises.push(logger.flush());
+    }
+    await Promise.allSettled(promises);
+  }
+  #logPath;
+  #enabled;
+  #queue = Promise.resolve();
+  #queueLen = 0;
+  #closed = false;
+  constructor(sessionId, cwd, options) {
+    this.#enabled = options?.enabled ?? true;
+    if (!this.#enabled) {
+      this.#logPath = "";
+      return;
+    }
+    const baseDir = options?.logsDir ?? defaultLogsDir();
+    const projectName = projectNameFromCwd(cwd);
+    this.#logPath = join5(baseDir, projectName, `${sessionId}.jsonl`);
+    _ConversationLogger.#instances.add(this);
+  }
+  /** 日志文件完整路径（禁用时返回空字符串） */
+  get logPath() {
+    return this.#logPath;
+  }
+  /** 是否启用日志记录 */
+  get enabled() {
+    return this.#enabled;
+  }
+  /**
+   * 记录一个事件。
+   *
+   * 内部将事件序列化为 pretty JSON 并以多行块的形式追加到日志文件。
+   * 写入操作串行排队，保证事件顺序。调用方无需 await。
+   */
+  log(event) {
+    if (!this.#enabled || this.#closed) return;
+    if (this.#queueLen >= MAX_QUEUE) return;
+    const enriched = {
+      ...event,
+      time: event.time ?? formatTime(event.ts),
+      loc: event.loc ?? captureCallerLocation()
+    };
+    this.#queueLen++;
+    this.#queue = this.#queue.then(() => this.#writeBlock(enriched)).catch(() => {
+    }).finally(() => this.#queueLen--);
+  }
+  /**
+   * 关闭日志记录器。
+   *
+   * 标记关闭，不再接受新事件，但会等待队列中已有事件写入完成。
+   * 返回的 Promise resolve 后保证所有已 log 的事件都已落盘。
+   */
+  async flush() {
+    this.#closed = true;
+    await this.#queue.catch(() => {
+    });
+    _ConversationLogger.#instances.delete(this);
+  }
+  /** 将一条事件以多行块的形式写入日志文件 */
+  async #writeBlock(event) {
+    const dir = join5(this.#logPath, "..");
+    await mkdir5(dir, { recursive: true });
+    const block = formatBlock(event);
+    await appendFile(this.#logPath, block, "utf-8");
+  }
+  // -----------------------------------------------------------------------
+  // 便捷方法 — 封装常见事件类型，减少调用方样板代码
+  // -----------------------------------------------------------------------
+  /** 记录会话开始 */
+  logSessionStart(sessionId, cwd, model, mode) {
+    this.log({ ts: Date.now(), type: "session_start", sessionId, cwd, model, mode });
+  }
+  /** 记录用户消息 */
+  logUserMessage(content) {
+    this.log({ ts: Date.now(), type: "user_message", content });
+  }
+  /** 记录助手文本（一轮中模型输出的完整文本） */
+  logAssistantText(content, round) {
+    this.log({ ts: Date.now(), type: "assistant_text", content, round });
+  }
+  /** 记录工具调用 */
+  logToolCall(name, callId, args, round) {
+    this.log({ ts: Date.now(), type: "tool_call", name, callId, arguments: args, round });
+  }
+  /** 记录工具结果 */
+  logToolResult(name, callId, success, data, error, elapsed, round) {
+    this.log({
+      ts: Date.now(),
+      type: "tool_result",
+      name,
+      callId,
+      success,
+      data: truncate(data),
+      ...error ? { error } : {},
+      ...elapsed !== void 0 ? { elapsed } : {},
+      round
+    });
+  }
+  /** 记录 Token 用量与费用 */
+  logUsage(model, promptTokens, completionTokens, cachedPromptTokens, cost, round) {
+    this.log({
+      ts: Date.now(),
+      type: "usage",
+      model,
+      promptTokens,
+      completionTokens,
+      ...cachedPromptTokens !== void 0 ? { cachedPromptTokens } : {},
+      cost,
+      round
+    });
+  }
+  /** 记录错误 */
+  logError(message, stack) {
+    this.log({ ts: Date.now(), type: "error", message, ...stack ? { stack } : {} });
+  }
+  /** 记录一轮对话完成 */
+  logTurnDone(elapsed, toolRounds) {
+    this.log({ ts: Date.now(), type: "turn_done", elapsed, toolRounds });
+  }
+  /** 记录会话结束 */
+  logSessionEnd(elapsed) {
+    this.log({ ts: Date.now(), type: "session_end", elapsed });
+  }
+  /** 记录反射（工具失败归因注入到下一轮 prompt 时） */
+  logReflections(items) {
+    this.log({ ts: Date.now(), type: "reflection", items });
+  }
+};
+function truncate(text) {
+  if (text.length <= MAX_DATA_LEN) return text;
+  return text.slice(0, MAX_DATA_LEN) + `...[\u5DF2\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${text.length}]`;
+}
+function formatTime(ts) {
+  const d = new Date(ts);
+  const pad = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+var projectRootCache = null;
+function getProjectRoot() {
+  if (projectRootCache !== null) return projectRootCache;
+  try {
+    const here = fileURLToPath(import.meta.url);
+    const segments = here.split(sep);
+    const srcIdx = segments.lastIndexOf("src");
+    projectRootCache = srcIdx > 0 ? segments.slice(0, srcIdx).join(sep) : here;
+  } catch {
+    projectRootCache = "";
+  }
+  return projectRootCache;
+}
+var STACK_FRAME_RE = /\s+at\s+.+?\((.+):(\d+):\d+\)|\s+at\s+(.+):(\d+):\d+/;
+function captureCallerLocation() {
+  let stack;
+  try {
+    const err = new Error();
+    Error.captureStackTrace?.(err, captureCallerLocation);
+    stack = err.stack;
+  } catch {
+    return { file: "<unknown>", line: 0 };
+  }
+  if (!stack) return { file: "<unknown>", line: 0 };
+  const root = getProjectRoot();
+  const lines = stack.split("\n");
+  for (const raw of lines) {
+    const m = STACK_FRAME_RE.exec(raw);
+    if (!m) continue;
+    const filePath = m[1] ?? m[3] ?? "";
+    const lineNo = Number(m[2] ?? m[4] ?? "0");
+    if (!filePath) continue;
+    const normalized = filePath.replace(/^file:\/\/\//, "").replace(/^file:\/\//, "");
+    if (normalized.includes(`${sep}${LOGGER_DIR}${sep}`) || normalized.endsWith(`${sep}${LOGGER_DIR}`)) {
+      continue;
+    }
+    if (normalized.includes(`${sep}node_modules${sep}`)) continue;
+    let rel = normalized;
+    if (root && normalized.startsWith(root)) {
+      rel = normalized.slice(root.length).replace(/^[/\\]/, "") || basename(normalized);
+    }
+    return { file: rel || basename(normalized), line: lineNo };
+  }
+  return { file: "<unknown>", line: 0 };
+}
+var SEPARATOR_WIDTH = 80;
+var SEPARATOR = "\u2500".repeat(SEPARATOR_WIDTH);
+function formatBlock(event) {
+  const header = `[${event.time}] [${event.type}] @ ${event.loc.file}:${event.loc.line}`;
+  const body = JSON.stringify(event, null, 2);
+  return `${SEPARATOR}
+${header}
+${body}
+
+`;
+}
+
 // src/agent/index.ts
 var Session = class _Session {
+  /** 当前会话的消息历史（含 system/user/assistant/tool），可外部只读 */
   #messages = [];
+  /** LLM Provider（DeepSeek 等） */
   #provider;
+  /** 工具注册表（所有可用工具） */
   #toolRegistry;
+  /** 成本追踪器（今日 + 本会话） */
   #costTracker;
+  /** 归一化后的构造选项（带默认值） */
   #options;
+  /** 中止信号控制器（abort() 时触发，传递给 LLM 和工具） */
   #abortController = new AbortController();
+  /** 会话唯一 ID（UUID） */
   #sessionId;
+  /** 持久化存储；传 false 时为 null */
   #store;
+  /** 会话创建时间（毫秒） */
   #createdAt;
+  /** 节流持久化定时器（500ms debounce） */
   #persistTimer = null;
+  /** user 消息 → Checkpoint 映射（仅给 user 消息建点） */
   #checkpoints = /* @__PURE__ */ new Map();
+  /** 最近的失败记录（仅失败的，用于风暴检测） */
   #stormRecords = [];
+  /** 当前会话模式：code（默认）/ plan（只读） */
   #mode = "code";
+  /** 对话日志记录器（写入 .dskcode/logs/） */
+  #logger;
+  /** 风暴检测器（连续 3 次同工具同错码失败时中断本轮） */
+  #stormDetector;
+  /** 失败归因 Reflector（将本轮失败原因拼到下一轮 prompt；null 表示已关闭） */
+  #reflector;
+  /** 本轮工具执行结果（仅在 chat() 循环内使用；用于下一轮注入 reflection） */
+  #lastRoundResults = null;
+  /**
+   * 构造一个 Session。
+   *
+   * @param provider — LLM Provider 实例（必须）
+   * @param tools — 工具列表或已初始化的 ToolRegistry（默认空）
+   * @param costTracker — 成本追踪器（默认新建）
+   * @param options — 会话选项（详见 SessionOptions）
+   *
+   * @sideEffect 创建 .dskcode/logs/ 下的日志文件并写入 session_start 事件
+   */
   constructor(provider, tools = [], costTracker, options) {
     this.#provider = provider;
     if (tools instanceof ToolRegistry) {
@@ -2309,45 +3026,87 @@ var Session = class _Session {
       projectContext: options?.projectContext,
       gate: options?.gate ?? new AlwaysAllowGate(),
       writeRoots: options?.writeRoots ?? [options?.cwd ?? process.cwd()],
-      enableCheckpoint: options?.enableCheckpoint ?? true
+      enableCheckpoint: options?.enableCheckpoint ?? true,
+      enableLog: options?.enableLog ?? true,
+      enableReflection: options?.enableReflection !== false
     };
     this.#sessionId = options?.sessionId ?? SessionStore.newId();
     this.#store = options?.store === false ? null : options?.store ?? new SessionStore();
     this.#createdAt = Date.now();
+    this.#logger = new ConversationLogger(this.#sessionId, this.#options.cwd, {
+      enabled: this.#options.enableLog
+    });
+    this.#logger.logSessionStart(this.#sessionId, this.#options.cwd, this.#provider.model(), this.#mode);
+    this.#stormDetector = new StormDetector({ threshold: 3 });
+    this.#reflector = this.#options.enableReflection ? new Reflector() : null;
   }
+  /** 当前会话的完整消息历史（只读视图） */
   get messages() {
     return this.#messages;
   }
+  /** 本次会话累计成本（人民币元） */
   get accumulatedCost() {
     return this.#costTracker.sessionTotalCost;
   }
+  /** 成本追踪器（含今日总成本、会话成本、模型维度统计） */
   get costTracker() {
     return this.#costTracker;
   }
+  /** 当前模型标识（如 "deepseek-v4-flash"） */
   get model() {
     return this.#provider.model();
   }
+  /** 工具注册表（可外部读 / 运行时 register） */
   get toolRegistry() {
     return this.#toolRegistry;
   }
+  /** 当前模式："code" | "plan" */
   get mode() {
     return this.#mode;
   }
+  /** 会话 ID（UUID） */
   get id() {
     return this.#sessionId;
   }
+  /** 持久化存储实例（禁用持久化时为 null） */
   get store() {
     return this.#store;
   }
+  /** 会话创建时间戳（毫秒） */
   get createdAt() {
     return this.#createdAt;
   }
+  /**
+   * 切换会话模式。
+   *
+   * @param mode — "code"：全部工具；"plan"：只暴露只读工具
+   * @returns 设置后的模式（便于链式调用）
+   */
   setMode(mode) {
     this.#mode = mode;
     return this.#mode;
   }
+  /**
+   * chat() — 接收一轮用户输入，串起 LLM 调用 / 工具执行 / 风暴中断 / 持久化。
+   *
+   * 主循环每轮做：
+   * 1. 构建 system prompt + 裁剪消息 + 拼装 apiMessages
+   * 2. 调 provider.chat() 拿流式 chunks，向外 yield text_delta / usage 事件
+   * 3. 若本轮有 tool_calls：
+   *    a. 先调 StormDetector.shouldBreak 判定是否中断风暴
+   *    b. 调 ToolExecutor.executeBatch 执行工具
+   *    c. 把工具结果 yield 出去并写入 messages
+   * 4. 持续到 LLM 不再调工具 或 达到 maxToolRounds
+   *
+   * @param userInput — 用户本轮输入
+   * @param opts — 透传给 provider.chat() 的 ChatOptions（thinking / tool_choice 等）
+   * @yields AgentEvent — text_delta / tool_calls / tool_result / usage / done / error
+   *
+   * @sideEffect 写入 messages、logger、costTracker、可能触发 checkpoint / persist
+   */
   async *chat(userInput, opts) {
     this.#messages.push({ role: "user", content: userInput });
+    this.#logger.logUserMessage(userInput);
     const userMsgIndex = this.#messages.length - 1;
     if (this.#options.enableCheckpoint) {
       try {
@@ -2358,9 +3117,23 @@ var Session = class _Session {
     }
     const startTime = Date.now();
     let toolRounds = 0;
+    const toolExecutor = this.#buildToolExecutor();
     try {
       while (toolRounds < this.#options.maxToolRounds) {
-        const systemPrompt = this.#buildSystemPrompt();
+        let systemPrompt = this.#buildSystemPrompt();
+        if (this.#reflector && this.#lastRoundResults) {
+          const reflections = this.#reflector.analyze(this.#lastRoundResults, {
+            writeRoots: this.#options.writeRoots,
+            cwd: this.#options.cwd
+          });
+          if (reflections.length > 0) {
+            systemPrompt = this.#reflector.injectIntoPrompt(systemPrompt, reflections);
+            this.#logger.logReflections(
+              reflections.map((r) => ({ category: r.category, toolName: r.toolName, hint: r.hint }))
+            );
+          }
+          this.#lastRoundResults = null;
+        }
         const [trimmed] = trimMessages(
           [...this.#messages],
           {
@@ -2371,7 +3144,7 @@ var Session = class _Session {
           }
         );
         const apiMessages = buildApiMessages(systemPrompt, trimmed);
-        const toolDefs = this.#buildToolDefinitions();
+        const toolDefs = buildToolDefinitions(this.#toolRegistry, this.#mode);
         const stream = this.#provider.chat(apiMessages, {
           signal: this.#abortController.signal,
           tools: toolDefs.length > 0 ? toolDefs : void 0,
@@ -2380,30 +3153,91 @@ var Session = class _Session {
           responseFormat: opts?.responseFormat,
           toolChoice: opts?.toolChoice
         });
+        const modelId = this.#provider.model();
         let accumulatedText = "";
         let lastUsage;
         let lastToolCalls;
         let _lastFinishReason = null;
+        let estimatedInputTokens = 0;
+        for (const m of apiMessages) {
+          estimatedInputTokens += this.#provider.countTokens(m.content) + 10;
+        }
+        let lastEmitMs = 0;
+        const EST_EMIT_INTERVAL_MS = 300;
         for await (const chunk of stream) {
           if (chunk.content) {
             accumulatedText += chunk.content;
             yield { type: "text_delta", content: chunk.content };
+            const now = Date.now();
+            if (now - lastEmitMs >= EST_EMIT_INTERVAL_MS) {
+              lastEmitMs = now;
+              const estOutput = this.#provider.countTokens(accumulatedText);
+              const estUsage = {
+                promptTokens: estimatedInputTokens,
+                completionTokens: estOutput
+              };
+              const estCost = calculateCost(estUsage, modelId);
+              yield {
+                type: "usage",
+                usage: estUsage,
+                model: modelId,
+                cost: estCost.totalCost,
+                estimated: true
+              };
+            }
           }
           if (chunk.toolCalls && chunk.toolCalls.length > 0) lastToolCalls = chunk.toolCalls;
-          if (chunk.usage) lastUsage = chunk.usage;
+          if (chunk.usage) {
+            lastUsage = chunk.usage;
+            const realCost = calculateCost(chunk.usage, modelId);
+            yield {
+              type: "usage",
+              usage: chunk.usage,
+              model: modelId,
+              cost: realCost.totalCost,
+              estimated: false
+            };
+          }
           if (chunk.finishReason) _lastFinishReason = chunk.finishReason;
         }
+        if (accumulatedText && !lastUsage) {
+          const estOutput = this.#provider.countTokens(accumulatedText);
+          const estUsage = {
+            promptTokens: estimatedInputTokens,
+            completionTokens: estOutput
+          };
+          const estCost = calculateCost(estUsage, modelId);
+          yield {
+            type: "usage",
+            usage: estUsage,
+            model: modelId,
+            cost: estCost.totalCost,
+            estimated: true
+          };
+        }
         if (lastUsage) {
-          const modelId = this.#provider.model();
           this.#costTracker.record(lastUsage, modelId);
+          const cost = calculateCost(lastUsage, modelId);
+          this.#logger.logUsage(
+            modelId,
+            lastUsage.promptTokens,
+            lastUsage.completionTokens,
+            lastUsage.cachedPromptTokens,
+            cost.totalCost,
+            toolRounds
+          );
           yield { type: "usage", usage: lastUsage, model: modelId };
         }
         const assistantMsg = { role: "assistant", content: accumulatedText };
         if (lastToolCalls && lastToolCalls.length > 0) assistantMsg.toolCalls = lastToolCalls;
         this.#messages.push(assistantMsg);
+        this.#logger.logAssistantText(accumulatedText, toolRounds);
         if (lastToolCalls && lastToolCalls.length > 0) {
           yield { type: "tool_calls", calls: lastToolCalls };
-          const stormBroken = this.#checkStormBreak(lastToolCalls);
+          for (const tc of lastToolCalls) {
+            this.#logger.logToolCall(tc.name, tc.id, tc.arguments, toolRounds);
+          }
+          const stormBroken = this.#stormDetector.shouldBreak(this.#stormRecords, lastToolCalls);
           if (stormBroken) {
             const stormMsg = "\n\u26A0\uFE0F \u540C\u4E00\u5DE5\u5177\u91CD\u590D\u51FA\u9519\uFF0C\u5DF2\u5F3A\u5236\u5207\u6362\u7B56\u7565\n";
             yield { type: "text_delta", content: stormMsg };
@@ -2413,10 +3247,29 @@ var Session = class _Session {
             toolRounds++;
             continue;
           }
-          const results = await this.#executeBatch(lastToolCalls);
+          const results = await toolExecutor.executeBatch(lastToolCalls);
           this.#stormRecords = results.records;
+          console.log("results", results);
+          this.#lastRoundResults = results.items.map((it) => {
+            const tool = this.#toolRegistry.get(it.name);
+            return {
+              name: it.name,
+              result: it.result,
+              kind: tool?.kind ?? "other" /* Other */,
+              recentSameTool: results.records.filter((r) => r.name === it.name).map((r) => ({ success: r.success, error: r.error }))
+            };
+          });
           for (const item of results.items) {
             yield { type: "tool_result", name: item.name, result: item.result };
+            this.#logger.logToolResult(
+              item.name,
+              item.callId,
+              item.result.success,
+              item.result.data,
+              item.result.error,
+              void 0,
+              toolRounds
+            );
             let toolContent = item.result.data;
             if (item.result.diff && item.result.diff.patch) toolContent += `
 
@@ -2436,107 +3289,29 @@ ${item.result.diff.patch}`;
     } catch (err) {
       if (err instanceof DOMException && err.name === "AbortError") return;
       if (err instanceof Error && err.name === "AbortError") return;
+      this.#logger.logError(
+        err instanceof Error ? err.message : String(err),
+        err instanceof Error ? err.stack : void 0
+      );
       yield { type: "error", error: err instanceof Error ? err : new Error(String(err)) };
       return;
     }
     const elapsed = Date.now() - startTime;
+    this.#logger.logTurnDone(elapsed, toolRounds);
     void this.#persist();
     await this.#costTracker.flush().catch(() => {
     });
     yield { type: "done", elapsed };
   }
-  async #executeBatch(calls) {
-    const toolCtx = {
-      cwd: this.#options.cwd,
-      signal: this.#abortController.signal,
-      writeRoots: this.#options.writeRoots
-    };
-    const allReadOnly = calls.every((tc) => {
-      const tool = this.#toolRegistry.get(tc.name);
-      return tool ? isReadOnly(tool.kind) : true;
-    });
-    if (allReadOnly && calls.length > 1) {
-      const MAX_PARALLEL = 8;
-      const items2 = [];
-      const records2 = [];
-      for (let i = 0; i < calls.length; i += MAX_PARALLEL) {
-        const batch = calls.slice(i, i + MAX_PARALLEL);
-        const promises = batch.map((tc) => this.#executeOne(tc, toolCtx));
-        const batchResults = await Promise.all(promises);
-        for (const r of batchResults) {
-          items2.push(r.item);
-          records2.push(r.record);
-        }
-      }
-      return { items: items2, records: records2 };
-    }
-    const items = [];
-    const records = [];
-    for (const tc of calls) {
-      const r = await this.#executeOne(tc, toolCtx);
-      items.push(r.item);
-      records.push(r.record);
-    }
-    return { items, records };
-  }
-  async #executeOne(tc, ctx) {
-    const toolName = tc.name;
-    const timestamp = Date.now();
-    const tool = this.#toolRegistry.get(toolName);
-    if (!tool) {
-      const errMsg = `\u5DE5\u5177 "${toolName}" \u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u7981\u7528`;
-      return {
-        item: { name: toolName, callId: tc.id, result: { success: false, data: errMsg, error: "TOOL_NOT_FOUND" } },
-        record: { name: toolName, success: false, error: "TOOL_NOT_FOUND", timestamp }
-      };
-    }
-    let toolArgs;
-    try {
-      toolArgs = tc.arguments ? JSON.parse(tc.arguments) : {};
-    } catch {
-      toolArgs = {};
-    }
-    const gateResult = await this.#options.gate.check(toolName, toolArgs);
-    if (!gateResult) {
-      const errMsg = `\u5DE5\u5177 "${toolName}" \u88AB\u6743\u9650\u95E8\u62D2\u7EDD`;
-      return {
-        item: { name: toolName, callId: tc.id, result: { success: false, data: errMsg, error: "GATE_DENIED" } },
-        record: { name: toolName, success: false, error: "GATE_DENIED", timestamp }
-      };
-    }
-    if (!isReadOnly(tool.kind)) {
-      const maybePreview = tool.preview;
-      if (typeof maybePreview === "function") {
-        try {
-          await maybePreview(toolArgs, ctx);
-        } catch {
-        }
-      }
-    }
-    try {
-      const result = await tool.execute(toolArgs, ctx);
-      return {
-        item: { name: toolName, callId: tc.id, result },
-        record: { name: toolName, success: result.success, error: result.error, timestamp }
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const errorResult = { success: false, data: `\u5DE5\u5177 "${toolName}" \u6267\u884C\u5F02\u5E38\uFF1A${message}`, error: "EXECUTION_ERROR" };
-      return {
-        item: { name: toolName, callId: tc.id, result: errorResult },
-        record: { name: toolName, success: false, error: "EXECUTION_ERROR", timestamp }
-      };
-    }
-  }
-  #checkStormBreak(currentCalls) {
-    if (this.#stormRecords.length < 3) return false;
-    const recentErrors = this.#stormRecords.slice(-3);
-    if (recentErrors.length < 3) return false;
-    const first = recentErrors[0];
-    const allSame = recentErrors.every((r) => r.name === first.name && r.error === first.error && !r.success);
-    if (!allSame) return false;
-    return currentCalls.some((tc) => tc.name === first.name);
-  }
+  // -------------------------------------------------------------------------
+  // 持久化与恢复
+  // -------------------------------------------------------------------------
+  /**
+   * 中止当前会话：触发 AbortController，停止流式 LLM 和正在执行的工具。
+   * 同时清掉节流持久化定时器。
+   *
+   * @sideEffect abort 当前 chat 循环、取消所有 #abortController 监听者
+   */
   abort() {
     this.#abortController.abort();
     if (this.#persistTimer) {
@@ -2544,15 +3319,34 @@ ${item.result.diff.patch}`;
       this.#persistTimer = null;
     }
   }
+  /**
+   * 刷新日志缓冲，确保所有已记录的事件落盘。
+   * 通常在进程退出前调用，避免日志丢失。
+   *
+   * @sideEffect 写入 .dskcode/logs/ 下的日志文件
+   */
+  async flushLog() {
+    await this.#logger.flush();
+  }
+  /**
+   * 清空消息历史、会话成本、风暴记录、checkpoints。
+   * 注意：不会清掉磁盘上的会话记录（用 delete() 删除），仅重置内存状态。
+   *
+   * @sideEffect 抹掉 messages / costTracker / stormRecords / checkpoints
+   */
   reset() {
     this.#messages.length = 0;
     this.#costTracker.resetSession();
     this.#stormRecords = [];
     this.#checkpoints.clear();
+    this.#lastRoundResults = null;
   }
-  // -------------------------------------------------------------------------
-  // 持久化与恢复
-  // -------------------------------------------------------------------------
+  /**
+   * 立即把当前状态写入持久化（不等 500ms debounce）。
+   * 用于 UI 上"立即保存"按钮或异常退出前的最后兜底。
+   *
+   * @sideEffect 调用 #doPersist()，写入磁盘
+   */
   async persistNow() {
     if (this.#persistTimer) {
       clearTimeout(this.#persistTimer);
@@ -2560,6 +3354,12 @@ ${item.result.diff.patch}`;
     }
     await this.#doPersist();
   }
+  /**
+   * 节流持久化：500ms 内多次调用只会真正落盘一次。
+   * 通过 setTimeout + timer.refresh() 实现 debounce。
+   *
+   * @sideEffect 调度一个 500ms 后的 #doPersist() 任务
+   */
   #persist() {
     if (!this.#store) return;
     if (this.#persistTimer) {
@@ -2572,6 +3372,12 @@ ${item.result.diff.patch}`;
     }, 500);
     this.#persistTimer.unref();
   }
+  /**
+   * 真正执行持久化：构造 StoredSession 并写入 store。
+   * 失败仅 console.error，不抛给调用方（持久化失败不应阻塞对话）。
+   *
+   * @sideEffect 写磁盘 ~/.dskcode/sessions/<id>.json
+   */
   async #doPersist() {
     if (!this.#store) return;
     const stored = {
@@ -2590,12 +3396,24 @@ ${item.result.diff.patch}`;
       console.error("[Session] \u6301\u4E45\u5316\u5931\u8D25:", err);
     }
   }
+  /**
+   * 从消息历史推导会话标题：取第一条非空 user 消息的前 40 字。
+   * 无任何 user 消息时返回 "新会话"。
+   *
+   * @pure 不修改任何状态
+   */
   #deriveTitle() {
     for (const m of this.#messages) {
       if (m.role === "user" && m.content.trim()) return m.content.trim().slice(0, 40);
     }
     return "\u65B0\u4F1A\u8BDD";
   }
+  /**
+   * 把内存 messages 转成可持久化的 StoredSession["messages"]。
+   * 给 user 消息挂上对应 checkpoint（若存在），用于 rewind 时文件回退。
+   *
+   * @pure 不修改任何状态
+   */
   #serializeMessages() {
     return this.#messages.map((msg, idx) => {
       const checkpoint = this.#checkpoints.get(idx);
@@ -2603,6 +3421,19 @@ ${item.result.diff.patch}`;
       return { ...msg };
     });
   }
+  /**
+   * 静态方法：从磁盘恢复一个之前保存的 Session。
+   *
+   * @param id — 之前 SessionStore 保存的会话 ID
+   * @param provider — LLM Provider（必须）
+   * @param tools — 工具列表/Registry（必须重新提供，因为工具不持久化）
+   * @param costTracker — 成本追踪器（可选）
+   * @param options — 会话选项（sessionId / store 必须与持久化 ID 对应）
+   * @returns 恢复后的 Session 实例
+   * @throws 持久化被禁用时、ID 不存在时抛错
+   *
+   * @sideEffect 从磁盘读 messages + checkpoints
+   */
   static async resume(id, provider, tools = [], costTracker, options) {
     const store = options?.store === false ? null : options?.store ?? new SessionStore();
     if (!store) throw new Error("resume \u9700\u8981\u542F\u7528\u6301\u4E45\u5316\uFF08options.store \u4E0D\u80FD\u4E3A false\uFF09");
@@ -2628,6 +3459,13 @@ ${item.result.diff.patch}`;
   // -------------------------------------------------------------------------
   // 检查点与 Rewind
   // -------------------------------------------------------------------------
+  /**
+   * 列出所有 user 消息对应的 checkpoint（按 index 升序）。
+   * 用于 UI 展示 /rewind 列表。
+   *
+   * @returns 每个元素的 index = messages 数组索引，可直接传给 rewind()
+   * @pure 不修改任何状态
+   */
   listCheckpoints() {
     const result = [];
     for (const [index, checkpoint] of this.#checkpoints) {
@@ -2637,6 +3475,25 @@ ${item.result.diff.patch}`;
     }
     return result.sort((a, b) => a.index - b.index);
   }
+  /**
+   * rewind — 把消息历史截断到 targetIndex 对应的 user 消息，
+   * 并尝试把文件工作区也回退到那一刻。
+   *
+   * @param targetIndex — 要回退到的 user 消息索引（来自 listCheckpoints()）
+   * @returns
+   *   - `{ ok: true, fileRestored }`：成功；fileRestored 表示工作区是否也被还原
+   *   - `{ ok: false, error }`：失败（无效索引 / 非 user / 无 checkpoint / 文件恢复失败）
+   *
+   * 行为：
+   * 1. 截断 messages 数组到 targetIndex + 1
+   * 2. 移除并丢弃所有 > targetIndex 的 checkpoints
+   * 3. 若目标 checkpoint 是 git 仓库：
+   *    - 有 stashSha：恢复该 stash（force）
+   *    - 无 stashSha：把工作区 restore 到 HEAD 干净状态
+   * 4. 触发 #persist() 把截断后的状态写盘
+   *
+   * @sideEffect 改写 messages、checkpoints、磁盘
+   */
   async rewind(targetIndex) {
     if (targetIndex < 0 || targetIndex >= this.#messages.length) {
       return { ok: false, error: `\u65E0\u6548\u7684\u6D88\u606F\u7D22\u5F15 ${targetIndex}` };
@@ -2676,19 +3533,58 @@ ${item.result.diff.patch}`;
     this.#persist();
     return { ok: true, fileRestored };
   }
+  /**
+   * 是否存在可用的 checkpoint（决定 UI 是否显示 /rewind 入口）。
+   *
+   * @pure 不修改任何状态
+   */
   hasCheckpoints() {
     return this.listCheckpoints().length > 0;
   }
+  /**
+   * 彻底删除会话：从磁盘移除 SessionStore 条目、丢弃所有 checkpoint、关闭日志。
+   * 删除后该 Session 实例不应再被使用。
+   *
+   * @sideEffect 删磁盘文件、清 checkpoints、flush 并关闭 logger
+   */
   async delete() {
     if (this.#store) await this.#store.delete(this.#sessionId);
     for (const cp2 of this.#checkpoints.values()) {
       void discardCheckpoint(cp2);
     }
     this.#checkpoints.clear();
+    this.#logger.logSessionEnd(Date.now() - this.#createdAt);
+    await this.#logger.flush();
   }
   // -------------------------------------------------------------------------
   // 内部方法
   // -------------------------------------------------------------------------
+  /**
+   * 构建本轮使用的工具执行器（每次 chat() 调用一次，绑定当前 signal）。
+   * 每次新建确保 abort signal 是当下有效的，且 #baseCtx 不会被多次调用共享篡改。
+   *
+   * @returns 新的 ToolExecutor 实例
+   * @pure 仅组装参数，不修改任何状态
+   */
+  #buildToolExecutor() {
+    return new ToolExecutor({
+      registry: this.#toolRegistry,
+      gate: this.#options.gate,
+      baseCtx: {
+        cwd: this.#options.cwd,
+        signal: this.#abortController.signal,
+        writeRoots: this.#options.writeRoots
+      }
+    });
+  }
+  /**
+   * 构建 system prompt：注入当前模型、cwd、工具清单、项目上下文。
+   * plan 模式使用 buildPlanSystemPrompt（只读工具 + 计划输出格式），
+   * code 模式使用 buildSystemPrompt。
+   *
+   * @returns 渲染好的 prompt 字符串
+   * @pure 不修改任何状态
+   */
   #buildSystemPrompt() {
     const enabledTools = this.#toolRegistry.list();
     const toolDescs = enabledTools.map((t) => ({
@@ -2706,17 +3602,10 @@ ${item.result.diff.patch}`;
     if (this.#mode === "plan") return buildPlanSystemPrompt(opts);
     return buildSystemPrompt(opts);
   }
-  #buildToolDefinitions() {
-    const tools = this.#mode === "plan" ? this.#toolRegistry.listReadTools() : this.#toolRegistry.list();
-    return tools.map((t) => ({
-      type: "function",
-      function: { name: t.name, description: t.description, parameters: t.parameters }
-    }));
-  }
 };
 
 // src/tool/sandbox.ts
-import { resolve, relative, isAbsolute } from "path";
+import { resolve, relative as relative2, isAbsolute } from "path";
 import { realpath as realpath2 } from "fs/promises";
 import { spawn } from "child_process";
 import process2 from "process";
@@ -2735,7 +3624,7 @@ async function realPath(target) {
     const parent = resolve(target, "..");
     try {
       const realParent = await realpath2(parent);
-      return resolve(realParent, relative(parent, target));
+      return resolve(realParent, relative2(parent, target));
     } catch {
       return resolve(target);
     }
@@ -2748,7 +3637,7 @@ async function confine(allowedRoots, target) {
   const realTarget = await realPath(target);
   for (const root of allowedRoots) {
     const realRoot = await realPath(root);
-    const rel = relative(realRoot, realTarget);
+    const rel = relative2(realRoot, realTarget);
     if (!rel.startsWith("..") && rel !== "" && !rel.startsWith("/") && !rel.startsWith("\\")) {
       return { ok: true };
     }
@@ -2780,6 +3669,10 @@ async function execCommand(command, args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS, s
       spawnCmd = command;
       spawnArgs = args;
       useShell = false;
+      if (isWindows && spawnCmd === "cmd" && spawnArgs[0] === "/c") {
+        const prefixed = `chcp 65001 >nul && ${spawnArgs[1] ?? ""}`;
+        spawnArgs = ["/c", prefixed];
+      }
     } else {
       useShell = !isWindows;
       spawnCmd = isWindows ? "cmd" : command;
@@ -2794,10 +3687,10 @@ async function execCommand(command, args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS, s
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (data) => {
-      stdout += data.toString();
+      stdout += data.toString("utf8");
     });
     child.stderr.on("data", (data) => {
-      stderr += data.toString();
+      stderr += data.toString("utf8");
     });
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
@@ -3141,7 +4034,7 @@ async function writeFileWithEol(filePath, originalContent, newContent) {
 // src/tool/builtins/read-file.ts
 import { readFile as readFile5, stat } from "fs/promises";
 import { open } from "fs/promises";
-import { relative as relative2 } from "path";
+import { relative as relative3 } from "path";
 async function checkBinary(filePath) {
   const fileHandle = await open(filePath, "r");
   try {
@@ -3224,7 +4117,7 @@ var readFileTool = {
       const tailHint = remaining > 0 ? `
 
 [\u8FD8\u6709 ${remaining} \u884C\uFF1B\u4F7F\u7528 startLine=${endLine + 1} \u7EE7\u7EED\u67E5\u770B]` : "";
-      const relPath = relative2(ctx.cwd, filePath).replace(/\\/g, "/");
+      const relPath = relative3(ctx.cwd, filePath).replace(/\\/g, "/");
       const rangeLabel = startLine > 0 || endLine < lines.length ? `\u7B2C ${startLine + 1}-${endLine} \u884C` : `${lines.length} \u884C`;
       return {
         success: true,
@@ -3243,8 +4136,8 @@ var readFileTool = {
 };
 
 // src/tool/builtins/write-file.ts
-import { mkdir as mkdir5, readFile as readFile6 } from "fs/promises";
-import { dirname, relative as relative3, basename } from "path";
+import { mkdir as mkdir6, readFile as readFile6 } from "fs/promises";
+import { dirname, relative as relative4, basename as basename2 } from "path";
 var writeFileTool = {
   name: "write_file",
   kind: "edit" /* Edit */,
@@ -3286,7 +4179,7 @@ var writeFileTool = {
         existedBefore = true;
       } catch {
       }
-      await mkdir5(dirname(filePath), { recursive: true });
+      await mkdir6(dirname(filePath), { recursive: true });
       const content = args.content;
       await writeFileWithEol(filePath, oldContent, content);
       const diff = computeFileDiff(oldContent, content, filePath);
@@ -3295,11 +4188,11 @@ var writeFileTool = {
       const byteSize = Buffer.byteLength(content, "utf-8");
       const action = existedBefore ? "\u5DF2\u4FEE\u6539" : "\u5DF2\u521B\u5EFA";
       const diffSummary = existedBefore ? `\uFF0C+${diff.additions} -${diff.deletions}` : `\uFF0C+${diff.additions} \u884C\uFF08\u65B0\u5EFA\uFF09`;
-      const fileName = basename(filePath);
+      const fileName = basename2(filePath);
       const summary = existedBefore ? `\u{1F4DD} \u4FEE\u6539: ${fileName} (+${diff.additions} -${diff.deletions})` : `\u{1F4DD} \u65B0\u5EFA: ${fileName} (+${diff.additions} \u884C)`;
       return {
         success: true,
-        data: `\u6587\u4EF6${action}\uFF1A${relative3(ctx.cwd, filePath).replace(/\\/g, "/")}\uFF08${lineCount} \u884C\uFF0C${byteSize} \u5B57\u8282${diffSummary}\uFF09`,
+        data: `\u6587\u4EF6${action}\uFF1A${relative4(ctx.cwd, filePath).replace(/\\/g, "/")}\uFF08${lineCount} \u884C\uFF0C${byteSize} \u5B57\u8282${diffSummary}\uFF09`,
         summary,
         diff
       };
@@ -3316,7 +4209,7 @@ var writeFileTool = {
 
 // src/tool/builtins/edit-file.ts
 import { readFile as readFile7 } from "fs/promises";
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 var editFileTool = {
   name: "edit_file",
   kind: "edit" /* Edit */,
@@ -3384,7 +4277,7 @@ var editFileTool = {
       const oldLines = args.old_text.split("\n").length;
       const newLines = args.new_text.split("\n").length;
       const diffSummary = `+${diff.additions} -${diff.deletions}`;
-      const summary = `\u{1F4DD} \u4FEE\u6539: ${basename2(filePath)} (+${diff.additions} -${diff.deletions})`;
+      const summary = `\u{1F4DD} \u4FEE\u6539: ${basename3(filePath)} (+${diff.additions} -${diff.deletions})`;
       return {
         success: true,
         data: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}
@@ -3407,7 +4300,7 @@ ${oldLines} \u884C \u2192 ${newLines} \u884C
 
 // src/tool/builtins/multi-edit.ts
 import { readFile as readFile8 } from "fs/promises";
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 var multiEditTool = {
   name: "multi_edit",
   kind: "edit" /* Edit */,
@@ -3505,7 +4398,7 @@ var multiEditTool = {
         data: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}
 \u5171\u6267\u884C ${args.edits.length} \u6B65\u66FF\u6362
 \u53D8\u66F4\uFF1A+${diff.additions} -${diff.deletions}`,
-        summary: `\u{1F4DD} \u4FEE\u6539: ${basename3(filePath)} (${args.edits.length} \u6B65, +${diff.additions} -${diff.deletions})`,
+        summary: `\u{1F4DD} \u4FEE\u6539: ${basename4(filePath)} (${args.edits.length} \u6B65, +${diff.additions} -${diff.deletions})`,
         diff
       };
     } catch (err) {
@@ -3521,7 +4414,7 @@ var multiEditTool = {
 
 // src/tool/builtins/delete-range.ts
 import { readFile as readFile9 } from "fs/promises";
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
 function findUniqueLine(lines, anchor, label) {
   const matches = [];
   for (let i = 0; i < lines.length; i++) {
@@ -3617,7 +4510,7 @@ var deleteRangeTool = {
       const diff = computeFileDiff(content, newContent, filePath);
       diff.existedBefore = true;
       const deletedLines = rangeEnd - rangeStart + 1;
-      const summary = `\u{1F4DD} \u4FEE\u6539: ${basename4(filePath)} (\u5220 ${deletedLines} \u884C, +${diff.additions} -${diff.deletions})`;
+      const summary = `\u{1F4DD} \u4FEE\u6539: ${basename5(filePath)} (\u5220 ${deletedLines} \u884C, +${diff.additions} -${diff.deletions})`;
       return {
         success: true,
         data: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}
@@ -3639,17 +4532,62 @@ var deleteRangeTool = {
 
 // src/tool/builtins/bash.ts
 import process3 from "process";
+import { existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
 var isWindows2 = process3.platform === "win32";
+function detectShell() {
+  if (!isWindows2) {
+    return {
+      bin: "sh",
+      args: ["-c"],
+      label: "sh",
+      hint: "\u5F53\u524D shell \u662F bash \u517C\u5BB9\u8BED\u6CD5\uFF0C\u652F\u6301 pwd/ls/&&/\u7BA1\u9053\u7B49\u6807\u51C6 Unix \u5DE5\u5177\u3002"
+    };
+  }
+  const envBash = process3.env.DSKCODE_BASH;
+  if (envBash && existsSync3(envBash)) {
+    return { bin: envBash, args: ["-c"], label: "Git Bash", hint: SHELL_HINT_BASH };
+  }
+  const roots = [
+    process3.env.ProgramFiles,
+    process3.env["ProgramFiles(x86)"],
+    process3.env.LOCALAPPDATA ? join6(process3.env.LOCALAPPDATA, "Programs") : null,
+    // 非 C 盘安装（你机器就是 D 盘），枚举几个常见盘符根
+    "D:\\Program Files",
+    "E:\\Program Files"
+  ].filter((v) => Boolean(v));
+  for (const root of roots) {
+    for (const sub of ["Git\\bin\\bash.exe", "Git\\usr\\bin\\bash.exe"]) {
+      const candidate = join6(root, sub);
+      if (existsSync3(candidate)) {
+        return { bin: candidate, args: ["-c"], label: "Git Bash", hint: SHELL_HINT_BASH };
+      }
+    }
+  }
+  return {
+    bin: "cmd",
+    args: ["/c"],
+    label: "cmd.exe",
+    hint: "\u5F53\u524D shell \u662F Windows cmd.exe\u3002\u8BF7\u4F7F\u7528 cmd \u8BED\u6CD5\uFF1A\u8DEF\u5F84\u7528\u53CD\u659C\u6760\u6216\u6B63\u659C\u6760\u5747\u53EF\u3001\u547D\u4EE4\u94FE\u7528 & \u6216\u6362\u884C\uFF0C\u907F\u514D\u4F7F\u7528 pwd/ls/&& \u7B49 Unix \u547D\u4EE4\u3002"
+  };
+}
+var SHELL_HINT_BASH = "\u5F53\u524D shell \u662F bash \u517C\u5BB9\u8BED\u6CD5\uFF0C\u652F\u6301 pwd/ls/&&/\u7BA1\u9053\u7B49\u6807\u51C6 Unix \u5DE5\u5177\u3002";
+var SHELL_INFO = detectShell();
 var bashTool = {
   name: "bash",
   kind: "other" /* Other */,
-  description: "\u5728 shell \u4E2D\u6267\u884C\u547D\u4EE4\u3002\u8FD4\u56DE\u6807\u51C6\u8F93\u51FA\u3001\u6807\u51C6\u9519\u8BEF\u548C\u9000\u51FA\u7801\u3002\u652F\u6301\u8D85\u65F6\u63A7\u5236\u548C\u4FE1\u53F7\u4E2D\u6B62\u3002\u9002\u7528\u4E8E\u8FD0\u884C\u6784\u5EFA\u3001\u6D4B\u8BD5\u3001Git \u64CD\u4F5C\u7B49\u547D\u4EE4\u3002",
+  description: [
+    "\u5728 shell \u4E2D\u6267\u884C\u547D\u4EE4\uFF0C\u8FD4\u56DE stdout / stderr / \u9000\u51FA\u7801\u3002\u652F\u6301\u8D85\u65F6\u63A7\u5236\u548C\u4FE1\u53F7\u4E2D\u6B62\u3002",
+    `\u5F53\u524D shell\uFF1A${SHELL_INFO.label}\u3002${SHELL_INFO.hint}`,
+    "\u8BFB\u53D6\u6587\u4EF6\u8BF7\u4F18\u5148\u4F7F\u7528 read_file \u5DE5\u5177\uFF0C\u4E0D\u8981\u7528 cat/type/Get-Content\uFF1B",
+    "\u641C\u7D22\u4EE3\u7801\u7528 grep / glob\uFF0C\u5217\u76EE\u5F55\u7528 ls\u2014\u2014\u8FD9\u4E9B\u4E13\u7528\u5DE5\u5177\u5728\u6240\u6709\u5E73\u53F0\u90FD\u53EF\u7528\u4E14\u65E0\u9700\u5173\u5FC3 shell \u8BED\u6CD5\u3002"
+  ].join(""),
   parameters: {
     type: "object",
     properties: {
       command: {
         type: "string",
-        description: "\u8981\u6267\u884C\u7684 shell \u547D\u4EE4"
+        description: `\u8981\u6267\u884C\u7684 shell \u547D\u4EE4\uFF08\u5F53\u524D shell\uFF1A${SHELL_INFO.label}\uFF09`
       },
       timeout: {
         type: "number",
@@ -3665,8 +4603,8 @@ var bashTool = {
     }
     const timeout = args.timeout ?? ctx.timeout ?? getDefaultTimeout();
     try {
-      const shellCommand = isWindows2 ? "cmd" : "sh";
-      const shellArgs = isWindows2 ? ["/c", args.command] : ["-c", args.command];
+      const shellCommand = SHELL_INFO.bin ?? "cmd";
+      const shellArgs = [...SHELL_INFO.args, args.command];
       const result = await execCommand(
         shellCommand,
         shellArgs,
@@ -3707,7 +4645,7 @@ ${truncateOutput(result.stderr)}`);
 
 // src/tool/builtins/glob.ts
 import { readdir as readdir3, stat as stat2 } from "fs/promises";
-import { join as join5, relative as relative4, isAbsolute as isAbsolute2 } from "path";
+import { join as join7, relative as relative5, isAbsolute as isAbsolute2 } from "path";
 function globToRegex(pattern) {
   let regexStr = pattern;
   regexStr = regexStr.replace(/\*\*\//g, "<<GLOBSTAR_SLASH>>");
@@ -3732,8 +4670,8 @@ async function walkDir(dir, baseDir) {
     if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
       continue;
     }
-    const fullPath = join5(dir, entry.name);
-    const relPath = relative4(baseDir, fullPath);
+    const fullPath = join7(dir, entry.name);
+    const relPath = relative5(baseDir, fullPath);
     if (entry.isDirectory()) {
       results.push(...await walkDir(fullPath, baseDir));
     } else {
@@ -3765,7 +4703,7 @@ var globTool = {
     if (!args?.pattern || typeof args.pattern !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 pattern", error: "INVALID_ARGS" };
     }
-    const searchDir = args.directory ? isAbsolute2(args.directory) ? args.directory : join5(ctx.cwd, args.directory) : ctx.cwd;
+    const searchDir = args.directory ? isAbsolute2(args.directory) ? args.directory : join7(ctx.cwd, args.directory) : ctx.cwd;
     const regex = globToRegex(args.pattern);
     try {
       const dirStat = await stat2(searchDir);
@@ -3805,7 +4743,7 @@ var globTool = {
 
 // src/tool/builtins/grep.ts
 import { readdir as readdir4, readFile as readFile10, stat as stat3 } from "fs/promises";
-import { join as join6, relative as relative5, isAbsolute as isAbsolute3 } from "path";
+import { join as join8, relative as relative6, isAbsolute as isAbsolute3 } from "path";
 async function collectFiles(dir, extension, maxFiles = 200) {
   const results = [];
   let entries;
@@ -3819,7 +4757,7 @@ async function collectFiles(dir, extension, maxFiles = 200) {
     if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist")) {
       continue;
     }
-    const fullPath = join6(dir, entry.name);
+    const fullPath = join8(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...await collectFiles(fullPath, extension, maxFiles - results.length));
     } else {
@@ -3866,7 +4804,7 @@ var grepTool = {
     if (!args?.pattern || typeof args.pattern !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 pattern", error: "INVALID_ARGS" };
     }
-    const searchDir = args.directory ? isAbsolute3(args.directory) ? args.directory : join6(ctx.cwd, args.directory) : ctx.cwd;
+    const searchDir = args.directory ? isAbsolute3(args.directory) ? args.directory : join8(ctx.cwd, args.directory) : ctx.cwd;
     const maxFiles = args.max_files ?? 200;
     try {
       const flags = args.case_sensitive ? "g" : "gi";
@@ -3881,7 +4819,7 @@ var grepTool = {
         try {
           const content = await readFile10(filePath, "utf-8");
           const lines = content.split("\n");
-          const relPath = relative5(searchDir, filePath);
+          const relPath = relative6(searchDir, filePath);
           for (let i = 0; i < lines.length; i++) {
             if (regex.test(lines[i] ?? "")) {
               regex.lastIndex = 0;
@@ -3926,7 +4864,7 @@ var grepTool = {
 
 // src/tool/builtins/ls.ts
 import { readdir as readdir5, stat as stat4 } from "fs/promises";
-import { join as join7, relative as relative6 } from "path";
+import { join as join9, relative as relative7 } from "path";
 var lsTool = {
   name: "ls",
   kind: "read" /* Read */,
@@ -3964,7 +4902,7 @@ var lsTool = {
         let sizeStr = "";
         if (typeMark === "FILE") {
           try {
-            const fileStat = await stat4(join7(dirPath, entry.name));
+            const fileStat = await stat4(join9(dirPath, entry.name));
             if (fileStat.size < 1024) {
               sizeStr = `${fileStat.size}B`;
             } else if (fileStat.size < 1024 * 1024) {
@@ -3980,9 +4918,9 @@ var lsTool = {
         lines.push(`${typeLabel} ${entry.name}${sizeStr ? ` (${sizeStr})` : ""}`);
       }
       if (lines.length === 0) {
-        return { success: true, data: "\u76EE\u5F55\u4E3A\u7A7A", summary: `\u{1F4C2} ${relative6(ctx.cwd, dirPath).replace(/\\/g, "/")}\uFF08\u7A7A\uFF09` };
+        return { success: true, data: "\u76EE\u5F55\u4E3A\u7A7A", summary: `\u{1F4C2} ${relative7(ctx.cwd, dirPath).replace(/\\/g, "/")}\uFF08\u7A7A\uFF09` };
       }
-      const relPath = relative6(ctx.cwd, dirPath).replace(/\\/g, "/");
+      const relPath = relative7(ctx.cwd, dirPath).replace(/\\/g, "/");
       return {
         success: true,
         data: truncateOutput(`\u76EE\u5F55\uFF1A${dirPath}
@@ -4166,9 +5104,9 @@ function getGradientColors(text, phase, stops) {
 }
 
 // src/ui/ChatSession.tsx
-import { Fragment, jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
 var PHASE_CONFIG = {
-  thinking: { icon: "\u{1F9E0}", label: "\u601D\u8003\u4E2D", color: "#ff9800" },
+  thinking: { icon: "\u{1F9E0}", label: "\u6DF1\u5EA6\u601D\u8003\u4E2D", color: "#ff9800" },
   generating: { icon: "\u2728", label: "\u751F\u6210\u4E2D", color: "#00ff41" },
   calling_tools: { icon: "\u{1F6E0}", label: "\u8C03\u7528\u5DE5\u5177", color: "#f59e0b" },
   executing_tools: { icon: "\u26A1", label: "\u6267\u884C\u5DE5\u5177", color: "#00ffff" }
@@ -4240,34 +5178,34 @@ function ChatSession({
 }) {
   const termWidth = typeof process.stdout.columns === "number" ? process.stdout.columns : 80;
   const dividerWidth = Math.max(termWidth - 2, 1);
-  const [offset, setOffset] = useState3(0);
-  const [displayMessages, setDisplayMessages] = useState3([]);
-  const [staticKey, setStaticKey] = useState3(0);
-  const [input, setInput] = useState3("");
-  const [balance, setBalance] = useState3(null);
-  const [balanceLoading, setBalanceLoading] = useState3(false);
-  const [todayCost, setTodayCost] = useState3(null);
-  const [isStreaming, setIsStreaming] = useState3(false);
-  const [streamingPhase, setStreamingPhase] = useState3(null);
-  const [streamingPlaceholder, setStreamingPlaceholder] = useState3("");
-  const [idlePlaceholder, setIdlePlaceholder] = useState3(() => pickRandom(IDLE_PLACEHOLDERS));
-  const [gradientColors, setGradientColors] = useState3([]);
-  const gradientPhaseRef = useRef2(0);
-  const [streamingGradientColors, setStreamingGradientColors] = useState3([]);
-  const streamingPhaseRef = useRef2(0);
-  const [currentContent, setCurrentContent] = useState3("");
-  const [currentToolCalls, setCurrentToolCalls] = useState3([]);
-  const [_currentUsage, setCurrentUsage] = useState3(void 0);
-  const [_currentElapsed, setCurrentElapsed] = useState3(void 0);
-  const [_currentCost, setCurrentCost] = useState3(void 0);
-  const [activeModel, setActiveModel] = useState3(model);
-  const [_streamingModel, setStreamingModel] = useState3(void 0);
-  const [streamError, setStreamError] = useState3(void 0);
-  const [sessionMode, setSessionMode] = useState3("code");
-  const [thinkingEnabled, setThinkingEnabled] = useState3(true);
-  const [thinkingEffort, setThinkingEffort] = useState3("high");
-  const [responseFormat] = useState3("text");
-  const [toolChoice, setToolChoice] = useState3(void 0);
+  const [offset, setOffset] = useState4(0);
+  const [displayMessages, setDisplayMessages] = useState4([]);
+  const [staticKey, setStaticKey] = useState4(0);
+  const [input, setInput] = useState4("");
+  const [balance, setBalance] = useState4(null);
+  const [balanceLoading, setBalanceLoading] = useState4(false);
+  const [todayCost, setTodayCost] = useState4(null);
+  const [isStreaming, setIsStreaming] = useState4(false);
+  const [streamingPhase, setStreamingPhase] = useState4(null);
+  const [streamingPlaceholder, setStreamingPlaceholder] = useState4("");
+  const [idlePlaceholder, setIdlePlaceholder] = useState4(() => pickRandom(IDLE_PLACEHOLDERS));
+  const [gradientColors, setGradientColors] = useState4([]);
+  const gradientPhaseRef = useRef3(0);
+  const [streamingGradientColors, setStreamingGradientColors] = useState4([]);
+  const streamingPhaseRef = useRef3(0);
+  const [currentContent, setCurrentContent] = useState4("");
+  const [currentToolCalls, setCurrentToolCalls] = useState4([]);
+  const [_currentUsage, setCurrentUsage] = useState4(void 0);
+  const [_currentElapsed, setCurrentElapsed] = useState4(void 0);
+  const [_currentCost, setCurrentCost] = useState4(void 0);
+  const [activeModel, setActiveModel] = useState4(model);
+  const [_streamingModel, setStreamingModel] = useState4(void 0);
+  const [streamError, setStreamError] = useState4(void 0);
+  const [sessionMode, setSessionMode] = useState4("code");
+  const [thinkingEnabled, setThinkingEnabled] = useState4(true);
+  const [thinkingEffort, setThinkingEffort] = useState4("high");
+  const [responseFormat] = useState4("text");
+  const [toolChoice, setToolChoice] = useState4(void 0);
   const sessionCost = useMemo(() => {
     return displayMessages.reduce((sum, msg) => {
       if (msg.assistantDetail?.cost) {
@@ -4278,36 +5216,36 @@ function ChatSession({
   }, [displayMessages]);
   const hasConversationStarted = displayMessages.length > 0;
   const cmdTips = Array.from(getRegisteredCommands()).filter(([name]) => name !== "/exit" && name !== "/quit").map(([name, cmd]) => ({ name, desc: cmd.desc }));
-  const [cmdTipIndex, setCmdTipIndex] = useState3(0);
-  const [cmdTipGradientColors, setCmdTipGradientColors] = useState3([]);
-  const cmdTipPhaseRef = useRef2(0);
-  const [skillSelectIndex, setSkillSelectIndex] = useState3(0);
-  const [fileSelectIndex, setFileSelectIndex] = useState3(0);
-  const [inputKey, setInputKey] = useState3(0);
-  const [rewindSelecting, setRewindSelecting] = useState3(false);
-  const [rewindSelectIndex, setRewindSelectIndex] = useState3(0);
-  const [rewindList, setRewindList] = useState3([]);
-  const [rewinding, setRewinding] = useState3(false);
-  const [rewindHintPhase, setRewindHintPhase] = useState3("idle");
-  const currentRoundModifiedRef = useRef2(false);
-  const rewindHintTimerRef = useRef2(null);
-  const [selectingModel, setSelectingModel] = useState3(false);
-  const [modelSelectIndex, setModelSelectIndex] = useState3(0);
+  const [cmdTipIndex, setCmdTipIndex] = useState4(0);
+  const [cmdTipGradientColors, setCmdTipGradientColors] = useState4([]);
+  const cmdTipPhaseRef = useRef3(0);
+  const [skillSelectIndex, setSkillSelectIndex] = useState4(0);
+  const [fileSelectIndex, setFileSelectIndex] = useState4(0);
+  const [inputKey, setInputKey] = useState4(0);
+  const [rewindSelecting, setRewindSelecting] = useState4(false);
+  const [rewindSelectIndex, setRewindSelectIndex] = useState4(0);
+  const [rewindList, setRewindList] = useState4([]);
+  const [rewinding, setRewinding] = useState4(false);
+  const [rewindHintPhase, setRewindHintPhase] = useState4("idle");
+  const currentRoundModifiedRef = useRef3(false);
+  const rewindHintTimerRef = useRef3(null);
+  const [selectingModel, setSelectingModel] = useState4(false);
+  const [modelSelectIndex, setModelSelectIndex] = useState4(0);
   const modelOptions = ["deepseek-v4-flash", "deepseek-v4-pro"];
-  const sessionRef = useRef2(null);
-  const abortRef = useRef2(null);
-  const currentContentRef = useRef2("");
-  const currentToolCallsRef = useRef2([]);
-  const currentUsageRef = useRef2(void 0);
-  const currentElapsedRef = useRef2(void 0);
-  const currentCostRef = useRef2(void 0);
-  const currentModelRef = useRef2(void 0);
-  const streamErrorRef = useRef2(void 0);
-  useEffect3(() => {
+  const sessionRef = useRef3(null);
+  const abortRef = useRef3(null);
+  const currentContentRef = useRef3("");
+  const currentToolCallsRef = useRef3([]);
+  const currentUsageRef = useRef3(void 0);
+  const currentElapsedRef = useRef3(void 0);
+  const currentCostRef = useRef3(void 0);
+  const currentModelRef = useRef3(void 0);
+  const streamErrorRef = useRef3(void 0);
+  useEffect4(() => {
     setSkillSelectIndex(0);
     setFileSelectIndex(0);
   }, [input]);
-  useEffect3(() => {
+  useEffect4(() => {
     return () => {
       if (rewindHintTimerRef.current) {
         clearTimeout(rewindHintTimerRef.current);
@@ -4403,7 +5341,12 @@ function ChatSession({
     }
   }, []);
   const { doubleCtrlC, handleCtrlC } = useDoubleCtrlC(() => {
-    process.exit(0);
+    const s = sessionRef.current;
+    if (s) {
+      void s.flushLog().finally(() => process.exit(0));
+    } else {
+      process.exit(0);
+    }
   });
   useInput(
     useCallback2(
@@ -4537,14 +5480,14 @@ function ChatSession({
       [selectingModel, modelSelectIndex, modelOptions, activeModel, isStreaming, handleCtrlC, input, skills, skillSelectIndex, fileSelectIndex, getFilteredSkills, getFilteredFiles, sessionMode, setSessionMode, rewindSelecting, rewindSelectIndex, rewindList, doRewind]
     )
   );
-  useEffect3(() => {
+  useEffect4(() => {
     if (cmdTips.length <= 1) return;
     const timer = setInterval(() => {
       setCmdTipIndex((prev) => (prev + 1) % cmdTips.length);
     }, 2e3);
     return () => clearInterval(timer);
   }, [cmdTips.length]);
-  useEffect3(() => {
+  useEffect4(() => {
     const tip = cmdTips[cmdTipIndex % cmdTips.length];
     if (!tip) {
       setCmdTipGradientColors([]);
@@ -4559,13 +5502,13 @@ function ChatSession({
     }, GRADIENT_ANIMATION.cmdTipInterval);
     return () => clearInterval(interval);
   }, [cmdTipIndex, cmdTips.length]);
-  useEffect3(() => {
+  useEffect4(() => {
     const timer = setInterval(() => {
       setOffset((prev) => (prev + 1) % CYBER_PALETTE.length);
     }, 500);
     return () => clearInterval(timer);
   }, []);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!apiKey || !baseUrl) return;
     const provider = createProvider({
       name: "deepseek",
@@ -4584,7 +5527,7 @@ function ChatSession({
       sessionRef.current = null;
     };
   }, [apiKey, baseUrl, activeModel, externalCostTracker]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!apiKey || !baseUrl) return;
     let cancelled = false;
     setBalanceLoading(true);
@@ -4609,7 +5552,7 @@ function ChatSession({
       cancelled = true;
     };
   }, [apiKey, baseUrl]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!externalCostTracker) return;
     let cancelled = false;
     let timer;
@@ -4627,7 +5570,7 @@ function ChatSession({
       if (timer) clearInterval(timer);
     };
   }, [externalCostTracker]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (isStreaming || !idlePlaceholder) {
       setGradientColors([]);
       return;
@@ -4640,7 +5583,7 @@ function ChatSession({
     }, GRADIENT_ANIMATION.idleInterval);
     return () => clearInterval(interval);
   }, [isStreaming, idlePlaceholder]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!isStreaming || !streamingPlaceholder) {
       setStreamingGradientColors([]);
       return;
@@ -4803,6 +5746,7 @@ function ChatSession({
         const result = cmd.handler();
         switch (result.kind) {
           case "exit":
+            await sessionRef.current?.flushLog();
             process.exit(0);
             return;
           case "clear":
@@ -4988,8 +5932,8 @@ function ChatSession({
         }, 2e3);
       }
     }
-  }, [onLaunchGame, onLaunchStock, currentContent, currentToolCalls, skills, skillSelectIndex, getFilteredSkills, thinkingEnabled, thinkingEffort, responseFormat, toolChoice, activeModel, sessionMode]);
-  useEffect3(() => {
+  }, [onLaunchGame, onLaunchStock, currentContent, currentToolCalls, skills, skillSelectIndex, getFilteredSkills, thinkingEnabled, thinkingEffort, responseFormat, toolChoice, activeModel, sessionMode, isStreaming, rewinding]);
+  useEffect4(() => {
     if (!isStreaming && externalCostTracker) {
       setTodayCost(externalCostTracker.todayTotalCost);
     }
@@ -5092,7 +6036,10 @@ function ChatSession({
         {
           content: currentContent,
           toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0,
-          isStreaming: true
+          isStreaming: true,
+          usage: _currentUsage,
+          cost: _currentCost,
+          model: _streamingModel
         }
       ),
       !isStreaming && streamError && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, marginLeft: 3, children: /* @__PURE__ */ jsxs9(Text10, { color: "red", children: [
@@ -5164,7 +6111,7 @@ function ChatSession({
         /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text10, { color: "#808080", dimColor: true, children: "\u2191\u2193 \u9009\u62E9 \xB7 Enter \u786E\u8BA4 \xB7 Esc \u53D6\u6D88" }) })
       ] }),
       /* @__PURE__ */ jsx9(Text10, { color: "#00ffff", dimColor: true, children: "\u2500".repeat(dividerWidth) })
-    ] }) : /* @__PURE__ */ jsxs9(Fragment, { children: [
+    ] }) : /* @__PURE__ */ jsxs9(Fragment2, { children: [
       (hasConversationStarted || sessionMode === "plan") && isStreaming && streamingPhase ? /* @__PURE__ */ jsx9(Box9, { marginTop: 1, justifyContent: "center", children: /* @__PURE__ */ jsxs9(Text10, { bold: true, color: PHASE_CONFIG[streamingPhase].color, children: [
         PHASE_CONFIG[streamingPhase].icon,
         " ",
@@ -5216,10 +6163,10 @@ function ChatSession({
 
 // src/ui/GamePicker.tsx
 import { Box as Box10, Text as Text11, useInput as useInput2 } from "ink";
-import { useState as useState4, useCallback as useCallback3 } from "react";
+import { useState as useState5, useCallback as useCallback3 } from "react";
 import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
 function GamePicker({ games, onSelect, onExit, onBackToChat }) {
-  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [selectedIndex, setSelectedIndex] = useState5(0);
   const exitAction = onBackToChat ?? onExit ?? (() => process.exit(0));
   const { doubleCtrlC, handleCtrlC } = useDoubleCtrlC(exitAction);
   useInput2(
@@ -5274,7 +6221,7 @@ function listGames() {
 
 // src/game/brick-breaker/index.tsx
 import { Box as Box11, Text as Text12, useInput as useInput3, render as render2 } from "ink";
-import { useState as useState5, useEffect as useEffect4, useRef as useRef3, useCallback as useCallback4 } from "react";
+import { useState as useState6, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback4 } from "react";
 import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
 var GAME_WIDTH = 40;
 var GAME_HEIGHT = 18;
@@ -5406,13 +6353,13 @@ function buildBoard(state) {
   return lines.map((l) => `\u2502${l}\u2502`).join("\n");
 }
 function BrickBreakerGame({ onExit: _onExit }) {
-  const [initialLevel, setInitialLevel] = useState5(1);
-  const [selectingLevel, setSelectingLevel] = useState5(true);
-  const stateRef = useRef3(createInitialState(initialLevel));
-  const [tick2, setTick] = useState5(0);
-  const onExitRef = useRef3(_onExit);
+  const [initialLevel, setInitialLevel] = useState6(1);
+  const [selectingLevel, setSelectingLevel] = useState6(true);
+  const stateRef = useRef4(createInitialState(initialLevel));
+  const [tick2, setTick] = useState6(0);
+  const onExitRef = useRef4(_onExit);
   onExitRef.current = _onExit;
-  useEffect4(() => {
+  useEffect5(() => {
     if (selectingLevel) return;
     const interval = setInterval(() => {
       update(stateRef.current);
@@ -5546,7 +6493,7 @@ var brick_breaker_default = {
 
 // src/game/coder-check/index.tsx
 import { Box as Box12, Text as Text13, useInput as useInput4, render as render3 } from "ink";
-import { useState as useState6, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback5 } from "react";
+import { useState as useState7, useEffect as useEffect6, useRef as useRef5, useCallback as useCallback5 } from "react";
 import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
 var GAME_W = 66;
 var GAME_H = 20;
@@ -5938,18 +6885,18 @@ function buildGameView(s, scoreLines, scoreColor, message) {
   return rows;
 }
 function CoderCheck({ onExit: _onExit }) {
-  const stateRef = useRef4(createInitialState2());
-  const [tick2, setTick] = useState6(0);
-  const [colorOffset, setColorOffset] = useState6(0);
-  const onExitRef = useRef4(_onExit);
+  const stateRef = useRef5(createInitialState2());
+  const [tick2, setTick] = useState7(0);
+  const [colorOffset, setColorOffset] = useState7(0);
+  const onExitRef = useRef5(_onExit);
   onExitRef.current = _onExit;
-  useEffect5(() => {
+  useEffect6(() => {
     const timer = setInterval(() => {
       setColorOffset((prev) => (prev + 1) % CYBER_PALETTE2.length);
     }, 400);
     return () => clearInterval(timer);
   }, []);
-  useEffect5(() => {
+  useEffect6(() => {
     const interval = setInterval(() => {
       update2(stateRef.current);
       setTick((t) => t + 1);
@@ -6446,12 +7393,12 @@ import chalk5 from "chalk";
 
 // src/stock/StockList.tsx
 import { Box as Box13, Text as Text14, useInput as useInput5 } from "ink";
-import { useState as useState7, useCallback as useCallback6, useEffect as useEffect6, useMemo as useMemo2 } from "react";
+import { useState as useState8, useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo2 } from "react";
 import asciichart from "asciichart";
 import os from "os";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
-var SETTINGS_PATH = join8(os.homedir(), ".dskcode", "settings.json");
+var SETTINGS_PATH = join10(os.homedir(), ".dskcode", "settings.json");
 function toFileUrl(p) {
   const norm = p.replace(/\\/g, "/");
   if (process.platform === "win32") {
@@ -6553,20 +7500,20 @@ function latestPoints(data, maxPoints = 60) {
   return data.slice(data.length - maxPoints);
 }
 function StockList({ codes, onExit, onBackToChat }) {
-  const [stocks, setStocks] = useState7([]);
-  const [selectedIndex, setSelectedIndex] = useState7(0);
-  const [loading, setLoading] = useState7(true);
-  const [lastUpdate, setLastUpdate] = useState7("");
-  const [detailView, setDetailView] = useState7(null);
-  const [detailPrices, setDetailPrices] = useState7(null);
-  const [detailLoading, setDetailLoading] = useState7(false);
-  const [detailCountdown, setDetailCountdown] = useState7(10);
-  const [countdown, setCountdown] = useState7(5);
-  const [currentTime, setCurrentTime] = useState7(
+  const [stocks, setStocks] = useState8([]);
+  const [selectedIndex, setSelectedIndex] = useState8(0);
+  const [loading, setLoading] = useState8(true);
+  const [lastUpdate, setLastUpdate] = useState8("");
+  const [detailView, setDetailView] = useState8(null);
+  const [detailPrices, setDetailPrices] = useState8(null);
+  const [detailLoading, setDetailLoading] = useState8(false);
+  const [detailCountdown, setDetailCountdown] = useState8(10);
+  const [countdown, setCountdown] = useState8(5);
+  const [currentTime, setCurrentTime] = useState8(
     () => (/* @__PURE__ */ new Date()).toLocaleTimeString("zh-CN", { hour12: false })
   );
-  const [dimMode, setDimMode] = useState7(false);
-  const [sortOrder, setSortOrder] = useState7("default");
+  const [dimMode, setDimMode] = useState8(false);
+  const [sortOrder, setSortOrder] = useState8("default");
   const sortedStocks = useMemo2(() => {
     if (sortOrder === "default") return stocks;
     return [...stocks].toSorted(
@@ -6574,7 +7521,7 @@ function StockList({ codes, onExit, onBackToChat }) {
     );
   }, [stocks, sortOrder]);
   const { doubleCtrlC, handleCtrlC } = useDoubleCtrlC(onExit);
-  useEffect6(() => {
+  useEffect7(() => {
     const timer = setInterval(() => {
       setCurrentTime((/* @__PURE__ */ new Date()).toLocaleTimeString("zh-CN", { hour12: false }));
     }, 1e3);
@@ -6590,10 +7537,10 @@ function StockList({ codes, onExit, onBackToChat }) {
     }
     setLoading(false);
   }, [codes]);
-  useEffect6(() => {
+  useEffect7(() => {
     void loadData();
   }, [loadData]);
-  useEffect6(() => {
+  useEffect7(() => {
     const interval = setInterval(() => {
       setCountdown((prev) => {
         if (prev <= 1) {
@@ -6605,7 +7552,7 @@ function StockList({ codes, onExit, onBackToChat }) {
     }, 1e3);
     return () => clearInterval(interval);
   }, [loadData]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (detailView) {
       const loadDetail = () => {
         minuteCache.delete(detailView.code);
@@ -6624,7 +7571,7 @@ function StockList({ codes, onExit, onBackToChat }) {
     setDetailPrices(null);
     setDetailLoading(false);
   }, [detailView]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!detailView) return;
     const timer = setInterval(() => {
       setDetailCountdown((prev) => prev > 0 ? prev - 1 : 10);
@@ -6786,7 +7733,7 @@ function renderDetail(stock, _onBack, prices, countdown = 10, currentTime) {
 
 // src/utils/scan-files.ts
 import { readdir as readdir6 } from "fs/promises";
-import { join as join9, relative as relative7 } from "path";
+import { join as join11, relative as relative8 } from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -6851,12 +7798,12 @@ async function scanProjectFiles(baseDir, dir) {
     } else if (entry.isFile()) {
       const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
       if (SOURCE_EXTS.has(ext)) {
-        files.push(relative7(baseDir, join9(currentDir, name)));
+        files.push(relative8(baseDir, join11(currentDir, name)));
       }
     }
   }
   const nested = await Promise.all(
-    dirs.map((d) => scanProjectFiles(baseDir, join9(currentDir, d)))
+    dirs.map((d) => scanProjectFiles(baseDir, join11(currentDir, d)))
   );
   for (const n of nested) {
     files.push(...n);
@@ -6944,7 +7891,7 @@ compdef _dskcode_completion dskcode`);
   program2.command("stock").description("\u67E5\u770B\u81EA\u9009\u80A1\u5B9E\u65F6\u884C\u60C5").argument("[codes...]", "\u80A1\u7968\u4EE3\u7801\uFF08\u7A7A\u683C\u5206\u9694\uFF09\uFF0C\u5982 513090 600519").action(async function(codes) {
     const _ctx = this.dskcodeCtx;
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "~";
-    const globalConfigPath = join10(home, ".dskcode", "settings.json");
+    const globalConfigPath = join12(home, ".dskcode", "settings.json");
     let globalConfigHasStock = false;
     try {
       const raw = await readFile11(globalConfigPath, "utf-8");
@@ -7114,7 +8061,10 @@ var sigintCount = 0;
 var sigintTimer = null;
 async function gracefulExit(code) {
   try {
-    await CostTracker.flushAll();
+    await Promise.all([
+      CostTracker.flushAll(),
+      ConversationLogger.flushAll()
+    ]);
   } catch {
   }
   process.exit(code);
@@ -7137,19 +8087,19 @@ process.on("SIGTERM", () => {
 var program = createCli();
 try {
   await program.parseAsync(process.argv);
-  await CostTracker.flushAll();
+  await Promise.all([CostTracker.flushAll(), ConversationLogger.flushAll()]);
 } catch (err) {
   const error = err;
   if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
-    await CostTracker.flushAll();
+    await Promise.all([CostTracker.flushAll(), ConversationLogger.flushAll()]);
     process.exit(error.exitCode ?? ExitCode.SUCCESS);
   }
   if (typeof error.exitCode === "number") {
-    await CostTracker.flushAll();
+    await Promise.all([CostTracker.flushAll(), ConversationLogger.flushAll()]);
     process.exit(error.exitCode);
   }
   console.error(String(err));
-  await CostTracker.flushAll();
+  await Promise.all([CostTracker.flushAll(), ConversationLogger.flushAll()]);
   process.exit(ExitCode.GENERAL_ERROR);
 }
 //# sourceMappingURL=index.js.map