Context-Mode 深度实战：当 AI 编程成本暴涨到让人肉疼——一个 MCP 插件如何用「沙盒隔离」+「Think in Code」将 Token 消耗砍掉 98%，连续编程时间从 30 分钟拉到 3 小时

引言：一个所有 AI 程序员都经历过但没人认真解决的问题

如果你在用 Claude Code、Cursor、Gemini CLI 或者任何 AI 编程助手，你一定经历过这个场景：

刚开始编程时 AI 表现完美，代码写得飞快。30 分钟后，它开始犯蠢——忘记之前定义的接口、重复造轮子、对同一个 Bug 反复试错。你怀疑它变笨了，其实不是，它只是「失忆」了。

这背后的根本原因不是模型能力不够，而是上下文窗口被垃圾数据塞满了。

让我用真实数据给你算一笔账：

• 一次 Playwright 页面快照：56 KB
• 拉取 20 个 GitHub Issue：59 KB
• 一份 access log：45 KB
• 读 50 个源码文件：700 KB

主流 AI 编程助手的上下文窗口通常是 128K-200K tokens。按照 1 个中文字符约 2 tokens、1 个英文词约 1.3 tokens 来算，30 分钟的常规开发就能消耗掉 40% 的上下文窗口。当窗口快满时，系统会触发 compaction（压缩）——而压缩就意味着信息丢失。

更糟糕的是，你还在为此付钱。Claude Sonnet 输入 3 美元/百万 token，Opus 15 美元/百万 token，GPT-4o 也不便宜。当你发现一个月的 API 账单高达几百美元，其中一大半花在了「让 AI 读垃圾数据」上的时候——那种感觉，怎么说呢，就像雇了一个时薪 500 美元的程序员，结果他每天花 3 个小时在翻垃圾桶。

context-mode 就是来解决这个问题的。它是一个开源 MCP（Model Context Protocol）插件，登顶过 GitHub 和 Hacker News，获得 1.5 万+ Star，被 24.3 万开发者接入，微软、谷歌、Meta、字节跳动、Cursor 的团队都在用。核心效果很粗暴：Token 消耗降低 98%，连续有效编程时间从 30 分钟拉到 3 小时。

本文将从四个维度深度拆解 context-mode：它是怎么做到的、架构怎么设计、代码怎么接入、性能怎么优化。

一、问题全景：为什么 AI 编程的上下文管理比你想的更糟糕

1.1 四大 Token 浪费源头

在没有专业的上下文治理之前，几乎所有 AI 编程场景都存在四类结构性浪费：

浪费一：原始数据无脑灌入

工具调用返回的海量原始数据——文件内容、网页快照、Git 日志、shell 输出——被直接原样塞入上下文。比如你让 AI 检查一个项目的构建错误，npm run build 的输出可能有几十 KB，全部进入上下文。AI 需要在一大堆堆栈追踪里找到真正有用的那几行。

浪费二：多轮对话冗余堆积

历史对话不做筛选、不压缩、不归档。已解决的问题、过期的需求、无效的闲聊持续占用 Token。更致命的是，这些冗余信息会干扰模型的注意力——上下文越长，模型越容易被无关信息带偏。

浪费三：把 LLM 当数据处理机器滥用

这是最容易被忽略也最昂贵的浪费。批量读文件、统计代码行数、遍历目录——这些本该用脚本一次搞定的事，AI 会通过几十次工具调用逐个处理。为什么？因为没有人告诉它「用代码思考」。

一个真实案例：有人让 Claude 做 Kaggle 数据竞赛的训练任务，Claude 没有写一个定时监控脚本，而是每隔 5 秒对整个项目发起一次全局检索——结果，一个高配会员账号的 API 额度在半小时内消耗了 90%。

浪费四：模型输出冗余

AI 喜欢说废话。"好的，我来帮你处理这个问题。首先我们需要了解项目的整体结构，然后逐步分析..."——这些铺垫语、客套话、重复解释，每一句都在消耗输出 Token，同时挤占下一轮对话的上下文空间。

1.2 一个触目惊心的成本模型

