omni-context-cli 0.0.75 → 0.0.77

package/README.md

@@ -1,153 +1,109 @@
 # OmniContext CLI
 
-**Precision context. Minimal cost.**
+A zero-telemetry coding assistant that runs in your terminal and extends into VS Code, Office, the browser, and mobile. Most AI coding tools bolt a chat interface onto an LLM and call it a day. OmniContext CLI takes a different approach: it treats the context window as a scarce resource and engineers every layer of the system to use it efficiently. Lean system prompts, agent sub-delegation, automatic context editing, and native prompt caching work together so your tokens go toward solving the problem, not repeating boilerplate. Each LLM protocol (Anthropic, OpenAI, Gemini, Responses API) has its own dedicated request builder and stream handler with zero translation overhead. Custom workflows, agents, skills, and MCP servers make it fully extensible without touching the core.
 
-OmniContext CLI is a terminal-native coding assistant that treats context as a first-class resource. Lean system prompts keep overhead low. Specialist delegation routes grunt work to cheaper models while keeping your main context clean. Zero telemetry means your code never leaves your machine. And it extends into VS Code, Office, the browser, Figma, Obsidian, and Zed.
+## Context-First Architecture
 
-```bash
-npm install -g omni-context-cli && omx
-```
-
-## How It Works
-
-Traditional assistants call basic tools one at a time, resending your entire context with every round. OmniContext CLI delegates multi-step operations to agentic sub-agents running on a cheaper model -- your expensive model stays focused on reasoning, not file I/O.
-
-**Task: "Find the definition of `handleAuth`"**
+Every token matters. OmniContext CLI is engineered from the ground up to squeeze maximum value out of every context window.
 
-Traditional approach:
+**Lean system prompts.** The built-in system prompts are short, focused, and free of boilerplate. Tool descriptions are minimal. Your context budget goes toward actual work, not framework overhead.
 
-| Round | Call | Result |
-|-------|------|--------|
-| R1 | `glob("src/**/*.ts")` | 43 files returned |
-| R2 | `grep("handleAuth", ...)` | 7 matches in 4 files |
-| R3 | `read("src/middleware/auth.ts")` | 186 lines -- wrong file |
-| R4 | `read("src/routes/login.ts")` | 124 lines -- still looking |
-| R5 | `read("src/services/auth.ts", 40-90)` | Found it -- 50 more lines |
+**Agent sub-delegation.** Exploratory tasks (searching code, surveying project structure, previewing files) run as autonomous sub-agents on a cheaper model. Their intermediate tool calls, file contents, and reasoning never enter your main context. You get a concise answer back; the scratch work stays off the books.
 
-> 5 rounds, ~12K context added, all on main model
+**Context editing.** As a conversation grows, older rounds accumulate tool call payloads and thinking blocks that are no longer relevant. Context editing automatically compresses these, replacing bulky tool inputs and outputs with compact placeholders and stripping reasoning traces, so the model sees a clean, focused history instead of a bloated one.
 
-Specialist mode:
+**Auto-compaction.** When token usage hits 80% of the model's context limit, the conversation is automatically summarized, key memories are extracted, and a fresh session picks up seamlessly. You never have to manually manage context overflow.
 
-| Round | Call | Result |
-|-------|------|--------|
-| R1 | `Pluck("handleAuth definition")` | Sub-agent (cheap model): glob -> grep -> read -> locate -> extract |
+**Native prompt caching.** Automatic cache control for Anthropic and Gemini with configurable TTL (5-minute or 1-hour). Repeated context blocks are served from cache instead of being re-processed.
 
-> 1 round, ~1K context added, grunt work on cheap model
+## Workflow System
 
-## Agentic Tools
+A workflow controls everything about how OmniContext CLI behaves: the system prompt, which tools are available, and how the assistant interacts with you. Two workflows ship built-in:
 
-Each tool runs as an autonomous sub-agent on a cheaper model. It handles file I/O, error recovery, and retries internally -- keeping intermediate output out of your main context and your token bill down.
+| Preset | Use Case | Description |
+|--------|----------|-------------|
+| **Programming** (default) | Terminal, VS Code | Coding assistant with base tools, agent tools, and MCP integration. Concise output, minimal overhead. |
+| **General** | Office, browser sidebar | Personal assistant for documents, spreadsheets, and presentations. Proactive with tools, conversational tone. |
 
