chatccc 0.2.251 → 0.2.253

package/deepccc-agent/src/session-search.ts

@@ -1,370 +0,0 @@
-/**
- * session-search.ts — DeepCCC 历史会话关键词检索
- *
- * 供 agent 通过 session_search 工具按需查找很久以前的原始消息/工具调用：
- * - 主数据源：~/.deepccc/sessions/<sessionId>/context.json（明文 JSON，含 summary、
- *   messages.content 与结构化 toolCalls）
- * - 可选数据源：~/.deepccc/raw-stream-logs/deepccc/<sessionId>/*.jsonl.gz（gzip 原始流，
- *   逐行解压检索，默认关闭）
- *
- * 纯关键词匹配（多词 AND、大小写不敏感），不依赖向量索引。
- */
-
-import { createReadStream, existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { createInterface } from "node:readline";
-import { createGunzip } from "node:zlib";
-
-import { RAW_STREAM_LOGS_DIR } from "./config.js";
-import { DEFAULT_BUILTIN_CONTEXT_DIR, type BuiltinContextRole } from "./context.js";
-
-export interface SessionSearchOptions {
-  /** 会话目录，默认 ~/.deepccc/sessions */
-  contextDir?: string;
-  /** raw-stream-logs 根目录，默认 ~/.deepccc/raw-stream-logs */
-  rawLogsDir?: string;
-  /** 是否搜索 gzip 原始流日志（默认 false，较慢） */
-  includeRawLogs?: boolean;
-  /** 只搜索指定 sessionId（目录名或 state.sessionId 匹配） */
-  sessionId?: string;
-  /** 结果上限（默认 20，上限 50） */
-  maxResults?: number;
-  /** 单条命中片段最大字符数（默认 400） */
-  maxSnippetChars?: number;
-  /** 单个 raw log 文件最多解压检索的字节数（默认 4MB） */
-  maxRawLogBytesPerFile?: number;
-}
-
-export interface SessionSearchInput {
-  query: string;
-  session_id?: string;
-  include_raw_logs?: boolean;
-  max_results?: number;
-}
-
-export interface SessionSearchMatch {
-  sessionId: string;
-  source: "context" | "summary" | "raw-log";
-  role?: BuiltinContextRole;
-  /** 在 messages 数组中的下标 */
-  messageIndex?: number;
-  /** 在 message.toolCalls 数组中的下标（仅结构化工具调用命中时） */
-  toolCallIndex?: number;
-  toolCallName?: string;
-  snippet: string;
-  filePath: string;
-}
-
-export interface SessionSearchOutput {
-  query: string;
-  terms: string[];
-  matches: SessionSearchMatch[];
-  truncated: boolean;
-  scannedSessions: number;
-  scannedRawLogFiles: number;
-}
-
-const DEFAULT_MAX_RESULTS = 20;
-const MAX_RESULTS_CAP = 50;
-const DEFAULT_MAX_SNIPPET_CHARS = 400;
-const MAX_SNIPPET_CHARS_CAP = 2_000;
-const DEFAULT_MAX_RAW_LOG_BYTES_PER_FILE = 4 * 1024 * 1024;
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.min(max, Math.max(min, value));
-}
-
-function tokenize(query: string): string[] {
-  return query
-    .toLowerCase()
-    .split(/\s+/)
-    .map((term) => term.trim())
-    .filter((term) => term.length > 0);
-}
-
-/** 多词 AND、大小写不敏感：候选文本必须包含全部关键词 */
-function matchesTerms(text: string, terms: readonly string[]): boolean {
-  const lower = text.toLowerCase();
-  return terms.every((term) => lower.includes(term));
-}
-
-function makeSnippet(text: string, terms: readonly string[], maxChars: number): string {
-  if (text.length <= maxChars) return text;
-  const lower = text.toLowerCase();
-  let hitIndex = -1;
-  for (const term of terms) {
-    const index = lower.indexOf(term);
-    if (index !== -1) {
-      hitIndex = index;
-      break;
-    }
-  }
-  const half = Math.floor(maxChars / 2);
-  if (hitIndex === -1) {
-    return `${text.slice(0, half)}…${text.slice(-half)}`;
-  }
-  const start = Math.max(0, hitIndex - half);
-  const end = Math.min(text.length, hitIndex + half);
-  const prefix = start > 0 ? "…" : "";
-  const suffix = end < text.length ? "…" : "";
-  return `${prefix}${text.slice(start, end)}${suffix}`;
-}
-
-interface ContextSearchResult {
-  matches: SessionSearchMatch[];
-  scannedSessions: number;
-  /** 命中总数（含被 maxResults 截断的部分），用于精确的 truncated 判定 */
-  totalHits: number;
-}
-
-function searchContextDir(
-  query: string,
-  options: SessionSearchOptions,
-  maxResults: number,
-  maxSnippetChars: number,
-): ContextSearchResult {
-  const dir = options.contextDir ?? DEFAULT_BUILTIN_CONTEXT_DIR;
-  const terms = tokenize(query);
-  const matches: SessionSearchMatch[] = [];
-  if (terms.length === 0 || !existsSync(dir)) {
-    return { matches, scannedSessions: 0, totalHits: 0 };
-  }
-
-  const restrictTo = options.sessionId?.trim();
-
-  let scannedSessions = 0;
-  let totalHits = 0;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    if (restrictTo && entry.name !== restrictTo) continue;
-    const filePath = join(dir, entry.name, "context.json");
-    if (!existsSync(filePath)) continue;
-
-    let state: {
-      sessionId?: unknown;
-      summary?: unknown;
-      messages?: unknown;
-    };
-    try {
-      state = JSON.parse(readFileSync(filePath, "utf8")) as typeof state;
-    } catch {
-      continue; // 损坏或非 JSON 的会话文件跳过
-    }
-    if (!state || typeof state !== "object") continue;
-    if (restrictTo && state.sessionId !== restrictTo && entry.name !== restrictTo) continue;
-    scannedSessions += 1;
-    const sessionId = typeof state.sessionId === "string" ? state.sessionId : entry.name;
-
-    if (typeof state.summary === "string" && matchesTerms(state.summary, terms)) {
-      totalHits += 1;
-      matches.push({
-        sessionId,
-        source: "summary",
-        snippet: makeSnippet(state.summary, terms, maxSnippetChars),
-        filePath,
-      });
-    }
-
-    if (Array.isArray(state.messages)) {
-      state.messages.forEach((message, messageIndex) => {
-        if (!message || typeof message !== "object") return;
-        const raw = message as { role?: unknown; content?: unknown; toolCalls?: unknown };
-        const role: BuiltinContextRole | undefined =
-          raw.role === "user" || raw.role === "assistant" ? raw.role : undefined;
-
-        if (typeof raw.content === "string" && matchesTerms(raw.content, terms)) {
-          totalHits += 1;
-          matches.push({
-            sessionId,
-            source: "context",
-            role,
-            messageIndex,
-            snippet: makeSnippet(raw.content, terms, maxSnippetChars),
-            filePath,
-          });
-        }
-
-        if (Array.isArray(raw.toolCalls)) {
-          raw.toolCalls.forEach((call, toolCallIndex) => {
-            if (!call || typeof call !== "object") return;
-            const callRaw = call as { name?: unknown; input?: unknown; output?: unknown };
-            const name = typeof callRaw.name === "string" ? callRaw.name : "";
-            const input = typeof callRaw.input === "string" ? callRaw.input : "";
-            const output = typeof callRaw.output === "string" ? callRaw.output : "";
-            if (name.length === 0 && input.length === 0 && output.length === 0) return;
-            const haystack = [name, input, output].join("\n");
-            if (!matchesTerms(haystack, terms)) return;
-            totalHits += 1;
-            const source = output || input || name;
-            matches.push({
-              sessionId,
-              source: "context",
-              role,
-              messageIndex,
-              toolCallIndex,
-              toolCallName: name,
-              snippet: makeSnippet(source, terms, maxSnippetChars),
-              filePath,
-            });
-          });
-        }
-      });
-    }
-  }
-
-  return { matches: matches.slice(0, maxResults), scannedSessions, totalHits };
-}
-
-interface RawLogSearchResult {
-  matches: SessionSearchMatch[];
-  scannedFiles: number;
-  /** raw log 流式解压提前截断（达到 maxResults 停止扫描剩余文件） */
-  truncated: boolean;
-}
-
-async function searchRawLogs(
-  query: string,
-  options: SessionSearchOptions,
-  maxResults: number,
-  maxSnippetChars: number,
-): Promise<RawLogSearchResult> {
-  const terms = tokenize(query);
-  const rootDir = options.rawLogsDir ?? RAW_STREAM_LOGS_DIR;
-  const matches: SessionSearchMatch[] = [];
-  if (terms.length === 0 || !existsSync(rootDir)) {
-    return { matches, scannedFiles: 0, truncated: false };
-  }
-
-  const toolRoot = join(rootDir, "deepccc");
-  if (!existsSync(toolRoot)) return { matches, scannedFiles: 0, truncated: false };
-
-  const restrictTo = options.sessionId?.trim();
-  const maxBytesPerFile = Math.max(0, options.maxRawLogBytesPerFile ?? DEFAULT_MAX_RAW_LOG_BYTES_PER_FILE);
-
-  // 收集所有 .jsonl.gz 文件，按 mtime 新→旧排序（最新轮次优先）
-  const files: { path: string; sessionId: string; mtimeMs: number }[] = [];
-  for (const sessionEntry of readdirSync(toolRoot, { withFileTypes: true })) {
-    if (!sessionEntry.isDirectory()) continue;
-    if (restrictTo && sessionEntry.name !== restrictTo) continue;
-    const sessionDir = join(toolRoot, sessionEntry.name);
-    let entries;
-    try {
-      entries = readdirSync(sessionDir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const fileEntry of entries) {
-      if (!fileEntry.isFile() || !fileEntry.name.endsWith(".jsonl.gz")) continue;
-      const filePath = join(sessionDir, fileEntry.name);
-      try {
-        const info = statSync(filePath);
-        files.push({ path: filePath, sessionId: sessionEntry.name, mtimeMs: info.mtimeMs });
-      } catch {
-        // 无法 stat 的文件跳过
-      }
-    }
-  }
-  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
-
-  let scannedFiles = 0;
-  let truncated = false;
-  for (const file of files) {
-    if (matches.length >= maxResults) {
-      truncated = true;
-      break;
-    }
-    scannedFiles += 1;
-    const snippets = await searchGzipFileLines(file.path, terms, maxBytesPerFile, maxSnippetChars);
-    for (const snippet of snippets) {
-      matches.push({
-        sessionId: file.sessionId,
-        source: "raw-log",
-        snippet,
-        filePath: file.path,
-      });
-      if (matches.length >= maxResults) break;
-    }
-  }
-
-  return { matches: matches.slice(0, maxResults), scannedFiles, truncated };
-}
-
-async function searchGzipFileLines(
-  filePath: string,
-  terms: readonly string[],
-  maxBytes: number,
-  maxSnippetChars: number,
-): Promise<string[]> {
-  const hits: string[] = [];
-  let bytes = 0;
-  try {
-    const source = createReadStream(filePath);
-    const gunzip = createGunzip();
-    // 防崩溃（线上事故）：截断/损坏的 gzip 会在 zlib 层 emit 'error'（如
-    // "unexpected end of file"）。若无人监听，错误事件会升级为 uncaughtException
-    // 直接杀死整个服务（崩溃黑匣子 exit(1)）。显式挂监听把错误降级为
-    // “跳过该文件”：destroy 流让 for await 正常结束，不再冒泡。
-    source.on("error", () => gunzip.destroy());
-    gunzip.on("error", () => gunzip.destroy());
-    const reader = createInterface({ input: source.pipe(gunzip), crlfDelay: Infinity });
-    // readline 会把 input 流的 error 转发到自己身上，同样需要监听避免冒泡
-    reader.on("error", () => {});
-    for await (const line of reader) {
-      bytes += Buffer.byteLength(line, "utf-8");
-      if (bytes > maxBytes) break;
-      if (!matchesTerms(line, terms)) continue;
-      hits.push(makeSnippet(line, terms, maxSnippetChars));
-      if (hits.length >= 50) break;
-    }
-  } catch {
-    // 损坏的 gzip 文件按 best-effort 跳过
-  }
-  return hits;
-}
-
-/**
- * 关键词检索历史会话存档。context.json 为同步扫描；raw-stream-logs 为
- * gzip 逐行解压（异步，仅 options.includeRawLogs 时启用）。
- */
-export async function searchBuiltinSessions(
-  query: string,
-  options: SessionSearchOptions = {},
-): Promise<SessionSearchOutput> {
-  const terms = tokenize(query);
-  const maxResults = clamp(options.maxResults ?? DEFAULT_MAX_RESULTS, 1, MAX_RESULTS_CAP);
-  const maxSnippetChars = clamp(
-    options.maxSnippetChars ?? DEFAULT_MAX_SNIPPET_CHARS,
-    80,
-    MAX_SNIPPET_CHARS_CAP,
-  );
-
-  if (terms.length === 0) {
-    return {
-      query,
-      terms,
-      matches: [],
-      truncated: false,
-      scannedSessions: 0,
-      scannedRawLogFiles: 0,
-    };
-  }
-
-  const contextResult = searchContextDir(query, options, maxResults, maxSnippetChars);
-  let rawResult: RawLogSearchResult = { matches: [], scannedFiles: 0, truncated: false };
-  if (options.includeRawLogs) {
-    rawResult = await searchRawLogs(query, options, maxResults, maxSnippetChars);
-  }
-
-  const matches = [...contextResult.matches, ...rawResult.matches].slice(0, maxResults);
-  const truncated =
-    contextResult.totalHits > maxResults || rawResult.truncated || rawResult.matches.length > maxResults;
-
-  return {
-    query,
-    terms,
-    matches,
-    truncated,
-    scannedSessions: contextResult.scannedSessions,
-    scannedRawLogFiles: rawResult.scannedFiles,
-  };
-}

package/deepccc-agent/src/session-select.ts

@@ -1,48 +0,0 @@
-import {
-  DEFAULT_BUILTIN_CONTEXT_DIR,
-  getBuiltinContextSession,
-  latestBuiltinSessionForCwd,
-  newBuiltinSessionId,
-  normalizeBuiltinSessionId,
-} from "./context.js";
-
-export type BuiltinResumeRequest = true | string | undefined;
-
-export interface ResolveBuiltinSessionOptions {
-  cwd: string;
-  contextDir?: string;
-  resume?: BuiltinResumeRequest;
-  now?: Date;
-  randomSuffix?: string;
-}
-
-export interface ResolvedBuiltinSession {
-  mode: "new" | "resumed";
-  sessionId: string;
-}
-
-export function resolveBuiltinSession(options: ResolveBuiltinSessionOptions): ResolvedBuiltinSession {
-  const contextDir = options.contextDir ?? DEFAULT_BUILTIN_CONTEXT_DIR;
-
-  if (options.resume === true) {
-    const latest = latestBuiltinSessionForCwd(options.cwd, contextDir);
-    if (!latest) {
-      throw new Error(`No resumable DeepCCC session found for cwd: ${options.cwd}`);
-    }
-    return { mode: "resumed", sessionId: latest.sessionId };
-  }
-
-  if (typeof options.resume === "string") {
-    const sessionId = normalizeBuiltinSessionId(options.resume);
-    const existing = getBuiltinContextSession(sessionId, contextDir);
-    if (!existing) {
-      throw new Error(`DeepCCC session not found: ${sessionId}`);
-    }
-    return { mode: "resumed", sessionId };
-  }
-
-  return {
-    mode: "new",
-    sessionId: newBuiltinSessionId(options.now, options.randomSuffix),
-  };
-}

package/deepccc-agent/src/sigint.ts

@@ -1,50 +0,0 @@
-export const CTRL_C_CONFIRM_WINDOW_MS = 2000;
-
-export type CtrlCAction =
-  | "arm-interrupt"
-  | "interrupt"
-  | "arm-exit"
-  | "exit";
-
-type PendingCtrlCAction = "interrupt" | "exit";
-
-export interface CtrlCStateOptions {
-  windowMs?: number;
-  now?: () => number;
-}
-
-export interface CtrlCState {
-  press(isGenerating: boolean): CtrlCAction;
-  reset(): void;
-}
-
-export function createCtrlCState(options: CtrlCStateOptions = {}): CtrlCState {
-  const windowMs = options.windowMs ?? CTRL_C_CONFIRM_WINDOW_MS;
-  const now = options.now ?? Date.now;
-
-  let pending: PendingCtrlCAction | null = null;
-  let lastPressAt = 0;
-
-  return {
-    press(isGenerating: boolean): CtrlCAction {
-      const action: PendingCtrlCAction = isGenerating ? "interrupt" : "exit";
-      const current = now();
-      const isConfirmed = pending === action && current - lastPressAt <= windowMs;
-
-      if (isConfirmed) {
-        pending = null;
-        lastPressAt = 0;
-        return action;
-      }
-
-      pending = action;
-      lastPressAt = current;
-      return isGenerating ? "arm-interrupt" : "arm-exit";
-    },
-
-    reset(): void {
-      pending = null;
-      lastPressAt = 0;
-    },
-  };
-}

package/deepccc-agent/src/skills.ts

@@ -1,205 +0,0 @@
-/**
- * skills.ts — 多来源技能扫描（DeepCCC 统一入口）
- *
- * 并行扫描 Claude / Codex / Cursor / DeepCCC 四套目录式技能
- * （<name>/SKILL.md + YAML frontmatter，三套生态同构）。
- *
- * 同名优先级（高 → 低）：deepccc > codex > cursor > claude；
- * 同来源内：project（项目级）> global（用户级）。
- * 目录列表按低 → 高排列，扫描时后者覆盖前者，天然实现优先级。
- *
- * 热加载：SKILL.md 内容带 mtime 缓存，文件变化时自动重读；
- * 目录枚举每次都做（新技能目录立即被发现）。因此"创建技能 →
- * 下一次对话自动生效"，无需重启，也无需常驻 watcher。
- */
-
-import { readdirSync } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-export type SkillSource = "deepccc" | "codex" | "cursor" | "claude";
-export type SkillScope = "global" | "project";
-
-export interface BuiltinSkill {
-  name: string;
-  description: string;
-  /** SKILL.md 的绝对路径 */
-  skillPath: string;
-  /** 来源（优先级 deepccc > codex > cursor > claude） */
-  source: SkillSource;
-  /** global = 用户级；project = 项目级（同来源内 project > global） */
-  scope: SkillScope;
-}
-
-export interface SkillDirSpec {
-  dir: string;
-  source: SkillSource;
-  scope: SkillScope;
-}
-
-/** 解析 SKILL.md frontmatter（兼容 CRLF），返回 name + description；无 frontmatter 返回 null */
-export function parseSkillFrontmatter(
-  content: string,
-): { name: string; description: string } | null {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/.exec(content);
-  if (!match) return null;
-  const fm = match[1];
-  const nameMatch = /^name:\s*(.+?)\s*$/m.exec(fm);
-  if (!nameMatch) return null;
-  const descMatch = /^description:\s*(.+?)\s*$/m.exec(fm);
-  return {
-    name: nameMatch[1].trim(),
-    description: descMatch?.[1].trim() ?? "",
-  };
-}
-
-// ---------------------------------------------------------------------------
-// mtime 热加载缓存：同一进程内重复扫描命中缓存（stat 校验），文件变化自动重读
-// ---------------------------------------------------------------------------
-
-const skillFileCache = new Map<string, { mtimeMs: number; content: string }>();
-
-async function readSkillFile(skillPath: string): Promise<string | null> {
-  let st;
-  try {
-    st = await stat(skillPath);
-  } catch {
-    return null;
-  }
-  if (!st.isFile()) return null;
-  const cached = skillFileCache.get(skillPath);
-  if (cached && cached.mtimeMs === st.mtimeMs) return cached.content;
-  const content = await readFile(skillPath, "utf8");
-  skillFileCache.set(skillPath, { mtimeMs: st.mtimeMs, content });
-  return content;
-}
-
-/**
- * 扫描多个 skill 目录（并行读取），按 name 去重。
- * 同名技能：后面的 spec（高优先级）覆盖前面的（低优先级）。
- * 隐藏目录（.system 等）和无 SKILL.md 的目录会被跳过；缺失目录跳过。
- */
-export async function scanSkillsDirs(dirs: SkillDirSpec[]): Promise<BuiltinSkill[]> {
-  const byName = new Map<string, BuiltinSkill>();
-
-  for (const spec of dirs) {
-    let entries;
-    try {
-      entries = readdirSync(spec.dir, { withFileTypes: true });
-    } catch {
-      continue; // 目录不存在或不可读：跳过
-    }
-
-    // 目录内所有候选 SKILL.md 并行读取（读文件是扫描的瓶颈）
-    const results = await Promise.all(
-      entries
-        .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
-        .map(async (entry) => {
-          const skillPath = join(spec.dir, entry.name, "SKILL.md");
-          const content = await readSkillFile(skillPath);
-          if (content === null) return null;
-          const parsed = parseSkillFrontmatter(content);
-          if (!parsed) return null;
-          return { ...parsed, skillPath };
-        }),
-    );
-
-    for (const result of results) {
-      if (!result) continue;
-      byName.set(result.name, {
-        name: result.name,
-        description: result.description,
-        skillPath: result.skillPath,
-        source: spec.source,
-        scope: spec.scope,
-      });
-    }
-  }
-
-  return [...byName.values()];
-}
-
-/**
- * 默认技能扫描目录（按优先级从低到高排列，扫描时后者覆盖前者）：
- * claude(global→project) < cursor(global→project) < codex(global→project) < deepccc(global→project)
- * 其中 codex 全局包含 ~/.codex/skills（CLI 旧路径）与 ~/.agents/skills（标准全局目录）。
- */
-export function buildDefaultSkillDirs(cwd: string): SkillDirSpec[] {
-  const h = homedir();
-  return [
-    { dir: join(h, ".claude", "skills"), source: "claude", scope: "global" },
-    { dir: join(cwd, ".claude", "skills"), source: "claude", scope: "project" },
-    { dir: join(h, ".cursor", "skills"), source: "cursor", scope: "global" },
-    { dir: join(cwd, ".cursor", "skills"), source: "cursor", scope: "project" },
-    { dir: join(h, ".codex", "skills"), source: "codex", scope: "global" },
-    { dir: join(h, ".agents", "skills"), source: "codex", scope: "global" },
-    { dir: join(cwd, ".codex", "skills"), source: "codex", scope: "project" },
-    { dir: join(h, ".deepccc", "skills"), source: "deepccc", scope: "global" },
-    { dir: join(cwd, ".deepccc", "skills"), source: "deepccc", scope: "project" },
-  ];
-}
-
-/**
- * 把技能绝对路径转成 prompt 展示形式：主目录下的路径缩写为 `~/...`（跨机器、
- * 跨用户稳定，避免用户名/盘符差异导致 system 前缀变化破坏缓存命中）；
- * 分隔符统一为 `/`。主目录外的路径保持绝对路径（仅统一分隔符）。
- */
-export function normalizeSkillPathForPrompt(skillPath: string): string {
-  const home = homedir().replace(/[\\/]+$/, "").replace(/\\/g, "/");
-  const normalized = skillPath.replace(/\\/g, "/");
-  if (normalized === home) return "~";
-  if (normalized.startsWith(home + "/")) {
-    return "~" + normalized.slice(home.length);
-  }
-  return normalized;
-}
-
-/**
- * 生成 skill 索引提示词（注入 system prompt）。
- * 索引只含 name + description + 来源 + 路径，并指示模型在任务匹配时
- * 先用 read_file 读取 SKILL.md 全文再执行；同时声明"创建技能"约定
- * （模型在对话中应把新技能创建到 ~/.deepccc/skills 或项目 .deepccc/skills）。
- * 路径经 normalizeSkillPathForPrompt 缩写，保持跨机器前缀稳定。
- */
-export function buildSkillsIndexPrompt(skills: BuiltinSkill[]): string {
-  if (skills.length === 0) return "";
-
-  const lines = [
-    "## 可用技能",
-    "技能会从 Claude/Codex/Cursor/DeepCCC 技能目录并行扫描。",
-    "名称冲突时：DeepCCC > Codex > Cursor > Claude 优先；同一来源内，项目级优先于全局。",
-    "当用户请求匹配某个技能的描述时，先用 read_file 读取其完整 SKILL.md，然后严格按其指令执行。",
-    "",
-    ...skills.map((s) => `- **${s.name}** [${s.source}:${s.scope}] (\`${normalizeSkillPathForPrompt(s.skillPath)}\`): ${s.description || "(无描述)"}`),
-    "",
-    "## 创建技能",
-    "当用户要求创建技能时，按 Codex 风格的目录技能创建：",
-    "~/.deepccc/skills/<name>/SKILL.md（全局，默认）或 <cwd>/.deepccc/skills/<name>/SKILL.md（项目级，仅当用户明确要求项目级技能时）。",
-    "SKILL.md 格式：",
-    "```",
-    "---",
-    "name: <skill-name>",
-    "description: <one-line description>",
-    "---",
-    "",
-    "<instructions>",
-    "```",
-    "新技能会在下一条消息自动生效（热加载）；无需重启。",
-  ];
-  return lines.join("\n");
-}
-
-/** 生成 Codex 结构的新技能 SKILL.md 模板（供 CLI skill create / 对话创建约定共用） */
-export function buildSkillTemplate(name: string, description: string): string {
-  return [
-    "---",
-    `name: ${name}`,
-    `description: ${description}`,
-    "---",
-    "",
-    `# ${name}`,
-    "",
-    "<skill instructions>",
-    "",
-  ].join("\n");
-}