让我用一个典型场景来量化这个问题：

假设你用 Claude Opus 做一个中型项目的重构（涉及约 50 个文件），工作 8 小时：

按照 Opus 的定价（15 美元/百万输入 token + 75 美元/百万输出 token），这些数据大致消耗：

• 输入：1845 KB ≈ 460K tokens → 约 6.9 美元
• 输出：300 KB ≈ 75K tokens → 约 5.6 美元
• 单日成本：约 12.5 美元，月成本：约 250 美元

而这其中，超过 60% 的 Token 是完全可以避免的。

1.3 Compaction 隐患：压缩不等于理解

当上下文窗口快满时，AI 编程助手会触发 compaction——把历史对话压缩成摘要。问题是：

1. 关键细节丢失：你第 15 分钟告诉 AI "API 端点要用 /v2 不是 /v1"，这个约束在压缩后很可能变成 "用户对 API 版本有要求"——具体是 v1 还是 v2？丢了。
2. 任务状态模糊化：正在进行的 3 个并行任务，压缩后可能变成 "用户有多个待办事项"——哪个优先？哪个已完成？不清楚。
3. Bug 上下文断裂：AI 花 10 轮对话终于定位到一个 Bug 的根因，压缩后只剩一句 "发现了一个并发相关的问题"——下次 AI 又要重新分析一遍。

这不是模型能力问题，这是上下文工程问题。

二、Context-Mode 架构深度解析

2.1 整体架构设计

context-mode 的核心思路可以概括为一句话：在大模型和操作系统之间建一道「防火墙」，只让有效信息通过。

┌─────────────────────────────────────────────┐
│              AI 编程助手 (Claude/Cursor/...)  │
│  ┌───────────────────────────────────────┐  │
│  │         上下文窗口 (Context Window)      │  │
│  │   只包含：摘要、索引、关键决策、任务状态    │  │
│  └───────────────────────────────────────┘  │
├─────────────────────────────────────────────┤
│           Context-Mode MCP Server            │
│  ┌──────────┐ ┌──────────┐ ┌─────────────┐ │
│  │ 沙盒引擎  │ │ 语义检索  │ │ Think in    │ │
│  │ Sandbox  │ │ FTS5+BM25│ │ Code 引擎   │ │
│  └──────────┘ └──────────┘ └─────────────┘ │
│  ┌──────────┐ ┌──────────────────────────┐  │
│  │ 钩子系统  │ │ 会话持久化 SQLite        │  │
│  │ Hooks   │ │ Session Persistence      │  │
│  └──────────┘ └──────────────────────────┘  │
├─────────────────────────────────────────────┤
│              本地文件系统 / Shell              │
└─────────────────────────────────────────────┘

架构分三层：

1. 上层（AI 编程助手）：只看到精简后的上下文——摘要、索引引用、任务状态快照。原始数据被完全隔离。
2. 中层（Context-Mode MCP Server）：核心处理层，包含沙盒引擎、语义检索、代码执行引擎、钩子系统、会话持久化五个核心模块。
3. 下层（本地文件系统）：实际的文件读写、命令执行发生在这里，结果被中层拦截和处理后再传递给上层。

2.2 四大核心机制详解

机制一：上下文沙盒隔离（Context Saving）

核心原理：不把工具调用的原始返回数据直接放入上下文窗口，而是先存入本地 SQLite 数据库，只把精简后的摘要或索引引用传给模型。

实现流程：

工具调用请求
    ↓
Context-Mode 拦截 (PreToolUse Hook)
    ↓
工具正常执行，原始数据流入沙盒 (SQLite + FTS5)
    ↓
生成精简摘要/索引引用 (< 原始数据 2%)
    ↓
摘要替代原始数据进入上下文窗口

实际效果数据：

SQLite + FTS5 为什么是正确选择：

SQLite 是嵌入式数据库，零配置、零依赖、单文件部署，非常适合本地工具。FTS5（Full-Text Search 5）是 SQLite 内置的全文搜索引擎，支持 BM25 排序、中文分词、前缀匹配，性能在百万级文档下依然毫秒级响应。用 FTS5 建立语义索引后，context-mode 可以在毫秒内检索到与当前任务最相关的历史片段，而不是暴力遍历整个数据库。