-| Tool | Purpose |
-|------|---------|
-| **Explore** | Survey project architecture -- directory layout, key files, and how the codebase is organized |
-| **Spark** | Run shell commands with automatic error detection and retry |
-| **Sculpt** | Edit files with surgical precision, find the right location, make the change, validate the result |
-| **Weave** | Write entire files from scratch with auto-validation |
-| **Sweep** | Find files matching complex criteria by name, content, or structure |
-| **Pluck** | Extract specific code segments -- functions, classes, or blocks you need |
-| **Ripple** | Trace symbol references across your codebase |
-| **Slice** | Answer targeted code questions by reading only the relevant parts |
-| **Quest** | Research topics via web search |
-| **Glance** | Preview multiple files at once with brief summaries |
+Create your own by dropping a markdown file in `~/.omx/workflows/` or `.omx/workflows/`. Each workflow is a markdown file with YAML frontmatter that defines the tool set and a body that becomes the system prompt:
 
-## Workflow Presets
-
-Switch how OmniContext CLI behaves with a single command. Each preset changes the tools available, the system prompt, and the response style.
+```markdown
+---
+name: My Workflow
+allowBaseTools: true
+allowBuiltinAgents: true
+allowCustomAgents: true
+allowMcpTools: true
+allowRemoteTools: true
+---
+Your system prompt here. Template variables like {{OS_TYPE}},
+{{PLATFORM}}, {{ARCH}}, {{CWD}}, and {{TODAY}} are available.
+```
 
-| Preset | Description |
-|--------|-------------|
-| **Specialist** (default) | Your main model reasons, a cheaper agent model executes. Fewer rounds, cleaner context, lower cost. |
-| **Explorer** | Research-first mode. Launches multiple web searches before answering. Great for current events, docs, and fact-checking. |
-| **Artist** | Visual-first responses. Prioritizes image generation when the model supports it. Ideal for design exploration and mockups. |
-| **Assistant** | Personal assistant for app integrations. Controls browser tabs, Office documents, and Figma designs through natural language. |
-| **Normal** | Basic tools with manual orchestration. Direct read, write, edit, and bash access. Full control, no abstraction. |
+Switch workflows at startup with `omx --workflow my-workflow` or set a default in `omx.json`.
 
 ## Native Multi-Protocol
 
-Most tools funnel everything through a single API format and hope for the best. OmniContext CLI has a dedicated request builder and stream handler for each protocol. Prompt caching, extended thinking, and provider-specific features work exactly as the vendor intended -- no lossy translation layer in between.
+Each LLM API protocol has its own dedicated request builder and stream handler. Prompt caching, extended thinking, structured outputs, and every other provider-specific feature work exactly as the vendor designed them. There is no translation layer. Anthropic requests are not converted into OpenAI format or vice versa.
 
 | Protocol | Description |
 |----------|-------------|
-| **Anthropic** | Native Messages API with prompt caching, extended thinking, and streaming. Token-level cache control via custom TTL. |
-| **OpenAI** | Native Chat Completions API. Compatible with any endpoint that speaks the OpenAI format. |
-| **Gemini** | Native generateContent API with Gemini-specific streaming. Tools and function calling use Gemini's own schema. |
-| **Responses API** | OpenAI's newer Responses API with built-in tool orchestration. Separate path from Chat Completions. |
-
-## Cost Optimization
-
-Every API call resends your full conversation history. Fewer rounds means fewer cache reads. Cleaner context means fewer tokens written. Specialist mode cuts both -- and offloads the grunt work to a cheaper model.
-
-- **Fewer API rounds** -- Traditional tools need 5 rounds to find a function definition. Specialist mode does it in 1. That's 4 fewer full-context resends -- saving cache read costs on every skipped round.
-- **Smaller context growth** -- Basic tools dump ~10KB of intermediate output into your conversation. Agentic tools return only the final result. Context editing automatically trims old tool payloads and thinking blocks, keeping growth in check even over long sessions.
-- **Cheap model for execution** -- Sub-agents run on a low-cost model while your main model handles only planning and decisions. The expensive model never does file I/O.
-- **1-hour cache for deep work** -- The default 5-minute prompt cache expires if you pause to think. Switch to 1-hour for debugging, refactoring, or research -- it eliminates repeated cache rebuilds across a session.
+| **Anthropic** | Messages API with prompt caching, extended thinking, and streaming |
+| **OpenAI** | Chat Completions API, compatible with any OpenAI-format endpoint |
+| **Gemini** | generateContent API with native streaming and function calling |
+| **Responses API** | OpenAI's Responses API with built-in tool orchestration |
 
-**Simulated cost comparison: "Find the definition of handleAuth"**
+Provider-specific interceptors handle the quirks of individual model sources (DeepSeek, Kimi, MiniMax, xAI, Zhipu, Zenmux, and others) without compromising the protocol.
 
