jinzd-ai-cli 0.4.117 → 0.4.119

package/dist/chunk-DIOSW6R4.js

@@ -0,0 +1,1728 @@
+#!/usr/bin/env node
+import {
+  truncateForPersist
+} from "./chunk-VYTV2VP7.js";
+import {
+  APP_NAME,
+  CONFIG_DIR_NAME,
+  DEV_STATE_FILE_NAME,
+  MCP_CALL_TIMEOUT,
+  MCP_CONNECT_TIMEOUT,
+  MCP_PROTOCOL_VERSION,
+  MCP_TOOL_PREFIX,
+  VERSION
+} from "./chunk-BS7EUZSO.js";
+import {
+  redactJson
+} from "./chunk-7ZJN4KLV.js";
+
+// src/session/session-manager.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, renameSync, openSync, readSync, closeSync } from "fs";
+import { join } from "path";
+import { v4 as uuidv4 } from "uuid";
+
+// src/core/types.ts
+function getContentText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+
+// src/session/session.ts
+function makeBranchId() {
+  return Math.random().toString(16).slice(2, 8);
+}
+function messagesEqual(a, b) {
+  if (a.role !== b.role) return false;
+  if (JSON.stringify(a.content) !== JSON.stringify(b.content)) return false;
+  if (JSON.stringify(a.toolCalls ?? null) !== JSON.stringify(b.toolCalls ?? null)) return false;
+  return true;
+}
+var Session = class _Session {
+  id;
+  provider;
+  model;
+  created;
+  updated;
+  messages = [];
+  title;
+  tokenUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0
+  };
+  checkpoints = [];
+  // ── B2 Branches (v0.4.74+) ──────────────────────────────────────
+  /**
+   * All branches in this session. The 'main' branch is auto-created and
+   * represents the linear conversation for pre-B2 sessions.
+   */
+  branches = [];
+  /** Currently active branch — its messages live in `this.messages`. */
+  activeBranchId = "main";
+  /**
+   * Stashed message arrays for INACTIVE branches. The active branch's
+   * messages are always in `this.messages`, never duplicated here.
+   */
+  _inactiveBranchMessages = /* @__PURE__ */ new Map();
+  constructor(id, provider, model) {
+    this.id = id;
+    this.provider = provider;
+    this.model = model;
+    this.created = /* @__PURE__ */ new Date();
+    this.updated = /* @__PURE__ */ new Date();
+    this.branches.push({
+      id: "main",
+      title: "main",
+      parentBranchId: null,
+      parentMessageIndex: 0,
+      created: this.created
+    });
+  }
+  /**
+   * 更新 session 关联的 provider 和 model（在 /provider 或 /model 切换时调用）。
+   * 保留对话历史和所有状态，仅更新元数据。
+   */
+  updateProvider(provider, model) {
+    this.provider = provider;
+    this.model = model;
+    this.updated = /* @__PURE__ */ new Date();
+  }
+  addMessage(message) {
+    this.messages.push(message);
+    this.updated = /* @__PURE__ */ new Date();
+    if (!this.title && message.role === "user") {
+      this.title = getContentText(message.content).slice(0, 50).replace(/\n/g, " ");
+    }
+  }
+  addTokenUsage(usage) {
+    this.tokenUsage.inputTokens += usage.inputTokens;
+    this.tokenUsage.outputTokens += usage.outputTokens;
+    this.tokenUsage.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
+    this.tokenUsage.cacheReadTokens += usage.cacheReadTokens ?? 0;
+  }
+  clear() {
+    this.messages = [];
+    this.title = void 0;
+    this.tokenUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0
+    };
+    this.updated = /* @__PURE__ */ new Date();
+  }
+  /**
+   * 上下文压缩：用摘要消息替换旧消息，保留最近 keepLast 条。
+   *
+   * Tool-history-aware: if the cut point lands inside a tool round
+   * (assistant+toolCalls followed by tool results), expand to keep the
+   * entire round intact. This prevents orphaned tool results.
+   *
+   * 压缩后消息结构：
+   *   [summaryMsg（user）, ackMsg（assistant）, ...最近 N 条原始消息]
+   *
+   * @returns 被删除的消息条数
+   */
+  compact(summaryMsg, ackMsg, keepLast) {
+    let cutIndex = this.messages.length - keepLast;
+    if (cutIndex <= 0) {
+      return 0;
+    }
+    while (cutIndex > 0 && this.messages[cutIndex]?.role === "tool") {
+      cutIndex--;
+    }
+    const preserved = this.messages.slice(cutIndex);
+    const removedCount = cutIndex;
+    this.messages = [summaryMsg, ackMsg, ...preserved];
+    this.updated = /* @__PURE__ */ new Date();
+    return removedCount;
+  }
+  /** 在当前消息位置创建检查点 */
+  createCheckpoint(name) {
+    this.checkpoints = this.checkpoints.filter((c) => c.name !== name);
+    this.checkpoints.push({
+      name,
+      messageIndex: this.messages.length,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /** 恢复到指定检查点：截断消息到检查点位置，移除后续检查点 */
+  restoreCheckpoint(name) {
+    const cp = this.checkpoints.find((c) => c.name === name);
+    if (!cp) return false;
+    this.messages = this.messages.slice(0, cp.messageIndex);
+    this.checkpoints = this.checkpoints.filter((c) => c.messageIndex <= cp.messageIndex);
+    this.updated = /* @__PURE__ */ new Date();
+    return true;
+  }
+  listCheckpoints() {
+    return [...this.checkpoints];
+  }
+  deleteCheckpoint(name) {
+    const len = this.checkpoints.length;
+    this.checkpoints = this.checkpoints.filter((c) => c.name !== name);
+    return this.checkpoints.length < len;
+  }
+  // ── B2 Branch operations ────────────────────────────────────────
+  /** Deep-clone a messages array (matches `Session.fork` semantics). */
+  static cloneMessages(msgs) {
+    return msgs.map((m) => {
+      const cloned = { ...m };
+      if (Array.isArray(cloned.content)) {
+        cloned.content = cloned.content.map(
+          (part) => typeof part === "object" && part !== null ? { ...part } : part
+        );
+      }
+      if (cloned.toolCalls) {
+        cloned.toolCalls = cloned.toolCalls.map((tc) => ({ ...tc }));
+      }
+      return cloned;
+    });
+  }
+  /** List all branches (metadata only). */
+  listBranches() {
+    return this.branches.map((b) => ({ ...b }));
+  }
+  /** Current active branch metadata. */
+  getActiveBranch() {
+    const b = this.branches.find((b2) => b2.id === this.activeBranchId);
+    if (!b) {
+      this.activeBranchId = this.branches[0]?.id ?? "main";
+      return this.branches[0] ?? { id: "main", title: "main", parentBranchId: null, parentMessageIndex: 0, created: /* @__PURE__ */ new Date() };
+    }
+    return b;
+  }
+  /**
+   * Create a new branch by forking the active branch at message index
+   * `fromIndex`. Copies `messages[0..fromIndex]` into the new branch
+   * and switches to it. The original active branch is preserved intact
+   * in the stash.
+   *
+   * @returns new branch id
+   * @throws if fromIndex is out of range
+   */
+  createBranch(fromIndex, title) {
+    if (fromIndex < 0 || fromIndex > this.messages.length) {
+      throw new Error(
+        `createBranch: fromIndex ${fromIndex} out of range [0, ${this.messages.length}]`
+      );
+    }
+    this._inactiveBranchMessages.set(this.activeBranchId, this.messages);
+    const id = makeBranchId();
+    const meta = {
+      id,
+      title: title || `branch-${this.branches.length + 1}`,
+      parentBranchId: this.activeBranchId,
+      parentMessageIndex: fromIndex,
+      created: /* @__PURE__ */ new Date()
+    };
+    this.branches.push(meta);
+    this.messages = _Session.cloneMessages(this.messages.slice(0, fromIndex));
+    this.activeBranchId = id;
+    this.updated = /* @__PURE__ */ new Date();
+    return id;
+  }
+  /**
+   * Switch the active branch. Stashes current messages under the old
+   * active id and loads the target branch's messages into `this.messages`.
+   *
+   * @returns true if switched, false if id not found or already active
+   */
+  switchBranch(id) {
+    if (id === this.activeBranchId) return false;
+    if (!this.branches.some((b) => b.id === id)) return false;
+    this._inactiveBranchMessages.set(this.activeBranchId, this.messages);
+    const target = this._inactiveBranchMessages.get(id) ?? [];
+    this._inactiveBranchMessages.delete(id);
+    this.messages = target;
+    this.activeBranchId = id;
+    this.updated = /* @__PURE__ */ new Date();
+    return true;
+  }
+  /**
+   * Delete a branch by id. Cannot delete the active branch or the last
+   * remaining branch. If other branches list this one as parent, their
+   * parent pointer is retargeted to this branch's parent (transparent
+   * to callers — branches still form a valid forest).
+   *
+   * @returns true if deleted
+   */
+  deleteBranch(id) {
+    if (id === this.activeBranchId) return false;
+    if (this.branches.length <= 1) return false;
+    const idx = this.branches.findIndex((b) => b.id === id);
+    if (idx === -1) return false;
+    const deleted = this.branches[idx];
+    for (const b of this.branches) {
+      if (b.parentBranchId === id) {
+        b.parentBranchId = deleted.parentBranchId;
+      }
+    }
+    this.branches.splice(idx, 1);
+    this._inactiveBranchMessages.delete(id);
+    this.updated = /* @__PURE__ */ new Date();
+    return true;
+  }
+  /** Rename a branch (affects only display title). */
+  renameBranch(id, newTitle) {
+    const b = this.branches.find((b2) => b2.id === id);
+    if (!b) return false;
+    b.title = newTitle;
+    this.updated = /* @__PURE__ */ new Date();
+    return true;
+  }
+  /**
+   * Resolve a user-supplied branch reference (v0.4.81+).
+   *
+   * Accepts the 6-hex branch id, the branch's display title, or an unambiguous
+   * id prefix (≥2 chars). This exists because users naturally type the title
+   * they chose at `/branch new`, not the auto-generated id — every other
+   * `/branch <sub>` used to error on that with "not found".
+   *
+   * Resolution order:
+   *   1. Exact id match
+   *   2. Exact title match (unique)
+   *   3. Id prefix match (unique, length ≥ 2)
+   *
+   * @returns `{ ok: true, id }` on success; on failure `{ ok: false, reason, matches }`
+   *          where `matches` lists candidates for ambiguous input so callers
+   *          can render a helpful error.
+   */
+  resolveBranchRef(ref) {
+    if (!ref) return { ok: false, reason: "not-found", matches: [] };
+    const byId = this.branches.find((b) => b.id === ref);
+    if (byId) return { ok: true, id: byId.id };
+    const byTitle = this.branches.filter((b) => b.title === ref);
+    if (byTitle.length === 1) return { ok: true, id: byTitle[0].id };
+    if (byTitle.length > 1) return { ok: false, reason: "ambiguous", matches: byTitle };
+    if (ref.length >= 2) {
+      const byPrefix = this.branches.filter((b) => b.id.startsWith(ref));
+      if (byPrefix.length === 1) return { ok: true, id: byPrefix[0].id };
+      if (byPrefix.length > 1) return { ok: false, reason: "ambiguous", matches: byPrefix };
+    }
+    return { ok: false, reason: "not-found", matches: [] };
+  }
+  /** Messages of any branch (active or inactive) — read-only copy. */
+  getBranchMessages(id) {
+    if (id === this.activeBranchId) return this.messages.slice();
+    const m = this._inactiveBranchMessages.get(id);
+    return m ? m.slice() : null;
+  }
+  // ── B3 Branch diff + cherry-pick (v0.4.80+) ────────────────────────
+  /**
+   * Compare messages between two branches. Finds the longest common prefix
+   * by message equality (role + content + toolCalls shape) — NOT by fork
+   * point metadata, so user-edited histories still diff cleanly.
+   *
+   * @param sourceId  Branch to compare
+   * @param targetId  Branch to compare against (defaults to active branch)
+   * @returns BranchDiff, or null if either branch id is unknown
+   */
+  diffBranches(sourceId, targetId) {
+    const tgt = targetId ?? this.activeBranchId;
+    const src = this.getBranchMessages(sourceId);
+    const dst = this.getBranchMessages(tgt);
+    if (!src || !dst) return null;
+    let i = 0;
+    while (i < src.length && i < dst.length && messagesEqual(src[i], dst[i])) i++;
+    return {
+      sourceId,
+      targetId: tgt,
+      commonPrefix: i,
+      sourceOnly: src.slice(i),
+      targetOnly: dst.slice(i)
+    };
+  }
+  /**
+   * Copy a single message from another branch into the active branch
+   * (appended at the end). Timestamp is reset to now so it's clear when
+   * the cherry-pick happened.
+   *
+   * @returns the cloned message, or null if sourceId / msgIndex is invalid
+   */
+  cherryPickMessage(sourceId, msgIndex) {
+    const src = this.getBranchMessages(sourceId);
+    if (!src) return null;
+    if (msgIndex < 0 || msgIndex >= src.length) return null;
+    const orig = src[msgIndex];
+    const copy = {
+      ...orig,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.messages.push(copy);
+    this.updated = /* @__PURE__ */ new Date();
+    return copy;
+  }
+  getMeta() {
+    return {
+      id: this.id,
+      provider: this.provider,
+      model: this.model,
+      messageCount: this.messages.length,
+      created: this.created,
+      updated: this.updated,
+      title: this.title
+    };
+  }
+  toJSON() {
+    const serializeMessages = (msgs) => msgs.map((m) => {
+      const out = {
+        role: m.role,
+        content: m.content,
+        timestamp: m.timestamp.toISOString()
+      };
+      if (m.toolCalls) out.toolCalls = m.toolCalls;
+      if (m.reasoningContent !== void 0) out.reasoningContent = m.reasoningContent;
+      if (m.toolCallId) out.toolCallId = m.toolCallId;
+      if (m.toolName) out.toolName = m.toolName;
+      if (m.isError !== void 0) out.isError = m.isError;
+      return out;
+    });
+    const branchMessages = {};
+    for (const [id, msgs] of this._inactiveBranchMessages.entries()) {
+      branchMessages[id] = serializeMessages(msgs);
+    }
+    return {
+      id: this.id,
+      provider: this.provider,
+      model: this.model,
+      created: this.created.toISOString(),
+      updated: this.updated.toISOString(),
+      title: this.title,
+      tokenUsage: { ...this.tokenUsage },
+      checkpoints: this.checkpoints.map((c) => ({
+        name: c.name,
+        messageIndex: c.messageIndex,
+        timestamp: c.timestamp.toISOString()
+      })),
+      // B2 Branches (v0.4.74+). Omitted for sessions with only the default
+      // 'main' branch and no stashed messages (keeps file size identical
+      // to pre-B2 for the common case).
+      ...this.branches.length > 1 || this._inactiveBranchMessages.size > 0 ? {
+        activeBranchId: this.activeBranchId,
+        branches: this.branches.map((b) => ({
+          id: b.id,
+          title: b.title,
+          parentBranchId: b.parentBranchId,
+          parentMessageIndex: b.parentMessageIndex,
+          created: b.created.toISOString()
+        })),
+        branchMessages
+      } : {},
+      messages: serializeMessages(this.messages)
+    };
+  }
+  /**
+   * 从现有 session 分叉创建新 session。
+   *
+   * 复制 messages[0..messageCount]，保留范围内的 checkpoints。
+   * 新 session 拥有独立 UUID，title 默认 "Fork of <原标题>"。
+   *
+   * @param original  原始 session
+   * @param newId     新 session 的 UUID
+   * @param messageCount  复制的消息数量（0 = 空 session，> messages.length 则取全部）
+   * @param newTitle  可选的新标题
+   */
+  static fork(original, newId, messageCount, newTitle) {
+    const forked = new _Session(newId, original.provider, original.model);
+    forked.title = newTitle ?? (original.title ? `Fork of ${original.title}` : void 0);
+    const clampedCount = Math.min(Math.max(messageCount, 0), original.messages.length);
+    forked.messages = original.messages.slice(0, clampedCount).map((m) => {
+      const cloned = { ...m };
+      if (Array.isArray(cloned.content)) {
+        cloned.content = cloned.content.map(
+          (part) => typeof part === "object" && part !== null ? { ...part } : part
+        );
+      }
+      return cloned;
+    });
+    forked.checkpoints = original.checkpoints.filter((c) => c.messageIndex <= clampedCount).map((c) => ({ ...c, timestamp: new Date(c.timestamp.getTime()) }));
+    forked.updated = /* @__PURE__ */ new Date();
+    return forked;
+  }
+  /**
+   * 从磁盘 JSON 数据恢复 Session 实例。
+   * 添加运行时校验：损坏或不兼容的历史文件会抛出明确错误，而非 TypeError 崩溃。
+   */
+  static fromJSON(data) {
+    const d = data;
+    if (!d || typeof d !== "object") {
+      throw new Error("Invalid session data: expected an object");
+    }
+    if (typeof d.id !== "string" || typeof d.provider !== "string" || typeof d.model !== "string") {
+      throw new Error("Invalid session data: missing or invalid id/provider/model fields");
+    }
+    if (!Array.isArray(d.messages)) {
+      throw new Error("Invalid session data: messages is not an array");
+    }
+    const session = new _Session(d.id, d.provider, d.model);
+    session.title = typeof d.title === "string" ? d.title : void 0;
+    const created = new Date(d.created);
+    const updated = new Date(d.updated);
+    session.created = isNaN(created.getTime()) ? /* @__PURE__ */ new Date() : created;
+    session.updated = isNaN(updated.getTime()) ? /* @__PURE__ */ new Date() : updated;
+    const tu = d.tokenUsage;
+    if (tu && typeof tu === "object") {
+      session.tokenUsage = {
+        inputTokens: typeof tu.inputTokens === "number" ? tu.inputTokens : 0,
+        outputTokens: typeof tu.outputTokens === "number" ? tu.outputTokens : 0,
+        cacheCreationTokens: typeof tu.cacheCreationTokens === "number" ? tu.cacheCreationTokens : 0,
+        cacheReadTokens: typeof tu.cacheReadTokens === "number" ? tu.cacheReadTokens : 0
+      };
+    }
+    if (Array.isArray(d.checkpoints)) {
+      session.checkpoints = d.checkpoints.map((c) => ({
+        name: String(c.name ?? ""),
+        messageIndex: typeof c.messageIndex === "number" ? c.messageIndex : 0,
+        timestamp: new Date(c.timestamp)
+      }));
+    }
+    const deserializeMessages = (arr) => arr.map((m) => {
+      const ts = new Date(m.timestamp);
+      const msg = {
+        role: m.role ?? "user",
+        content: Array.isArray(m.content) ? m.content : String(m.content ?? ""),
+        timestamp: isNaN(ts.getTime()) ? /* @__PURE__ */ new Date() : ts
+      };
+      if (Array.isArray(m.toolCalls)) msg.toolCalls = m.toolCalls;
+      if (typeof m.reasoningContent === "string") msg.reasoningContent = m.reasoningContent;
+      if (typeof m.toolCallId === "string") msg.toolCallId = m.toolCallId;
+      if (typeof m.toolName === "string") msg.toolName = m.toolName;
+      if (typeof m.isError === "boolean") msg.isError = m.isError;
+      return msg;
+    });
+    session.messages = deserializeMessages(d.messages);
+    if (Array.isArray(d.branches) && d.branches.length > 0) {
+      session.branches = d.branches.map((b) => {
+        const ts = new Date(b.created);
+        return {
+          id: String(b.id ?? "main"),
+          title: String(b.title ?? b.id ?? "main"),
+          parentBranchId: typeof b.parentBranchId === "string" ? b.parentBranchId : null,
+          parentMessageIndex: typeof b.parentMessageIndex === "number" ? b.parentMessageIndex : 0,
+          created: isNaN(ts.getTime()) ? /* @__PURE__ */ new Date() : ts
+        };
+      });
+      session.activeBranchId = typeof d.activeBranchId === "string" ? d.activeBranchId : session.branches[0]?.id ?? "main";
+      const bm = d.branchMessages;
+      if (bm && typeof bm === "object") {
+        for (const [id, arr] of Object.entries(bm)) {
+          if (id === session.activeBranchId) continue;
+          if (!Array.isArray(arr)) continue;
+          session._inactiveBranchMessages.set(
+            id,
+            deserializeMessages(arr)
+          );
+        }
+      }
+    }
+    return session;
+  }
+};
+
+// src/session/session-manager.ts
+function safeDate(value) {
+  const d = new Date(value);
+  return isNaN(d.getTime()) ? /* @__PURE__ */ new Date(0) : d;
+}
+function extractJsonField(header, field) {
+  const re = new RegExp(`"${field}"\\s*:\\s*"([^"]*)"`, "i");
+  const m = header.match(re);
+  return m ? m[1] : void 0;
+}
+var SessionManager = class {
+  _current = null;
+  historyDir;
+  config;
+  /** Last save's redaction hit count — exposed for /security status reporting */
+  lastRedactionHits = 0;
+  constructor(config) {
+    this.config = config;
+    this.historyDir = config.getHistoryDir();
+  }
+  /**
+   * Build redaction options from config. Returns `{ enabled: false }` when
+   * `security.redactOnSave` is off or `security.mode` is 'off'.
+   */
+  redactOptionsForSave() {
+    const security = this.config.get("security");
+    if (!security || !security.redactOnSave || security.mode === "off") {
+      return { enabled: false };
+    }
+    return {
+      enabled: true,
+      customRegexes: security.customPatterns ?? []
+    };
+  }
+  get current() {
+    return this._current;
+  }
+  createSession(provider, model) {
+    const session = new Session(uuidv4(), provider, model);
+    this._current = session;
+    return session;
+  }
+  /**
+   * 直接设置当前会话（用于从内存缓存恢复未保存的会话）。
+   * 与 `loadSession` 不同，此方法不读取磁盘，也不抛出错误。
+   * Web 多 Tab 场景下，SessionHandler 会维护一份未保存会话的内存缓存，
+   * 切换 Tab 时通过此方法将缓存中的会话设为当前会话，避免"Session not found"。
+   */
+  setCurrent(session) {
+    this._current = session;
+  }
+  /** 清除当前会话引用（下次访问将触发 lazy 创建）。 */
+  clearCurrent() {
+    this._current = null;
+  }
+  async save() {
+    if (!this._current) return;
+    mkdirSync(this.historyDir, { recursive: true });
+    const filePath = join(this.historyDir, `${this._current.id}.json`);
+    const raw = this._current.toJSON();
+    const opts = this.redactOptionsForSave();
+    const { value: payload, hits } = redactJson(raw, opts);
+    this.lastRedactionHits = hits.length;
+    const tmpPath = filePath + ".tmp";
+    writeFileSync(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+    renameSync(tmpPath, filePath);
+  }
+  loadSession(id) {
+    const filePath = join(this.historyDir, `${id}.json`);
+    if (!existsSync(filePath)) {
+      throw new Error(`Session ${id} not found`);
+    }
+    let data;
+    try {
+      data = JSON.parse(readFileSync(filePath, "utf-8"));
+    } catch (err) {
+      throw new Error(`Session ${id} is corrupted: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const session = Session.fromJSON(data);
+    this._current = session;
+    return session;
+  }
+  listSessions() {
+    if (!existsSync(this.historyDir)) return [];
+    const files = readdirSync(this.historyDir).filter((f) => f.endsWith(".json"));
+    const metas = [];
+    for (const file of files) {
+      try {
+        const meta = this.readSessionMeta(join(this.historyDir, file));
+        if (meta) metas.push(meta);
+      } catch (err) {
+        process.stderr.write(
+          `[Warning] Skipping corrupted session file "${file}": ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+    return metas.sort((a, b) => b.updated.getTime() - a.updated.getTime());
+  }
+  /**
+   * P1-B: Read only the first ~1KB of a session file to extract metadata fields.
+   * Session JSON format puts id/provider/model/created/updated/title before the
+   * large "messages" array, so a small header read suffices for metadata extraction.
+   * Falls back to full file read if header parsing fails.
+   */
+  readSessionMeta(filePath) {
+    const HEADER_SIZE = 1024;
+    let header;
+    try {
+      const fd = openSync(filePath, "r");
+      const buf = Buffer.alloc(HEADER_SIZE);
+      const bytesRead = readSync(fd, buf, 0, HEADER_SIZE, 0);
+      closeSync(fd);
+      header = buf.toString("utf-8", 0, bytesRead);
+    } catch {
+      return null;
+    }
+    const id = extractJsonField(header, "id");
+    const provider = extractJsonField(header, "provider");
+    const model = extractJsonField(header, "model");
+    const created = extractJsonField(header, "created");
+    const updated = extractJsonField(header, "updated");
+    const title = extractJsonField(header, "title");
+    if (id && provider && model) {
+      let messageCount = 0;
+      try {
+        const full = readFileSync(filePath, "utf-8");
+        const matches = full.match(/"role"\s*:/g);
+        messageCount = matches ? matches.length : 0;
+      } catch {
+      }
+      return {
+        id,
+        provider,
+        model,
+        messageCount,
+        created: safeDate(created),
+        updated: safeDate(updated),
+        title: title || void 0
+      };
+    }
+    const data = JSON.parse(readFileSync(filePath, "utf-8"));
+    return {
+      id: data.id,
+      provider: data.provider,
+      model: data.model,
+      messageCount: data.messages?.length ?? 0,
+      created: safeDate(data.created),
+      updated: safeDate(data.updated),
+      title: data.title
+    };
+  }
+  deleteSession(id) {
+    const filePath = join(this.historyDir, `${id}.json`);
+    if (!existsSync(filePath)) return false;
+    try {
+      unlinkSync(filePath);
+      if (this._current && this._current.id === id) {
+        this._current = null;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 从当前 session 分叉创建新 session。
+   *
+   * 先保存原始 session（保留完整历史），然后创建分叉（截取到 messageCount），
+   * 将分叉设为当前 session 并保存。
+   *
+   * @param messageCount  复制的消息数量
+   * @param title         可选的新标题
+   * @returns 新的分叉 session
+   */
+  async forkSession(messageCount, title) {
+    if (!this._current) {
+      throw new Error("No active session to fork");
+    }
+    await this.save();
+    const forked = Session.fork(this._current, uuidv4(), messageCount, title);
+    this._current = forked;
+    await this.save();
+    return forked;
+  }
+  /**
+   * 跨 session 全文搜索。
+   * 遍历所有历史 JSON 文件，逐条匹配消息内容（不区分大小写），
+   * 每个 session 最多返回 3 条匹配片段，全局最多 maxResults 个 session。
+   */
+  searchMessages(query, maxResults = 20) {
+    if (!existsSync(this.historyDir)) return [];
+    const q = query.toLowerCase();
+    const files = readdirSync(this.historyDir).filter((f) => f.endsWith(".json")).map((f) => join(this.historyDir, f));
+    const results = [];
+    for (const filePath of files) {
+      if (results.length >= maxResults) break;
+      try {
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        const messages = data.messages ?? [];
+        const matches = [];
+        for (const msg of messages) {
+          if (matches.length >= 3) break;
+          let text = "";
+          if (typeof msg.content === "string") {
+            text = msg.content;
+          } else if (Array.isArray(msg.content)) {
+            text = msg.content.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
+          }
+          const lowerText = text.toLowerCase();
+          const idx = lowerText.indexOf(q);
+          if (idx !== -1) {
+            const start = Math.max(0, idx - 30);
+            const end = Math.min(text.length, idx + query.length + 60);
+            const snippet = (start > 0 ? "\u2026" : "") + text.slice(start, end).replace(/\n/g, " ") + (end < text.length ? "\u2026" : "");
+            matches.push({ role: msg.role, snippet });
+          }
+        }
+        if (matches.length > 0) {
+          results.push({
+            sessionMeta: {
+              id: data.id,
+              provider: data.provider,
+              model: data.model,
+              messageCount: messages.length,
+              created: safeDate(data.created),
+              updated: safeDate(data.updated),
+              title: data.title
+            },
+            matches
+          });
+        }
+      } catch (err) {
+        process.stderr.write(
+          `[Warning] Skipping corrupted session file "${filePath}": ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+    return results.sort((a, b) => b.sessionMeta.updated.getTime() - a.sessionMeta.updated.getTime());
+  }
+};
+
+// src/mcp/client.ts
+import { spawn } from "child_process";
+var McpClient = class {
+  serverId;
+  config;
+  process = null;
+  nextId = 1;
+  // M8: wraps at MAX_SAFE_INTEGER via getNextId()
+  connected = false;
+  serverInfo = null;
+  /** stderr 收集（最多保留最后 2KB，用于错误报告） */
+  stderrBuffer = "";
+  /** 缓存已发现的工具列表 */
+  cachedTools = [];
+  /** 错误信息（连接失败时设置） */
+  errorMessage = null;
+  // ── JSON-RPC 请求/响应匹配 ──────────────────────────────────────
+  pendingRequests = /* @__PURE__ */ new Map();
+  /** stdout 残余缓冲区（处理不完整的 JSON 行） */
+  stdoutBuffer = "";
+  constructor(serverId, config) {
+    this.serverId = serverId;
+    this.config = config;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  get serverName() {
+    return this.serverInfo?.name ?? this.serverId;
+  }
+  get tools() {
+    return this.cachedTools;
+  }
+  // ══════════════════════════════════════════════════════════════════
+  // 连接与初始化
+  // ══════════════════════════════════════════════════════════════════
+  async connect() {
+    const timeout = this.config.timeout ?? MCP_CONNECT_TIMEOUT;
+    try {
+      this.process = spawn(this.config.command, this.config.args ?? [], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...this.config.env },
+        // Windows 上 npx 等是 .cmd 脚本，需要 shell 模式
+        shell: process.platform === "win32",
+        // 不让子进程阻止父进程退出
+        detached: false
+      });
+      this.process.on("error", (err) => {
+        this.errorMessage = err.message;
+        this.connected = false;
+        this.rejectAllPending(new Error(`MCP server [${this.serverId}] process error: ${err.message}`));
+      });
+      this.process.on("exit", (code, signal) => {
+        this.connected = false;
+        const reason = signal ? `signal ${signal}` : `code ${code}`;
+        this.rejectAllPending(new Error(`MCP server [${this.serverId}] exited: ${reason}`));
+      });
+      this.process.stdout.setEncoding("utf-8");
+      this.process.stdout.on("data", (chunk) => this.handleStdoutData(chunk));
+      this.process.stderr.setEncoding("utf-8");
+      this.process.stderr.on("data", (chunk) => {
+        this.stderrBuffer += chunk;
+        if (this.stderrBuffer.length > 2048) {
+          this.stderrBuffer = this.stderrBuffer.slice(-2048);
+        }
+      });
+      const initResult = await this.withTimeout(
+        this.sendRequest("initialize", {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: APP_NAME, version: VERSION }
+        }),
+        timeout,
+        "initialize handshake"
+      );
+      this.serverInfo = initResult.serverInfo;
+      this.sendNotification("notifications/initialized");
+      this.connected = true;
+      await this.refreshTools();
+    } catch (err) {
+      this.errorMessage = err instanceof Error ? err.message : String(err);
+      this.connected = false;
+      this.killProcess();
+      throw err;
+    }
+  }
+  // ══════════════════════════════════════════════════════════════════
+  // 工具操作
+  // ══════════════════════════════════════════════════════════════════
+  /** 刷新工具列表（tools/list） */
+  async refreshTools() {
+    this.ensureConnected();
+    const result = await this.withTimeout(
+      this.sendRequest("tools/list", {}),
+      MCP_CALL_TIMEOUT,
+      "tools/list"
+    );
+    this.cachedTools = result.tools ?? [];
+    return this.cachedTools;
+  }
+  /** 调用工具（tools/call） */
+  async callTool(name, args) {
+    this.ensureConnected();
+    return this.withTimeout(
+      this.sendRequest("tools/call", { name, arguments: args }),
+      MCP_CALL_TIMEOUT,
+      `tools/call(${name})`
+    );
+  }
+  // ══════════════════════════════════════════════════════════════════
+  // 关闭连接
+  // ══════════════════════════════════════════════════════════════════
+  async close() {
+    this.connected = false;
+    this.rejectAllPending(new Error("Client closing"));
+    this.killProcess();
+  }
+  /**
+   * 断线重连：清理旧状态后重新执行完整的 connect() 流程。
+   * 用于 MCP 服务器子进程意外退出后的自动或手动恢复。
+   */
+  async reconnect() {
+    this.connected = false;
+    this.rejectAllPending(new Error("Reconnecting"));
+    this.killProcess();
+    this.errorMessage = null;
+    this.stderrBuffer = "";
+    this.stdoutBuffer = "";
+    this.cachedTools = [];
+    await this.connect();
+  }
+  // ══════════════════════════════════════════════════════════════════
+  // 内部方法：JSON-RPC 通信
+  // ══════════════════════════════════════════════════════════════════
+  sendRequest(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.process?.stdin?.writable) {
+        return reject(new Error(`MCP server [${this.serverId}] stdin not writable`));
+      }
+      const id = this.nextId++;
+      if (this.nextId > Number.MAX_SAFE_INTEGER - 1) this.nextId = 1;
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...params !== void 0 ? { params } : {}
+      };
+      let timer;
+      const cleanup = () => {
+        this.pendingRequests.delete(id);
+        clearTimeout(timer);
+      };
+      timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`MCP request [${method}] timed out (internal)`));
+      }, MCP_CALL_TIMEOUT * 2);
+      this.pendingRequests.set(id, {
+        resolve: (result) => {
+          cleanup();
+          resolve(result);
+        },
+        reject: (error) => {
+          cleanup();
+          reject(error);
+        },
+        timer
+      });
+      const json = JSON.stringify(request) + "\n";
+      this.process.stdin.write(json, (err) => {
+        if (err) {
+          cleanup();
+          reject(new Error(`MCP write error: ${err.message}`));
+        }
+      });
+    });
+  }
+  sendNotification(method, params) {
+    if (!this.process?.stdin?.writable) return;
+    const notification = {
+      jsonrpc: "2.0",
+      method,
+      ...params !== void 0 ? { params } : {}
+    };
+    this.process.stdin.write(JSON.stringify(notification) + "\n");
+  }
+  /**
+   * 处理 stdout 数据：按行分割，每行解析为 JSON-RPC 响应。
+   * 处理不完整行：残余数据保留在 stdoutBuffer 中。
+   */
+  handleStdoutData(chunk) {
+    this.stdoutBuffer += chunk;
+    if (this.stdoutBuffer.length > 1048576) {
+      process.stderr.write(`[mcp] stdout buffer exceeded 1MB \u2014 clearing
+`);
+      this.stdoutBuffer = "";
+      return;
+    }
+    const lines = this.stdoutBuffer.split("\n");
+    this.stdoutBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        this.handleMessage(msg);
+      } catch {
+      }
+    }
+  }
+  /** 处理收到的 JSON-RPC 消息 */
+  handleMessage(msg) {
+    if ("id" in msg && typeof msg.id === "number") {
+      const pending = this.pendingRequests.get(msg.id);
+      if (!pending) return;
+      const response = msg;
+      if (response.error) {
+        pending.reject(new Error(
+          `MCP error [${response.error.code}]: ${response.error.message}`
+        ));
+      } else {
+        pending.resolve(response.result);
+      }
+    }
+  }
+  // ══════════════════════════════════════════════════════════════════
+  // 辅助方法
+  // ══════════════════════════════════════════════════════════════════
+  ensureConnected() {
+    if (!this.connected) {
+      throw new Error(
+        `MCP server [${this.serverId}] is not connected` + (this.errorMessage ? `: ${this.errorMessage}` : "")
+      );
+    }
+  }
+  /** Promise 超时包装 */
+  withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`MCP [${this.serverId}] ${label} timed out after ${ms}ms`));
+      }, ms);
+      promise.then((val) => {
+        clearTimeout(timer);
+        resolve(val);
+      }).catch((err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+  /** 拒绝所有挂起的请求。pending.reject() 内部的 cleanup() 已包含 clearTimeout。 */
+  rejectAllPending(error) {
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+  /** 杀掉子进程，并移除所有事件监听器防止僵尸引用 */
+  killProcess() {
+    if (this.process) {
+      this.process.removeAllListeners("error");
+      this.process.removeAllListeners("exit");
+      this.process.stdout?.removeAllListeners("data");
+      this.process.stderr?.removeAllListeners("data");
+      try {
+        this.process.stdin?.end();
+        this.process.kill();
+      } catch {
+      }
+      this.process = null;
+    }
+  }
+};
+
+// src/mcp/manager.ts
+var McpManager = class {
+  clients = /* @__PURE__ */ new Map();
+  /**
+   * 连接所有配置的 MCP 服务器（并发连接，单个失败不阻塞其他）。
+   * 连接结果通过 getStatus() 查看。
+   */
+  async connectAll(servers) {
+    const entries = Object.entries(servers);
+    if (entries.length === 0) return;
+    const promises = entries.map(async ([serverId, config]) => {
+      const client = new McpClient(serverId, config);
+      this.clients.set(serverId, client);
+      try {
+        await client.connect();
+        process.stderr.write(`[mcp] \u2713 ${serverId}: connected (${client.serverName}, ${client.tools.length} tools)
+`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[mcp] \u2717 ${serverId}: ${msg}
+`);
+      }
+    });
+    await Promise.allSettled(promises);
+  }
+  /**
+   * 获取所有已连接服务器的工具，转换为 ai-cli 的 Tool 接口。
+   * 工具名格式：mcp__<serverId>__<toolName>
+   */
+  getAllTools() {
+    const tools = [];
+    for (const [serverId, client] of this.clients) {
+      if (!client.isConnected) continue;
+      for (const mcpTool of client.tools) {
+        tools.push(this.wrapMcpTool(serverId, client, mcpTool));
+      }
+    }
+    return tools;
+  }
+  /**
+   * 获取连接状态摘要。
+   */
+  getStatus() {
+    const statuses = [];
+    for (const [serverId, client] of this.clients) {
+      statuses.push({
+        serverId,
+        serverName: client.serverName,
+        toolCount: client.tools.length,
+        connected: client.isConnected,
+        error: client.errorMessage ?? void 0
+      });
+    }
+    return statuses;
+  }
+  /**
+   * 获取已连接服务器数量。
+   */
+  getConnectedCount() {
+    let count = 0;
+    for (const client of this.clients.values()) {
+      if (client.isConnected) count++;
+    }
+    return count;
+  }
+  /**
+   * 获取所有 MCP 工具的总数。
+   */
+  getTotalToolCount() {
+    let count = 0;
+    for (const client of this.clients.values()) {
+      if (client.isConnected) count += client.tools.length;
+    }
+    return count;
+  }
+  /**
+   * 重连指定 MCP 服务器。
+   * @returns 重连是否成功
+   */
+  async reconnectServer(serverId) {
+    const client = this.clients.get(serverId);
+    if (!client) return false;
+    try {
+      await client.reconnect();
+      process.stderr.write(`[mcp] \u2713 ${serverId}: reconnected (${client.serverName}, ${client.tools.length} tools)
+`);
+      return true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[mcp] \u2717 ${serverId}: reconnect failed: ${msg}
+`);
+      return false;
+    }
+  }
+  /**
+   * 重连所有已断开的 MCP 服务器。
+   * @returns 成功重连的服务器数量
+   */
+  async reconnectAll() {
+    let reconnected = 0;
+    for (const [serverId, client] of this.clients) {
+      if (!client.isConnected) {
+        const ok = await this.reconnectServer(serverId);
+        if (ok) reconnected++;
+      }
+    }
+    return reconnected;
+  }
+  /**
+   * 关闭所有 MCP 服务器连接。
+   */
+  async closeAll() {
+    const promises = [...this.clients.entries()].map(
+      ([id, c]) => c.close().catch((err) => {
+        process.stderr.write(`[mcp] Failed to close ${id}: ${err instanceof Error ? err.message : err}
+`);
+      })
+    );
+    await Promise.allSettled(promises);
+    this.clients.clear();
+  }
+  // ══════════════════════════════════════════════════════════════════
+  // 内部方法
+  // ══════════════════════════════════════════════════════════════════
+  /**
+   * 将 MCP 工具包装为 ai-cli 的 Tool 接口。
+   * execute() 方法委托给对应 McpClient.callTool()。
+   */
+  wrapMcpTool(serverId, client, mcpTool) {
+    const toolName = `${MCP_TOOL_PREFIX}${serverId}__${mcpTool.name}`;
+    const definition = this.convertDefinition(toolName, serverId, mcpTool);
+    return {
+      definition,
+      execute: async (args) => {
+        if (!client.isConnected) {
+          process.stderr.write(`[mcp] ${serverId}: disconnected, attempting reconnect...
+`);
+          try {
+            await client.reconnect();
+            process.stderr.write(`[mcp] \u2713 ${serverId}: reconnected (${client.tools.length} tools)
+`);
+          } catch {
+            throw new Error(
+              `MCP server [${serverId}] is disconnected and reconnect failed` + (client.errorMessage ? `: ${client.errorMessage}` : "") + `. Use /mcp reconnect to retry, or restart ai-cli.`
+            );
+          }
+        }
+        try {
+          const result = await client.callTool(mcpTool.name, args);
+          if (result.isError) {
+            const errorText = this.extractText(result.content);
+            throw new Error(errorText || "MCP tool returned error with no message");
+          }
+          return this.extractText(result.content) || "(no output)";
+        } catch (err) {
+          throw new Error(`MCP [${serverId}/${mcpTool.name}]: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    };
+  }
+  /**
+   * 转换 MCP 工具定义为 ai-cli 的 ToolDefinition。
+   * MCP 使用 JSON Schema 的 inputSchema，ai-cli 使用 Record<string, ToolParameterSchema>。
+   * M12 修复：递归转换嵌套 object/array schema，保留完整结构供 AI 正确传参。
+   */
+  convertDefinition(toolName, serverId, mcpTool) {
+    const parameters = {};
+    const props = mcpTool.inputSchema?.properties ?? {};
+    const required = new Set(mcpTool.inputSchema?.required ?? []);
+    for (const [key, schema] of Object.entries(props)) {
+      parameters[key] = {
+        ...this.convertSchema(schema),
+        ...required.has(key) ? { required: true } : {}
+      };
+    }
+    return {
+      name: toolName,
+      description: (mcpTool.description ?? mcpTool.name) + ` [MCP: ${serverId}]`,
+      parameters
+    };
+  }
+  /**
+   * 递归转换单个 JSON Schema 属性为 ToolParameterSchema。
+   * 支持嵌套 object（含 properties）和 array（含 items）。
+   * 递归深度受 MCP 工具实际 schema 复杂度约束（通常 2-3 层）。
+   */
+  convertSchema(schema) {
+    const type = this.normalizeType(String(schema["type"] ?? "string"));
+    const result = {
+      type,
+      description: String(schema["description"] ?? ""),
+      ...schema["enum"] ? { enum: schema["enum"] } : {}
+    };
+    if (type === "object" && schema["properties"]) {
+      const props = schema["properties"];
+      result.properties = {};
+      for (const [k, v] of Object.entries(props)) {
+        result.properties[k] = this.convertSchema(v);
+      }
+    }
+    if (type === "array" && schema["items"]) {
+      const items = schema["items"];
+      result.items = this.convertSchema(items);
+    }
+    return result;
+  }
+  /**
+   * 将 JSON Schema 类型映射到 ai-cli 的 ToolParameterType。
+   * integer → number（ai-cli 不区分整数/浮点）
+   */
+  normalizeType(jsonSchemaType) {
+    switch (jsonSchemaType) {
+      case "string":
+        return "string";
+      case "number":
+      case "integer":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "array":
+        return "array";
+      case "object":
+        return "object";
+      default:
+        return "string";
+    }
+  }
+  /**
+   * 从 MCP 响应的 content blocks 中提取纯文本。
+   * 只处理 type="text" 的块，其他类型（image 等）跳过。
+   */
+  extractText(content) {
+    return content.filter((block) => block.type === "text" && block.text).map((block) => block.text).join("\n");
+  }
+};
+
+// src/skills/manager.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, mkdirSync as mkdirSync2, statSync } from "fs";
+import { join as join2 } from "path";
+
+// src/skills/types.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+function parseSimpleYaml(yaml) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    const match = line.replace(/\r$/, "").match(/^(\w+)\s*:\s*(.+)$/);
+    if (match) {
+      result[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, "");
+    }
+  }
+  return result;
+}
+function parseYamlArray(value) {
+  const bracketMatch = value.match(/^\[(.+)]$/);
+  if (bracketMatch) {
+    return bracketMatch[1].split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+  }
+  return [value.trim()];
+}
+function parseSkillFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const frontmatterMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    return {
+      meta: {
+        name: basename(filePath, ".md"),
+        description: ""
+      },
+      content: raw.trim(),
+      filePath
+    };
+  }
+  const [, yaml, content] = frontmatterMatch;
+  const parsed = parseSimpleYaml(yaml);
+  return {
+    meta: {
+      name: parsed["name"] ?? basename(filePath, ".md"),
+      description: parsed["description"] ?? "",
+      tools: parsed["tools"] ? parseYamlArray(parsed["tools"]) : void 0
+    },
+    content: content.trim(),
+    filePath
+  };
+}
+
+// src/skills/manager.ts
+var SKILL_CONTENT_WARN_CHARS_DEFAULT = 1e4;
+var SkillManager = class {
+  skills = /* @__PURE__ */ new Map();
+  activeSkill = null;
+  skillsDir;
+  /** 超大技能文件警告阈值，由调用方从 config 传入；0 = 静默，undefined = 用默认 10000 */
+  warnThreshold;
+  constructor(skillsDir, warnThreshold) {
+    this.skillsDir = skillsDir;
+    this.warnThreshold = warnThreshold ?? SKILL_CONTENT_WARN_CHARS_DEFAULT;
+  }
+  /** 发现并加载 skillsDir 下所有 .md 文件，返回加载数量 */
+  loadSkills() {
+    this.skills.clear();
+    if (!existsSync2(this.skillsDir)) {
+      try {
+        mkdirSync2(this.skillsDir, { recursive: true });
+      } catch {
+      }
+      return 0;
+    }
+    let entries;
+    try {
+      entries = readdirSync2(this.skillsDir);
+    } catch {
+      return 0;
+    }
+    for (const entry of entries) {
+      let filePath;
+      const fullPath = join2(this.skillsDir, entry);
+      if (entry.endsWith(".md")) {
+        filePath = fullPath;
+      } else {
+        try {
+          if (statSync(fullPath).isDirectory()) {
+            const skillMd = join2(fullPath, "SKILL.md");
+            if (existsSync2(skillMd)) {
+              filePath = skillMd;
+            } else {
+              continue;
+            }
+          } else {
+            continue;
+          }
+        } catch {
+          continue;
+        }
+      }
+      const skill = parseSkillFile(filePath);
+      if (skill) {
+        if (skill.meta.name === "SKILL" && !entry.endsWith(".md")) {
+          skill.meta.name = entry;
+        }
+        this.skills.set(skill.meta.name, skill);
+        if (this.warnThreshold > 0 && skill.content.length > this.warnThreshold) {
+          process.stderr.write(
+            `\u26A0 Skill '${skill.meta.name}' is ${skill.content.length} chars (>${this.warnThreshold}). Only consumed when activated via /skill. Adjust with: /config set ui.skillSizeWarn <n|0>
+`
+          );
+        }
+      }
+    }
+    return this.skills.size;
+  }
+  /** 列出所有已加载的技能 */
+  listSkills() {
+    return [...this.skills.values()];
+  }
+  /** 按 name 激活技能。返回被激活的 Skill，未找到返回 null。 */
+  activate(name) {
+    const skill = this.skills.get(name);
+    if (!skill) return null;
+    this.activeSkill = skill;
+    return skill;
+  }
+  /** 停用当前技能 */
+  deactivate() {
+    this.activeSkill = null;
+  }
+  /** 获取当前激活的技能（null 表示无激活技能） */
+  getActive() {
+    return this.activeSkill;
+  }
+  /** 获取激活技能的 prompt 内容（null 表示无激活技能） */
+  getActivePromptContent() {
+    return this.activeSkill?.content ?? null;
+  }
+  /** 获取激活技能的工具白名单 Set（null 表示无限制） */
+  getActiveToolFilter() {
+    if (!this.activeSkill?.meta.tools) return null;
+    return new Set(this.activeSkill.meta.tools);
+  }
+  /** 获取技能目录路径 */
+  getSkillsDir() {
+    return this.skillsDir;
+  }
+};
+
+// src/core/proxy.ts
+async function setupProxy(configProxy) {
+  const proxyUrl = process.env.HTTPS_PROXY ?? process.env.HTTP_PROXY ?? process.env.https_proxy ?? process.env.http_proxy ?? configProxy;
+  if (!proxyUrl) return;
+  try {
+    const { ProxyAgent, setGlobalDispatcher } = await import("undici");
+    setGlobalDispatcher(new ProxyAgent({ uri: proxyUrl }));
+  } catch {
+  }
+}
+
+// src/core/pricing.ts
+var PRICING_TABLE = {
+  // ── Anthropic Claude ──────────────────────────────────────────
+  "claude-opus-4-6": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+  "claude-opus-4-5": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  "claude-haiku-4-5-20251001": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 },
+  // Legacy Claude 3.x families (prefix fallback handles minor date suffixes)
+  "claude-3-5-sonnet": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  "claude-3-5-haiku": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 },
+  "claude-3-opus": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+  // ── OpenAI ────────────────────────────────────────────────────
+  "gpt-4o": { input: 2.5, output: 10, cacheRead: 1.25 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6, cacheRead: 0.075 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "gpt-4.1": { input: 2, output: 8, cacheRead: 0.5 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6, cacheRead: 0.1 },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4, cacheRead: 0.025 },
+  "o1": { input: 15, output: 60, cacheRead: 7.5 },
+  "o1-mini": { input: 3, output: 12, cacheRead: 1.5 },
+  "o3": { input: 10, output: 40, cacheRead: 2.5 },
+  "o3-mini": { input: 1.1, output: 4.4, cacheRead: 0.55 },
+  // ── Google Gemini ─────────────────────────────────────────────
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  // ── DeepSeek ──────────────────────────────────────────────────
+  // V4 family (2026-04-23+)：1M context, Thinking / Non-Thinking dual-mode, 384K max output
+  "deepseek-v4-pro": { input: 1.74, output: 3.48, cacheRead: 0.145 },
+  "deepseek-v4-flash": { input: 0.14, output: 0.28, cacheRead: 0.028 },
+  // Legacy aliases：retires 2026-07-24 UTC 15:59，官方 route 到 V4 Flash
+  "deepseek-chat": { input: 0.14, output: 0.28, cacheRead: 0.028 },
+  "deepseek-reasoner": { input: 0.14, output: 0.28, cacheRead: 0.028 },
+  "deepseek-v3": { input: 0.27, output: 1.1, cacheRead: 0.07 },
+  // ── Moonshot Kimi ─────────────────────────────────────────────
+  "moonshot-v1-8k": { input: 0.17, output: 0.17 },
+  "moonshot-v1-32k": { input: 0.33, output: 0.33 },
+  "moonshot-v1-128k": { input: 0.83, output: 0.83 },
+  "kimi-k2": { input: 0.6, output: 2.5 },
+  "kimi-latest": { input: 0.6, output: 2.5 },
+  // ── Zhipu GLM ─────────────────────────────────────────────────
+  "glm-4-plus": { input: 0.7, output: 0.7 },
+  "glm-4": { input: 0.14, output: 0.14 },
+  "glm-4-flash": { input: 0, output: 0 },
+  "glm-4.5": { input: 0.29, output: 1.14 },
+  "glm-4.6": { input: 0.6, output: 2.2 },
+  "glm-4.6v": { input: 0.6, output: 2.2 },
+  "glm-5": { input: 0.85, output: 2.85 },
+  "glm-5.1": { input: 0.95, output: 3.15 },
+  "glm-5.1-reasoning": { input: 1.4, output: 4.4 },
+  "glm-5.1-air": { input: 0.4, output: 1.2 },
+  "glm-z1": { input: 0.5, output: 1.5 },
+  "glm-z1-air": { input: 0.2, output: 0.6 },
+  "glm-z1-flash": { input: 0, output: 0 }
+  // ── OpenRouter (pass-through — actual cost depends on underlying model) ──
+  // Left empty; callers should resolve via underlying model ID.
+  // ── Ollama (local, zero cost) ─────────────────────────────────
+  // Handled via provider check below.
+};
+var FREE_PROVIDERS = /* @__PURE__ */ new Set(["ollama"]);
+function getPricing(provider, model) {
+  if (FREE_PROVIDERS.has(provider.toLowerCase())) {
+    return { input: 0, output: 0 };
+  }
+  const key = model.toLowerCase();
+  if (PRICING_TABLE[key]) return PRICING_TABLE[key];
+  const keys = Object.keys(PRICING_TABLE).sort((a, b) => b.length - a.length);
+  for (const k of keys) {
+    if (key.startsWith(k)) return PRICING_TABLE[k];
+  }
+  return null;
+}
+function computeCost(provider, model, usage) {
+  const p = getPricing(provider, model);
+  if (!p) return null;
+  const input = usage.inputTokens * p.input;
+  const output = usage.outputTokens * p.output;
+  const cacheWrite = (usage.cacheCreationTokens ?? 0) * (p.cacheWrite ?? p.input);
+  const cacheRead = (usage.cacheReadTokens ?? 0) * (p.cacheRead ?? p.input);
+  return (input + output + cacheWrite + cacheRead) / 1e6;
+}
+function formatCost(amount) {
+  if (amount === 0) return "$0.0000";
+  if (amount < 0.01) return `$${amount.toFixed(4)}`;
+  if (amount < 1) return `$${amount.toFixed(3)}`;
+  return `$${amount.toFixed(2)}`;
+}
+
+// src/session/tool-history.ts
+var SESSION_SIZE_LIMIT = 2 * 1024 * 1024;
+function persistToolRound(session, toolCalls, toolResults, opts) {
+  session.addMessage({
+    role: "assistant",
+    content: opts?.assistantContent ?? "",
+    toolCalls,
+    reasoningContent: opts?.reasoningContent,
+    timestamp: /* @__PURE__ */ new Date()
+  });
+  for (let i = 0; i < toolCalls.length; i++) {
+    const tc = toolCalls[i];
+    const tr = toolResults[i];
+    if (!tr) continue;
+    session.addMessage({
+      role: "tool",
+      content: truncateForPersist(tr.content),
+      toolCallId: tr.callId,
+      toolName: tc.name,
+      isError: tr.isError,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+}
+function trimOldToolOutput(messages, keepRecentRounds = 10) {
+  const roundStarts = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "assistant" && messages[i].toolCalls?.length) {
+      roundStarts.push(i);
+    }
+  }
+  if (roundStarts.length <= keepRecentRounds) return 0;
+  const cutoffRoundIdx = roundStarts.length - keepRecentRounds;
+  let trimmed = 0;
+  for (let r = 0; r < cutoffRoundIdx; r++) {
+    const start = roundStarts[r];
+    const end = r + 1 < roundStarts.length ? roundStarts[r + 1] : messages.length;
+    const assistantMsg = messages[start];
+    if (typeof assistantMsg.content === "string" && assistantMsg.content.length > 200) {
+      assistantMsg.content = assistantMsg.content.slice(0, 100) + "\u2026 [trimmed for size]";
+      trimmed++;
+    }
+    for (let j = start + 1; j < end; j++) {
+      const msg = messages[j];
+      if (msg.role === "tool") {
+        const status = msg.isError ? "\u2717 error" : "\u2713 ok";
+        const name = msg.toolName ?? "unknown";
+        const currentContent = typeof msg.content === "string" ? msg.content : "";
+        if (currentContent.length > 200) {
+          msg.content = `[${name}: ${status}] (output trimmed for size \u2014 ${currentContent.length} chars)`;
+          trimmed++;
+        }
+      }
+    }
+  }
+  return trimmed;
+}
+function cloneMessages(messages) {
+  return messages.map((m) => ({ ...m }));
+}
+function autoTrimSessionIfNeeded(session, sizeLimit = SESSION_SIZE_LIMIT) {
+  const originalSize = JSON.stringify(session.toJSON()).length;
+  if (originalSize <= sizeLimit) return false;
+  const snapshotLen = session.messages.length;
+  let working = cloneMessages(session.messages.slice(0, snapshotLen));
+  let committedSize = originalSize;
+  let anyTrim = false;
+  let keepRecent = 10;
+  while (keepRecent >= 2) {
+    const trimmedCount = trimOldToolOutput(working, keepRecent);
+    if (trimmedCount === 0) break;
+    anyTrim = true;
+    const originalMessages = session.messages;
+    session.messages = [...working, ...originalMessages.slice(snapshotLen)];
+    const newSize = JSON.stringify(session.toJSON()).length;
+    session.messages = originalMessages;
+    committedSize = newSize;
+    if (newSize <= sizeLimit) break;
+    keepRecent = Math.max(2, Math.floor(keepRecent / 2));
+    if (keepRecent < 2) break;
+  }
+  if (!anyTrim) return false;
+  const appended = session.messages.slice(snapshotLen);
+  session.messages.splice(0, session.messages.length, ...working, ...appended);
+  return committedSize < originalSize;
+}
+
+// src/repl/dev-state.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+var DEV_STATE_MAX_CHARS = 6e3;
+var SNAPSHOT_PROMPT = `You are about to be replaced by a different AI model. Please generate a structured development state snapshot so the next model can continue seamlessly.
+
+CRITICAL: Be SPECIFIC and DETAILED. Include exact values, file paths, format requirements, and constraints \u2014 vague summaries are useless to the next model.
+
+Output ONLY the snapshot in the following exact format (no preamble, no explanation):
+
+## Development State Snapshot
+
+### Current Task
+[1-2 sentence summary of the primary task/goal the user is working on]
+
+### Key Parameters & Constraints
+- [List ALL specific parameters, values, format requirements discovered during this conversation]
+- [Include exact numbers, dimensions, scoring rules, naming conventions, etc.]
+- [Example: "Exam duration 90 minutes, total score 200, 40 single-choice x2 pts + 20 multi-choice x4 pts + 20 true/false x2 pts"]
+- [Example: "File naming format YYYYMMDD-NN-mock-difficulty.md, saved to exam_papers/ directory"]
+
+### Completed Steps
+- [List each completed step with specific details (file paths, key outcomes)]
+
+### In-Progress Work
+- [List any work that was started but not finished]
+
+### Critical Reference Files
+- [List file paths that the next model MUST read before doing any work]
+- [Include brief description of each file's purpose]
+- [Example: "Exam2025.md \u2014 reference format for official past exams (90min/200pts/question type distribution)"]
+- [Example: "style-guide.md \u2014 style guidelines (character setup/scenario building/current events)"]
+
+### Modified/Created Files
+- [List any files that were created or modified, with brief notes on content]
+
+### Key Decisions & Context
+- [Important decisions, user preferences, or constraints established]
+
+### Next Steps
+- [What should be done next to continue this work]
+- [Include specific instructions the next model should follow]
+
+### Important Notes
+- [Any warnings, caveats, or critical context the next model needs to know]
+- [Things that went wrong or should be avoided]
+
+If any section has no content, write "(none)" for that section. Be thorough \u2014 the next model may have access to our conversation messages, but the detailed tool call results (file contents, command outputs) are NOT preserved. This snapshot is the primary source of specific details and context.`;
+function sessionHasMeaningfulContent(messages) {
+  if (messages.length < 2) return false;
+  const hasUser = messages.some((m) => m.role === "user");
+  const hasAssistant = messages.some((m) => m.role === "assistant");
+  return hasUser && hasAssistant;
+}
+function getDevStatePath() {
+  return join3(homedir(), CONFIG_DIR_NAME, DEV_STATE_FILE_NAME);
+}
+function saveDevState(content) {
+  const configDir = join3(homedir(), CONFIG_DIR_NAME);
+  if (!existsSync3(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
+  }
+  let trimmed = content.trim();
+  if (trimmed.length > DEV_STATE_MAX_CHARS) {
+    trimmed = trimmed.slice(0, DEV_STATE_MAX_CHARS);
+    const lastNewline = trimmed.lastIndexOf("\n");
+    if (lastNewline > 0) {
+      trimmed = trimmed.slice(0, lastNewline);
+    }
+    trimmed += "\n\n[...truncated]";
+  }
+  writeFileSync2(getDevStatePath(), trimmed, "utf-8");
+}
+function loadDevState() {
+  const path = getDevStatePath();
+  if (!existsSync3(path)) return null;
+  const content = readFileSync3(path, "utf-8").trim();
+  return content || null;
+}
+function clearDevState() {
+  const path = getDevStatePath();
+  if (existsSync3(path)) {
+    try {
+      unlinkSync2(path);
+    } catch {
+    }
+  }
+}
+
+export {
+  getContentText,
+  SessionManager,
+  getPricing,
+  computeCost,
+  formatCost,
+  parseSimpleYaml,
+  persistToolRound,
+  autoTrimSessionIfNeeded,
+  SNAPSHOT_PROMPT,
+  sessionHasMeaningfulContent,
+  saveDevState,
+  loadDevState,
+  clearDevState,
+  McpManager,
+  SkillManager,
+  setupProxy
+};