沙盒引擎代码结构（简化示意）：

// context-mode 沙盒引擎核心逻辑（伪代码简化）
interface SandboxResult {
  id: string;           // 唯一标识，用于后续检索
  summary: string;      // 精简摘要，< 200 tokens
  tokenCount: number;   // 原始 token 数
  savedTokens: number;  // 节省的 token 数
  fullDataRef: string;  // 原始数据在 SQLite 中的引用
}

class SandboxEngine {
  private db: Database; // SQLite 实例
  
  // 拦截工具调用，将原始输出存入沙盒
  async interceptToolOutput(
    toolName: string,
    rawOutput: string
  ): Promise<SandboxResult> {
    const originalTokens = estimateTokens(rawOutput);
    
    // 生成精简摘要
    const summary = await this.generateSummary(rawOutput);
    
    // 存入 SQLite + FTS5 索引
    const id = await this.db.store({
      tool: toolName,
      raw: rawOutput,
      summary: summary,
      timestamp: Date.now()
    });
    
    return {
      id,
      summary,
      tokenCount: originalTokens,
      savedTokens: originalTokens - estimateTokens(summary),
      fullDataRef: id
    };
  }
  
  // 按需检索完整数据
  async retrieve(query: string, limit = 5): Promise<string[]> {
    // BM25 相关性检索
    const results = await this.db.ftsSearch(query, limit);
    return results.map(r => r.raw);
  }
}

机制二：会话连续性（Session Continuity）

问题本质：compaction 后 AI 丢失任务上下文，不是因为它「记不住」，而是因为没有人帮它有选择性地恢复记忆。

Context-Mode 的方案：

1. 全量记录：每一次文件编辑、Git 操作、任务状态变更、报错日志、用户决策，都存入 SQLite。
2. 语义索引：用 FTS5 对所有事件建立全文索引，支持 BM25 相关性排序。
3. 智能恢复：compaction 触发时，不是简单地把所有历史灌回去，而是基于当前任务语义，只检索并注入最相关的历史片段。
4. 快照机制：定期生成 < 2KB 的「存档点」，记录当前任务进度、文件修改状态、关键决策，确保即使 compaction 也无法抹除核心状态。

// 会话连续性核心逻辑（伪代码）
class SessionManager {
  private db: Database;
  
  // 记录事件
  async recordEvent(event: SessionEvent): Promise<void> {
    await this.db.insert('events', {
      type: event.type,      // 'file_edit' | 'git_op' | 'task' | 'error' | 'decision'
      context: event.context, // 事件的具体内容
      timestamp: Date.now(),
      sessionId: event.sessionId
    });
  }
  
  // Compaction 前的智能恢复
  async preCompact(currentTask: string): Promise<string> {
    // 基于 BM25 检索与当前任务最相关的事件
    const relevantEvents = await this.db.ftsSearch(currentTask, {
      limit: 10,
      orderBy: 'BM25'
    });
    
    // 生成紧凑快照 (< 2KB)
    const snapshot = this.generateSnapshot(relevantEvents);
    return snapshot;
  }
  
  // 生成紧凑快照
  private generateSnapshot(events: Event[]): string {
    const activeTasks = events.filter(e => e.type === 'task' && !e.completed);
    const recentFiles = events.filter(e => e.type === 'file_edit').slice(-10);
    const keyDecisions = events.filter(e => e.type === 'decision');
    
    return `
## Current Session State
### Active Tasks (${activeTasks.length})
${activeTasks.map(t => `- [${t.status}] ${t.description}`).join('\n')}
### Recent File Changes
${recentFiles.map(f => `- ${f.path}: ${f.changeSummary}`).join('\n')}
### Key Decisions
${keyDecisions.map(d => `- ${d.content}`).join('\n')}
    `.trim();
  }
}

效果对比：

机制三：Think in Code（用代码思考）