-| | Traditional | Specialist | Saved |
-|---|---|---|---|
-| API rounds | 5 | 1 | -4 rounds |
-| Cache read per round | ~20K tokens x 5 | ~20K tokens x 1 | -80K tokens |
-| New context added | ~10KB | ~3KB | -70% |
-| Cache write (new tokens) | ~2.5K tokens | ~1K tokens | -60% |
-| Execution model | Expensive model only | Expensive + cheap | ~30% cheaper |
-
-*Based on a 20K-token conversation finding a function across a TypeScript project. Actual savings depend on project size and model pricing.*
-
-## Model Providers
-
-One command to add all your models. OmniContext CLI ships with built-in provider presets -- pick one, paste your API key, and every model from that service is ready to use.
+One command to add all models from a provider:
 
 ```bash
-# List available providers
-$ omx --list-providers
-
-# Add all models from a provider in one go
-$ omx --add-provider zenmux --api-key zmx-...
-
-# Remove a provider just as easily
-$ omx --remove-provider zenmux
+omx --list-providers
+omx --add-provider openrouter --api-key sk-...
+omx --remove-provider openrouter
 ```
 
-Built-in providers: **Zenmux**, **DeepSeek**, **OpenRouter**, **Zhipu (GLM)**, **MiniMax**
+Built-in providers: **Zenmux**, **DeepSeek**, **Kimi for Coding**, **OpenRouter**, **Zhipu (GLM)**, **MiniMax**
 
 ## Cross-Session Memory
 
-OmniContext CLI remembers your coding style, project patterns, and past decisions across sessions. Key points are extracted from every conversation and injected into future sessions. Helpful points gain score, harmful ones drop fast, unused ones decay naturally. Each project has its own memory file -- edit it directly if you want full control.
+Memory extraction runs automatically when a conversation is compacted. The model reflects on the session, pulls out key points, and evaluates existing ones. Each point carries a score that starts at 0 and shifts based on how useful it was in the conversation:
 
-## Integrations
+| Rating | Delta |
+|--------|-------|
+| Helpful | +3 |
+| Neutral | -1 |
+| Harmful | -6 |
 
-Terminal is home base, but OmniContext CLI reaches into every tool you use. One AI, consistent context, zero context switching.
+Points that drop below -10 are pruned. This means good insights accumulate weight over multiple sessions while bad advice is flushed quickly and stale knowledge decays on its own. Every project maintains its own memory file at `.omx/memory.json`. Edit it directly for full control.
 
-- **VS Code Extension** -- full IDE integration with file context, diagnostics, and diff views
-- **Desktop App** -- standalone GUI that acts as the local hub connecting Office, browser, and Figma extensions
-- **Chrome Extension** -- sidebar on any webpage for summarization, data extraction, and browser automation
-- **Office Add-in** -- AI panel inside Word, Excel, and PowerPoint
-- **Figma Plugin** -- inspect layouts, create shapes, modify nodes, and export assets through chat
-- **Zed Editor** -- external agent via Agent Client Protocol with full tool access
-- **Web Client** -- browser UI with LaTeX, Mermaid diagrams, file attachments, and drag-and-drop
-- **Mobile Access** -- run `omx --serve` and connect from your phone
+## Desktop & Integrations
+
+Terminal is home base, but OmniContext CLI extends into every tool you use. The desktop app ties it all together as a lightweight server launcher that connects your IDE, browser, and Office apps to a single OmniContext CLI instance.
+
+- **Desktop App** - workspace management, model configuration, and one-click server launch that bridges all the integrations below
+- **VS Code Extension** - IDE integration with file context, diagnostics, and diff views
+- **Chrome Extension** - sidebar on any webpage for summarization, data extraction, and browser automation
+- **Office Add-in** - AI panel inside Word, Excel, and PowerPoint
+- **Zed Editor** - external agent via Agent Client Protocol with full tool access
+- **Web Client** - browser UI with LaTeX, Mermaid diagrams, file attachments, and drag-and-drop
+- **Mobile Access** - run `omx --serve` and connect from your phone
 
 ## Extensibility
 
-Custom agents, skills, slash commands, and MCP servers. Everything is a markdown file or JSON config.
+Custom workflows, agents, skills, and MCP servers. Everything is a markdown file or JSON config.
 
-- **Custom SubAgents** -- write a markdown file with a prompt template and tool permissions. It becomes a new agentic tool instantly. Add `OMX-AGENTS.md` for global agent instructions.
-- **Custom Skills** -- teach OmniContext CLI domain-specific knowledge and workflows. Skills inject instructions into the current conversation.
-- **Slash Commands** -- create shortcuts for common prompts with Handlebars templating.
-- **MCP Servers** -- connect external tools and data sources via Model Context Protocol. Stdio and HTTP transports supported.
+- **Custom Workflows** - define your own system prompt and control exactly which tools are available: base tools, agents, MCP servers, and remote tools.
+- **Custom Agents** - write a markdown file with a prompt template, parameter schema, and tool permissions. It becomes a callable agent tool instantly. Add `OMX-AGENTS.md` for global agent instructions.
+- **Custom Skills** - directory-based prompt capabilities invoked as slash commands (`/skill-name`). Skills inject instructions into the current conversation for domain-specific knowledge and workflows. Compatible with Claude Code skill format.
+- **MCP Servers** - connect external tools and data sources via Model Context Protocol. Stdio and HTTP transports supported.
+- **Project Instructions** - drop an `OMX.md` or `CLAUDE.md` in your repo root and everyone on the team gets the same conventions and context.
 