核心理念：LLM 的正确角色是代码生成器，不是数据处理器。让 AI 写脚本来处理数据，而不是让 AI 自己去读数据。

这个想法为什么成立？

LLM 的输出 token 比输入 token 贵 10-25 倍。让 AI 读 50 个文件（50 次工具调用 + 700 KB 上下文），远不如让 AI 写一段 10 行脚本，在本地批量执行后只返回结果（1 次调用 + 3.6 KB 上下文）。

对比场景：

// ❌ 传统方式：让 AI 逐个读文件
// AI 执行 47 次 Read() 调用
// 总上下文消耗：700 KB
// Token 成本：约 175K tokens (输入)

// ✅ Think in Code 方式：让 AI 写脚本
// AI 执行 1 次 ctx_execute() 调用
ctx_execute("javascript", `
  const fs = require('fs');
  const files = fs.readdirSync('src').filter(f => f.endsWith('.ts'));
  files.forEach(f => {
    const lines = fs.readFileSync('src/' + f, 'utf8').split('\\n').length;
    console.log(f + ': ' + lines + ' lines');
  });
`);
// 脚本在本地沙盒执行，只返回结果
// 总上下文消耗：3.6 KB
// Token 成本：约 900 tokens (输入)
// 节省：99.5%

为什么不只是「让 AI 写脚本」这么简单？

关键在于 context-mode 的 ctx_execute 和 ctx_batch_execute 工具提供了：

1. 安全沙盒执行环境：脚本在隔离的 Node.js/Deno/Python 环境中运行，不能访问系统敏感资源。
2. 自动结果压缩：脚本输出会被自动截断和摘要化，不会因为 console.log 打印大量数据而重新撑满上下文。
3. 强制范式约束：通过 hook 机制，当检测到 AI 准备执行「批量读文件」或「遍历目录」这类操作时，自动拦截并引导它使用 ctx_execute 代替。

// ctx_execute 实现核心（简化）
async function ctxExecute(runtime: string, code: string): Promise<ExecutionResult> {
  // 1. 在沙盒中执行代码
  const startTime = Date.now();
  let output: string;
  
  try {
    switch (runtime) {
      case 'javascript':
      case 'node':
        output = await executeInSandbox(code, { timeout: 30000, maxOutput: 10000 });
        break;
      case 'python':
        output = await executeInPythonSandbox(code, { timeout: 30000 });
        break;
      case 'deno':
        output = await executeInDenoSandbox(code, { timeout: 30000 });
        break;
    }
  } catch (error) {
    output = `Error: ${error.message}`;
  }
  
  const executionTime = Date.now() - startTime;
  
  // 2. 如果输出过大，自动压缩
  if (output.length > 2000) {
    output = output.substring(0, 2000) + '\n... [truncated, use ctx_search for details]';
  }
  
  // 3. 返回精简结果
  return {
    output,
    executionTime,
    outputTokens: estimateTokens(output),
    savedTokens: /* 对比原始方式的节省量 */
  };
}

机制四：钩子系统（Hooks）——自动化的隐形守护者

Context-Mode 的精妙之处在于：你不需要改变任何使用习惯。所有优化通过 hook 机制自动生效。

钩子生命周期：

SessionStart
    ↓
PreToolUse → 拦截即将执行的工具调用，判断是否需要路由到沙盒
    ↓
Tool Executes → 工具执行
    ↓
PostToolUse → 拦截工具返回结果，存入沙盒，替换为摘要
    ↓
PreCompact → compaction 前，生成任务快照，智能恢复关键记忆
    ↓
（循环...）

PreToolUse Hook 的路由逻辑：

// PreToolUse Hook 核心路由逻辑（伪代码）
function preToolHook(toolCall: ToolCall): HookResult {
  const heavyTools = [
    'Read', 'ReadManyFiles', 'Grep', 
    'WebFetch', 'Shell', 'Glob'
  ];
  
  if (heavyTools.includes(toolCall.name)) {
    // 检测批量操作模式
    if (isBatchOperation(toolCall)) {
      return {
        action: 'redirect',
        message: `检测到批量${toolCall.name}操作。` +
                `请改用 ctx_execute 编写脚本在本地执行，` +
                `只返回精简结果。这可以节省 100x 的上下文消耗。`
      };
    }
    
    // 非批量操作也路由到沙盒版本
    return {
      action: 'redirect',
      redirectTool: `ctx_${toolCall.name.toLowerCase()}`,
      message: '使用沙盒版本以减少上下文消耗。'
    };
  }
  
  return { action: 'allow' }; // 轻量工具放行
}

为什么 hook 比手动配置更好：

1. 零侵入：不需要修改你的 AGENTS.md、CLAUDE.md 或任何项目配置。
2. 自适应：hook 根据工具调用的实际内容动态决策，不是简单的白名单/黑名单。
3. 跨平台一致：同一套逻辑在 Claude Code、Cursor、VS Code Copilot、Gemini CLI 上都生效。

2.3 数据流全景图

一次典型的 AI 编程交互中，数据如何流动：

用户: "帮我重构 src/auth 模块，把 JWT 验证抽成独立中间件"

AI 准备调用: Read("src/auth/handler.ts") 
                    ↓
        [PreToolUse Hook 拦截]
                    ↓
        路由到沙盒版本: ctx_execute → 
            脚本读取文件，提取关键信息（接口签名、函数列表、依赖关系）
                    ↓
        [PostToolUse Hook 处理]
                    ↓
        原始数据存入 SQLite，精简摘要进入上下文：
        "handler.ts: 3 个导出函数 (login, register, refresh),
         依赖 jwt.sign, bcrypt.compare,
         需要抽取 jwt 验证逻辑到 middleware"
                    ↓
AI 基于精简上下文做出重构决策
                    ↓
AI 执行重构，每次文件修改都被 SessionManager 记录
                    ↓
[30 分钟后，compaction 触发]
                    ↓
SessionManager 生成快照：
  - 已完成：extractJwtMiddleware() 函数
  - 进行中：修改 handler.ts 引用新中间件
  - 待处理：更新测试文件
                    ↓
AI 基于快照继续工作，无缝衔接

三、多平台接入实战

3.1 Claude Code 接入（最简单）

Claude Code 支持 plugin marketplace，安装最简单：

# 前置条件：Claude Code v1.0.33+
claude --version

# 如果版本不够，先升级
brew upgrade claude-code
# 或
npm update -g @anthropic-ai/claude-code

# 安装 context-mode 插件
/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

# 重启 Claude Code 或重新加载
/reload-plugins

# 验证安装
/context-mode:ctx-doctor

所有检查项都应该显示 [x]。ctx-doctor 会验证：

• Node.js 运行时是否可用
• Hook 系统是否正确注册
• FTS5 全文搜索是否正常
• 插件注册是否生效

安装完成后，你不需要做任何额外配置。SessionStart hook 会在每次会话启动时自动注入路由指令——没有任何文件会被写入你的项目。

可选：状态栏显示实时节省数据

编辑 ~/.claude/settings.json，添加：

{
  "statusLine": {
    "type": "command",
    "command": "context-mode statusline"
  }
}

重启后，Claude Code 底部会实时显示：$ saved this session · $ saved across sessions · % efficient，让你直观看到省了多少钱。

3.2 Cursor 接入

Cursor 的安装稍微复杂一些（Marketplace 插件还在审核中），但也不难：

Step 1：安装 context-mode

npm install -g context-mode

Step 2：配置 MCP Server

在项目根目录创建 .cursor/mcp.json：

{
  "mcpServers": {
    "context-mode": {
      "command": "context-mode"
    }
  }
}

Step 3：配置 Hooks

创建 .cursor/hooks.json：

{
  "version": 1,
  "hooks": {
    "preToolUse": [
      {
        "command": "context-mode hook cursor pretooluse",
        "matcher": "Shell|Read|Grep|WebFetch|Task"
      }
    ],
    "postToolUse": [
      {
        "command": "context-mode hook cursor posttooluse"
      }
    ],
    "stop": [
      {
        "command": "context-mode hook cursor stop"
      }
    ]
  }
}