-## The Details
+## Install
 
-- **Lean system prompts** -- minimal, focused instructions and concise tool descriptions. Your tokens go toward actual work, not bloated framework overhead.
-- **Zero telemetry** -- no usage tracking, no analytics, no data collection.
-- **Context editing** -- automatically trims old tool call payloads and thinking blocks from your conversation history.
-- **Extended thinking** -- enable deeper reasoning for complex tasks with configurable budget limits.
-- **CLAUDE.md compatible** -- already have a CLAUDE.md in your repo? OmniContext CLI reads it automatically.
-- **Auto-compaction** -- when context hits 80% capacity, the conversation is compacted, key memories are extracted, and a fresh session picks up where you left off.
-- **Native prompt caching** -- automatic cache control for Anthropic and Gemini with custom TTL settings.
-- **Project instructions** -- drop an `OMX.md` in your repo root and everyone on the team gets the same conventions and context.
+```bash
+npm install -g omni-context-cli && omx
+```
 
 ## Build & Release
 
@@ -155,7 +111,7 @@ Custom agents, skills, slash commands, and MCP servers. Everything is a markdown
 npm run release
 ```
 
-One command builds the CLI, all clients, packages release zips, and builds the desktop app for the current platform. Artifacts go to `release/`.
+One command builds the CLI, all clients, and packages the desktop app for the current platform.
 
 ## Documentation
 

package/README.zh-CN.md

@@ -1,153 +1,109 @@
 # OmniContext CLI
 
-**精准上下文，最小成本。**
+一个零遥测的编程助手，运行在终端，延伸到 VS Code、Office、浏览器和移动端。大多数 AI 编程工具只是给 LLM 套一个聊天界面就完事了。OmniContext CLI 走了不同的路，它把上下文窗口视为稀缺资源，从每一层设计上压榨它的利用效率。精简的系统提示词、Agent 子委托、自动上下文编辑和原生提示词缓存协同工作，让你的 token 花在解决问题上，而不是重复模板废话。每种 LLM 协议（Anthropic、OpenAI、Gemini、Responses API）都有专用的请求构建器和流处理器，零转换开销。自定义工作流、Agent、技能和 MCP 服务器提供完整的可扩展性，无需修改核心代码。
 
-OmniContext CLI 是一个终端原生的编程助手，把上下文当作一等资源来管理。精简的系统提示词控制开销。专家委派机制把脏活路由给便宜的模型，同时保持主上下文的干净。零遥测意味着你的代码不会离开你的机器。它还能延伸到 VS Code、Office、浏览器、Figma、Obsidian 和 Zed。
+## 上下文优先架构
 
-```bash
-npm install -g omni-context-cli && omx
-```
+每一个 token 都很重要。OmniContext CLI 从底层开始就为最大化利用上下文窗口而设计。
 
-## 工作原理
+**精简系统提示词。** 内置提示词短小、聚焦、没有模板废话。工具描述力求精简。你的上下文预算用在实际工作上，而不是框架开销。
 
-传统助手逐个调用基础工具，每一轮都重新发送完整上下文。OmniContext CLI 把多步操作委派给运行在便宜模型上的 Agentic 子代理——贵价模型专注推理，不做文件 I/O。
+**Agent 子委托。** 探索性任务（搜索代码、勘察项目结构、预览文件）由自主子 Agent 在更便宜的模型上运行。它们的中间工具调用、文件内容和推理过程不会进入你的主上下文。你只拿到一个简洁的结论，中间草稿完全不占空间。
 
-**任务："找到 `handleAuth` 的定义"**
+**上下文编辑。** 随着对话增长，早期的工具调用负载和思考块变得不再相关。上下文编辑自动压缩这些内容，用紧凑的占位符替换庞大的工具输入输出，剥离推理痕迹，让模型看到干净、聚焦的历史，而不是臃肿的堆积。
 
-传统模式：
+**自动压缩。** 当 token 用量达到模型上下文限制的 80% 时，对话自动摘要，关键记忆被提取，新会话无缝接续。你永远不需要手动管理上下文溢出。
 
-| 轮次 | 调用 | 结果 |
-|------|------|------|
-| R1 | `glob("src/**/*.ts")` | 返回 43 个文件 |
-| R2 | `grep("handleAuth", ...)` | 4 个文件中有 7 处匹配 |
-| R3 | `read("src/middleware/auth.ts")` | 186 行——找错文件了 |
-| R4 | `read("src/routes/login.ts")` | 124 行——还在找 |
-| R5 | `read("src/services/auth.ts", 40-90)` | 找到了——又多 50 行 |
+**原生提示词缓存。** Anthropic 和 Gemini 的自动缓存控制，支持可配置的 TTL（5 分钟或 1 小时）。重复的上下文块从缓存读取，而不是重新处理。
 
-> 5 轮，新增 ~12K 上下文，全部在主模型上执行
+## 工作流系统
 
-专家模式：
+工作流控制 OmniContext CLI 行为的方方面面：系统提示词、可用工具列表、助手交互方式。内置两套工作流：
 
-| 轮次 | 调用 | 结果 |
-|------|------|------|
-| R1 | `Pluck("handleAuth definition")` | 子代理（便宜模型）：glob -> grep -> read -> locate -> extract |
+| 预设 | 使用场景 | 说明 |
+|------|----------|------|
+| **Programming**（默认） | 终端、VS Code | 编程助手，包含基础工具、Agent 工具和 MCP 集成。简洁输出，最小开销。 |
+| **General** | Office、浏览器侧边栏 | 多功能个人助理，处理文档、表格和演示文稿。主动使用工具，匹配对话语气。 |
 
-> 1 轮，新增 ~1K 上下文，脏活在便宜模型上完成
+在 `~/.omx/workflows/` 或 `.omx/workflows/` 中放一个 Markdown 文件即可创建自定义工作流。每个工作流是一个带 YAML frontmatter 的 Markdown 文件，frontmatter 定义工具集，正文成为系统提示词：
 
-## Agentic 工具
-
-每个工具作为自主子代理运行在便宜模型上，内部处理文件 I/O、错误恢复和重试——中间输出不会进入你的主上下文，token 账单也不会膨胀。
+```markdown
+---
+name: My Workflow
+allowBaseTools: true
+allowBuiltinAgents: true
+allowCustomAgents: true
+allowMcpTools: true
+allowRemoteTools: true
+---
+你的系统提示词。可以使用模板变量 {{OS_TYPE}}、
+{{PLATFORM}}、{{ARCH}}、{{CWD}} 和 {{TODAY}}。
+```
 
-| 工具 | 用途 |
-|------|------|
-| **Explore** | 勘察项目架构——目录布局、关键文件和代码组织方式 |
-| **Spark** | 执行 shell 命令，自动检测错误并重试 |
-| **Sculpt** | 精准编辑文件，定位正确位置，修改并验证结果 |
-| **Weave** | 从头写入完整文件，自动验证 |
-| **Sweep** | 按名称、内容或结构查找匹配的文件 |
-| **Pluck** | 提取特定代码片段——函数、类或你需要的代码块 |
-| **Ripple** | 追踪符号在代码库中的所有引用 |
-| **Slice** | 只读取相关部分来回答针对性的代码问题 |
-| **Quest** | 通过网络搜索调研主题 |
-| **Glance** | 一次预览多个文件，附带简要摘要 |
-
-## 工作流预设
-
-一条命令切换 OmniContext CLI 的行为模式。每个预设改变可用工具、系统提示词和响应风格。
-
-| 预设 | 说明 |
-|------|------|
-| **Specialist**（默认） | 主模型负责推理，便宜的代理模型负责执行。更少轮次，更干净的上下文，更低的成本。 |
-| **Explorer** | 调研优先模式。先发起多次网络搜索再回答。适合时事、文档查阅和事实核查。 |
-| **Artist** | 视觉优先响应。在模型支持时优先生成图像。适合设计探索和原型。 |
-| **Assistant** | 应用集成的个人助理。通过自然语言控制浏览器标签页、Office 文档和 Figma 设计。 |
-| **Normal** | 基础工具加手动编排。直接使用 read、write、edit 和 bash。完全控制，没有抽象。 |
+启动时用 `omx --workflow my-workflow` 切换工作流，或在 `omx.json` 中设置默认值。
 
 ## 原生多协议
 
-大多数工具把所有请求转换成单一 API 格式。OmniContext CLI 为每种协议提供专用的请求构建器和流处理器。提示词缓存、扩展思考和供应商专属特性按原厂设计工作——没有有损的转换层。
+每种 LLM API 协议都有专用的请求构建器和流处理器。提示词缓存、扩展思考、结构化输出和每一个供应商专属特性都按原厂设计工作。没有转换层，不会把 Anthropic 请求转成 OpenAI 格式，也不会反过来。
 
 | 协议 | 说明 |
 |------|------|
-| **Anthropic** | 原生 Messages API，支持提示词缓存、扩展思考和流式传输。通过自定义 TTL 实现 token 级缓存控制。 |
-| **OpenAI** | 原生 Chat Completions API。兼容任何 OpenAI 格式的接口。 |
-| **Gemini** | 原生 generateContent API，Gemini 专用流式传输。工具和函数调用使用 Gemini 自己的 schema。 |
-| **Responses API** | OpenAI 新一代 Responses API，内置工具编排。独立于 Chat Completions 的路径。 |
-
-## 成本优化
-
-每次 API 调用都会重新发送完整的对话历史。更少的轮次意味着更少的缓存读取。更干净的上下文意味着更少的 token 写入。专家模式两者兼省——并且把脏活卸载给便宜的模型。
-
-- **更少的 API 轮次** ——传统工具需要 5 轮才能找到一个函数定义，专家模式只要 1 轮。省掉 4 次完整上下文重传，每省一轮都节省缓存读取成本。
-- **更小的上下文增长** ——基础工具往对话里塞 ~10KB 中间输出，Agentic 工具只返回最终结果。上下文编辑自动裁剪旧的工具负载和思考块，长会话也能控制增长。
-- **便宜模型做执行** ——子代理运行在低成本模型上，主模型只负责规划和决策。贵价模型永远不做文件 I/O。
-- **1 小时缓存应对深度工作** ——默认 5 分钟提示词缓存在你暂停思考时就会过期。切换到 1 小时缓存适合调试、重构或调研——消除会话中反复重建缓存的开销。
+| **Anthropic** | Messages API，支持提示词缓存、扩展思考和流式传输 |
+| **OpenAI** | Chat Completions API，兼容任何 OpenAI 格式的接口 |
+| **Gemini** | generateContent API，原生流式传输和函数调用 |
+| **Responses API** | OpenAI 的 Responses API，内置工具编排 |
 
-**模拟成本对比："找到 handleAuth 的定义"**
+供应商专属拦截器处理各模型源（DeepSeek、Kimi、MiniMax、xAI、Zhipu、Zenmux 等）的差异，同时不影响协议本身。
 
-| | 传统模式 | 专家模式 | 节省 |
-|---|---|---|---|
-| API 轮次 | 5 | 1 | -4 轮 |
-| 每轮缓存读取 | ~20K tokens x 5 | ~20K tokens x 1 | -80K tokens |
-| 新增上下文 | ~10KB | ~3KB | -70% |
-| 缓存写入（新 token） | ~2.5K tokens | ~1K tokens | -60% |
-| 执行模型 | 仅贵价模型 | 贵价 + 便宜 | 便宜 ~30% |
-
-*基于在 TypeScript 项目中查找函数的 20K token 对话。实际节省取决于项目规模和模型定价。*
-
-## 模型供应商
-
-一条命令添加所有模型。OmniContext CLI 内置供应商预设——选一个，粘贴 API key，该服务的所有模型就可以使用了。
+一条命令添加供应商的所有模型：
 
 ```bash