Step 4：添加路由规则

mkdir -p .cursor/rules
cp node_modules/context-mode/configs/cursor/context-mode.mdc .cursor/rules/context-mode.mdc

重启 Cursor，打开 Settings → MCP，确认 "context-mode" 显示为 Connected。在 Agent Chat 中输入 ctx stats 验证。

3.3 VS Code Copilot 接入

npm install -g context-mode

创建 .vscode/mcp.json：

{
  "servers": {
    "context-mode": {
      "command": "context-mode"
    }
  }
}

创建 .github/hooks/context-mode.json：

{
  "hooks": {
    "PreToolUse": [
      { "type": "command", "command": "context-mode hook vscode-copilot pretooluse" }
    ],
    "PostToolUse": [
      { "type": "command", "command": "context-mode hook vscode-copilot posttooluse" }
    ],
    "SessionStart": [
      { "type": "command", "command": "context-mode hook vscode-copilot sessionstart" }
    ]
  }
}

3.4 Gemini CLI 接入

npm install -g context-mode

编辑 ~/.gemini/settings.json：

{
  "mcpServers": {
    "context-mode": {
      "command": "context-mode"
    }
  },
  "hooks": {
    "BeforeTool": [
      {
        "matcher": "run_shell_command|read_file|read_many_files|grep_search|search_file_content|web_fetch",
        "hooks": [{ "type": "command", "command": "context-mode hook gemini-cli beforetool" }]
      }
    ],
    "AfterTool": [
      {
        "matcher": "",
        "hooks": [{ "type": "command", "command": "context-mode hook gemini-cli aftertool" }]
      }
    ],
    "PreCompress": [
      {
        "matcher": "",
        "hooks": [{ "type": "command", "command": "context-mode hook gemini-cli precompress" }]
      }
    ],
    "SessionStart": [
      {
        "matcher": "",
        "hooks": [{ "type": "command", "command": "context-mode hook gemini-cli sessionstart" }]
      }
    ]
  }
}

Gemini CLI 的 BeforeTool matcher 设计很精妙：只拦截会产生大量输出的工具（run_shell_command、read_file、read_many_files、grep_search、search_file_content、web_fetch），轻量工具直接放行，避免不必要的 hook 开销。

3.5 已支持的 15+ 平台一览

四、11 个 MCP 工具详解

Context-Mode 提供了 11 个 MCP 工具，分为两类：

4.1 六个沙盒工具（核心数据通道）

ctx_execute — 在安全沙盒中执行代码片段

// 基本用法：让 AI 在本地执行分析脚本，不污染上下文
ctx_execute("javascript", `
  const fs = require('fs');
  const files = fs.readdirSync('./src')
    .filter(f => f.endsWith('.ts'));
  
  const result = files.map(f => ({
    name: f,
    lines: fs.readFileSync('./src/' + f, 'utf8').split('\n').length,
    size: fs.statSync('./src/' + f).size
  }));
  
  console.log('Total:', files.length, 'files');
  console.log('Total lines:', result.reduce((s, r) => s + r.lines, 0));
  console.log('Largest:', result.sort((a, b) => b.lines - a.lines)[0].name);
`);

支持三种运行时：javascript（Node.js）、python、deno。超时默认 30 秒，输出超过 2000 字符自动截断。

ctx_execute_file — 执行本地脚本文件

// 执行项目中已有的分析脚本
ctx_execute_file("analysis/check-deps.js");

ctx_batch_execute — 批量执行多个代码片段

// 批量收集多个模块的导出信息
ctx_batch_execute([
  { runtime: "javascript", code: "console.log(Object.keys(require('./src/auth/utils').exports))" },
  { runtime: "javascript", code: "console.log(Object.keys(require('./src/db/connector').exports))" },
  { runtime: "javascript", code: "console.log(Object.keys(require('./src/api/routes').exports))" }
]);

ctx_index — 将文件或目录索引到 FTS5 知识库

// 索引整个项目的 README 文件
ctx_index({ path: "./README.md" });

// 索引文档目录
ctx_index({ path: "./docs", recursive: true });