-# 列出可用供应商
-$ omx --list-providers
-
-# 一次性添加供应商的所有模型
-$ omx --add-provider zenmux --api-key zmx-...
-
-# 移除同样简单
-$ omx --remove-provider zenmux
+omx --list-providers
+omx --add-provider openrouter --api-key sk-...
+omx --remove-provider openrouter
 ```
 
-内置供应商：**Zenmux**、**DeepSeek**、**OpenRouter**、**Zhipu (GLM)**、**MiniMax**
+内置供应商：**Zenmux**、**DeepSeek**、**Kimi for Coding**、**OpenRouter**、**Zhipu (GLM)**、**MiniMax**
 
 ## 跨会话记忆
 
-OmniContext CLI 跨会话记住你的编码风格、项目模式和历史决策。关键要点从每次对话中提取并注入未来的会话。有用的要点加分（+1），有害的快速扣分（-3），不再使用的自然衰减。每个项目有自己的记忆文件——想要完全控制可以直接编辑。
+记忆提取在对话压缩时自动触发。模型回顾当前会话，提炼关键要点，并评估已有的要点。每个要点的评分从 0 开始，根据它在对话中的表现变动：
 
-## 集成
+| 评价 | 分值变化 |
+|------|----------|
+| 有帮助 | +3 |
+| 中性 | -1 |
+| 有害 | -6 |
 
-终端是大本营，但 OmniContext CLI 延伸到你使用的每个工具。一个 AI，一致的上下文，零切换成本。
+评分低于 -10 的要点被剪枝。好的见解在多次会话中不断积累权重，坏的建议很快被清除，过时的知识自然衰减。每个项目在 `.omx/memory.json` 中维护自己的记忆文件，想要完全控制可以直接编辑。
 
-- **VS Code 扩展** ——完整的 IDE 集成，感知打开文件、诊断信息和 diff 视图
-- **桌面应用** ——独立 GUI，作为本地中枢连接 Office、浏览器和 Figma 扩展
-- **Chrome 扩展** ——任意网页上的侧边栏，支持摘要、数据提取和浏览器自动化
-- **Office 插件** ——Word、Excel 和 PowerPoint 内的 AI 面板
-- **Figma 插件** ——通过聊天面板检查布局、创建图形、修改节点和导出资源
-- **Zed 编辑器** ——通过 Agent Client Protocol 作为外部代理接入，拥有完整工具访问
-- **Web 客户端** ——浏览器 UI，支持 LaTeX、Mermaid 图表、文件附件和拖拽
-- **移动端访问** ——运行 `omx --serve` 后从手机连接
+## 桌面版与集成
+
+终端是大本营，但 OmniContext CLI 延伸到你使用的每个工具。桌面版把一切串联起来，一个轻量级服务启动器，将你的 IDE、浏览器和 Office 应用连接到同一个 OmniContext CLI 实例。
+
+- **桌面应用** - 工作区管理、模型配置、一键启动服务并桥接下面所有集成
+- **VS Code 扩展** - IDE 集成，感知打开文件、诊断信息和 diff 视图
+- **Chrome 扩展** - 任意网页上的侧边栏，支持摘要、数据提取和浏览器自动化
+- **Office 插件** - Word、Excel 和 PowerPoint 内的 AI 面板
+- **Zed 编辑器** - 通过 Agent Client Protocol 作为外部代理接入
+- **Web 客户端** - 浏览器 UI，支持 LaTeX、Mermaid 图表、文件附件和拖拽
+- **移动端访问** - 运行 `omx --serve` 后从手机连接
 
 ## 可扩展性
 
-自定义 Agent、技能、斜杠命令和 MCP 服务器。一切都是 Markdown 文件或 JSON 配置。
+自定义工作流、Agent、技能和 MCP 服务器。一切都是 Markdown 文件或 JSON 配置。
 
-- **自定义子代理** ——写一个带提示词模板和工具权限的 Markdown 文件，它立刻成为新的 Agentic 工具。添加 `OMX-AGENTS.md` 作为全局代理指令。
-- **自定义技能** ——教 OmniContext CLI 领域知识和工作流。技能会注入当前对话。
-- **斜杠命令** ——为常用提示词创建快捷方式，支持 Handlebars 模板。
-- **MCP 服务器** ——通过 Model Context Protocol 接入外部工具和数据源。支持 stdio 和 HTTP 传输。
+- **自定义工作流** - 定义自己的系统提示词，精确控制可用工具列表：基础工具、Agent、MCP 服务器和远程工具。
+- **自定义 Agent** - 写一个带提示词模板、参数定义和工具权限的 Markdown 文件，立刻成为可调用的 Agent 工具。添加 `OMX-AGENTS.md` 作为全局 Agent 指令。
+- **自定义技能** - 基于目录的提示词能力，通过斜杠命令（`/技能名`）调用。技能注入当前对话，提供领域知识和工作流。兼容 Claude Code 技能格式。
+- **MCP 服务器** - 通过 Model Context Protocol 接入外部工具和数据源，支持 stdio 和 HTTP 传输。
+- **项目指令** - 在仓库根目录放一个 `OMX.md` 或 `CLAUDE.md`，团队里每个人都能得到相同的约定和上下文。
 
-## 细节
+## 安装
 
-- **精简的系统提示词** ——最小化、聚焦的指令和简洁的工具描述。你的 token 用在实际工作上，而不是臃肿的框架开销。
-- **零遥测** ——没有使用追踪，没有数据分析，没有数据收集。
-- **上下文编辑** ——自动裁剪对话历史中旧的工具调用负载和思考块。
-- **扩展思考** ——为复杂任务启用深度推理，支持可配置的预算限制。
-- **兼容 CLAUDE.md** ——仓库里已经有 CLAUDE.md？OmniContext CLI 会自动读取。
-- **自动压缩** ——上下文达到 80% 容量时，对话被压缩，关键记忆被提取，新会话无缝接续。
-- **原生提示词缓存** ——Anthropic 和 Gemini 的自动缓存控制，支持自定义 TTL 设置。
-- **项目指令** ——在仓库根目录放一个 `OMX.md`，团队里每个人都能得到相同的约定和上下文。
+```bash
+npm install -g omni-context-cli && omx
+```
 
 ## 构建与发布
 
@@ -155,7 +111,7 @@ OmniContext CLI 跨会话记住你的编码风格、项目模式和历史决策
 npm run release
 ```
 