ctx_search — 在已索引的内容中搜索

// 搜索与 JWT 相关的内容
ctx_search({ query: "JWT authentication middleware", limit: 5 });
// 返回最相关的 5 条结果

ctx_fetch_and_index — 获取网页并自动索引

// 获取 API 文档并索引，后续可搜索
ctx_fetch_and_index({ url: "https://docs.example.com/api/v2" });

4.2 五个元工具（运维与诊断）

ctx_insight 特别值得一提——它会启动一个本地 Web UI，提供 90 个度量指标、37 种洞察模式、4 个综合评分（生产力、质量、委派效率、上下文健康度），覆盖 23 个事件类别。这对于团队管理者追踪 AI 编程 ROI 非常有价值。

五、性能优化与最佳实践

5.1 实际节省效果验证

根据官方测试和社区反馈，以下是不同场景下的典型节省数据：

场景一：Web 项目重构（中型）

场景二：Bug 排查（全栈项目）

场景三：新项目脚手架搭建

5.2 最佳实践

实践一：善用 ctx_execute 替代批量文件操作

// ❌ 低效做法：让 AI 逐个读文件寻找 TODO 注释
// AI 会执行 N 次 Read()，每次都消耗上下文

// ✅ 高效做法：让 AI 写脚本批量处理
ctx_execute("javascript", `
  const { execSync } = require('child_process');
  const files = execSync('find src -name "*.ts" -o -name "*.js"')
    .toString().trim().split('\n');
  
  const todos = [];
  files.forEach(f => {
    const content = require('fs').readFileSync(f, 'utf8');
    const matches = content.match(/\/\/\s*TODO:.*/g);
    if (matches) todos.push({ file: f, todos: matches });
  });
  
  console.log(JSON.stringify(todos, null, 2));
`);

实践二：项目开始时主动索引关键文件

// 项目初期，索引关键文档和配置
ctx_index({ path: "./README.md" });
ctx_index({ path: "./package.json" });
ctx_index({ path: "./tsconfig.json" });
ctx_index({ path: "./docs/architecture", recursive: true });

// 后续 AI 需要了解架构决策时，语义检索即可
ctx_search({ query: "authentication flow design decisions" });

实践三：利用 ctx_stats 做成本审计

// 每周五跑一次，查看本周 Token 消耗和节省情况
ctx_stats({
  period: "week",
  breakdown: "by_tool",
  format: "detailed"
});

// 输出示例：
// Week of 2026-06-09
// ───────────────────────────────
// Tool            Calls   Original(KB)   After(KB)   Saved
// Read             234      819.2          16.4       98.0%
// Shell            156      312.0          8.2        97.4%
// Grep             89       178.0          5.6        96.9%
// WebFetch         34       452.0          12.1       97.3%
// ctx_execute       45        9.0           9.0         0.0%
// ───────────────────────────────
// Total saved: $47.20 (estimated)

实践四：定期清理过期的索引数据

// 项目结束后或切换项目前，清理索引
ctx_purge();
// 或者只清理特定路径
ctx_purge({ path: "./old-project" });

5.3 企业级部署：Insights 服务

Context-Mode 近期推出了企业服务「Insights」，专门解决团队 AI 编程 ROI 不可衡量的问题：

• Token 消耗明细：精确到每个开发者的 API 使用量、工具调用分布、成本分摊。
• 安全审计：自动生成安全报告，记录所有 AI 操作的工具调用、文件访问、命令执行。
• 效率分析：按岗位、项目、时间段多维度分析 AI 编程效率。
• 成本控制：设置 Token 预算上限和告警阈值，防止个人滥用。

目前 Insights 仍处于定向内测阶段，但这个方向已经非常明确：AI 编程的成本治理正在从「个人手动管控」走向「企业级系统化治理」。

六、与竞品的差异化分析

6.1 Context-Mode vs 直接用 Claude Code

6.2 Context-Mode vs 手动 Prompt Engineering

很多人试图通过优化 system prompt 来减少 Token 消耗，比如在 AGENTS.md 里写