-一条命令构建 CLI 和所有客户端，打包发布 zip，并为当前平台构建桌面应用。产物输出到 `release/`。
+一条命令构建 CLI 和所有客户端，并为当前平台打包桌面应用。
 
 ## 文档
 

package/dist/agents/explore.md

@@ -1,32 +1,39 @@
 ---
 name: Explore
-description: Survey project structure and architecture. Shows directory layout, where features live, and how the codebase is organized. For structural overview, not detailed analysis.
-allowedTools: [Read, Glob, Grep, Bash, BashOutput]
-displayFields: [query, directory]
+description: Get a high-level overview of how a project or directory is organized. Use this to understand what exists and where things live, not to answer specific code questions.
+allowBaseTools: [Read, Glob, Grep, Bash, BashOutput]
+displayFields: [directory]
 parameters:
   properties:
-    query:
-      type: string
-      description: What aspect of the project structure to explore
     directory:
       type: string
-      description: Limit the search to this directory. If not provided, searches the entire project.
-  required: [query]
+      description: Directory to explore. If not provided, explores the entire project.
 ---
 
-Survey the project structure and find out: {{query}}
+Survey the project structure.
+
+{{#if directory}}Limit the exploration to this directory: {{directory}}.{{/if}}
+
+Use glob to map out the directory tree. Start broad, then selectively read key files (READMEs, configs, entry points) to understand their roles.
+
+Focus on the big picture: what directories exist, how the project is organized, where different concerns are separated. Don't dive deep into implementation details.
+
+Return the results in this format:
 
-{{#if directory}}Limit the search to this directory: {{directory}}.{{/if}}
+```
+Overview: One-paragraph summary of the project and its tech stack.
 
-Use glob to survey the file structure and identify relevant areas. Use grep to scan for where functionality lives. 
+Directory Structure:
+  src/          - Source code, organized by feature
+  tests/        - Test suites
+  scripts/      - Build and deployment scripts
 
-Focus on the big picture: what directories exist, how the project is organized, where different concerns are separated.
+Key Files:
+  package.json  - Dependencies and scripts
+  src/index.ts  - Application entry point
 
-Return a report covering:
-- A brief overview of what you found
-- Relevant directories and their purposes
-- Key files and their roles
-- How the codebase is organized (features, layers, modules)
-- Where the queried functionality lives
+Architecture:
+  How the codebase is organized (features, layers, modules, patterns).
+```
 
-Keep the report concise and to the point. Focus on what matters, skip the fluff.
+Do not include explanations beyond the result format. Keep responses concise and structured.

package/dist/agents/glance.md

@@ -1,7 +1,7 @@
 ---
 name: Glance
 description: Preview multiple files at once. Reads files and directories, returns a brief summary for each file to help understand what's in them without reading the full contents.
-allowedTools: [Read, Glob, Grep]
+allowBaseTools: [Read, Glob, Grep, Bash, BashOutput]
 displayFields: [paths, recursive, maxFiles]
 parameters:
   properties:
@@ -27,33 +27,18 @@ Maximum files to process: {{#if maxFiles}}{{maxFiles}}{{else}}20 (default){{/if}
 
 First, expand any directories into file lists using glob. Then read each file and write a brief summary (under 100 words) describing what the file does, its main exports, or key contents.
 
-Return the summaries in this format:
+For large files, focus on the top-level structure rather than reading everything.
+
+Return the results in this format:
 
 ```
-path/to/file1.ts
+path/to/file.ts
   Brief summary of what this file does, its purpose, main functions or exports.
 
-path/to/file2.tsx
-  Brief summary of this file's contents and role in the project.
-
-path/to/file3.json
+path/to/config.json
   Brief summary of the configuration or data structure.
 ```
 
-If a file can't be read, note it:
-
-```
-path/to/file.bin
-  [Binary file, skipped]
-
-path/to/missing.ts
-  [File not found]
-```
-
-If the file list exceeds the limit, process only the first N files and note:
-
-```
-[Reached limit of N files, X more files not processed]
-```
+If a file can't be read (binary, missing, etc.), note it briefly and move on.
 
 Do not include explanations beyond the result format. Keep responses concise and structured.

package/dist/agents/{slice.md → search.md}

@@ -1,7 +1,7 @@
 ---
-name: Slice
-description: Extract code snippets relevant to answering a specific question. Returns targeted code segments from across the codebase that address the query.
-allowedTools: [Read, Grep, Glob, Bash, BashOutput]
+name: Search
+description: Search the codebase to answer a specific question. Returns targeted code segments from across the project that address the query.
+allowBaseTools: [Read, Glob, Grep, Bash, BashOutput]
 displayFields: [question, directory]
 parameters:
   properties:
@@ -26,7 +26,7 @@ Read the files that contain the answer to the question. Focus on the specific co
 
 For complex flows, read multiple files to understand the complete picture.
 
-Return the code in this format. Use line ranges when only a section is relevant, complete contents for small files:
+Return the results in this format. Use line ranges when only a section is relevant, complete contents for small files:
 
 ```
 File: path/to/file.ts