compressed-context 0.1.1 → 0.2.1

package/README.md

@@ -1,89 +1,97 @@
 # compressed-context
 
-OpenCode 的上下文压缩插件：把变长的旧历史折叠成自包含摘要块，让长会话在有限窗口里继续跑下去。
+OpenCode 的上下文压缩插件。它会将较早的对话历史折叠成独立的摘要块，让长会话在有限的上下文窗口里继续跑下去。
 
-## 功能
+![compressed-context TUI 面板](docs/panel.png)
 
-- **自动压缩**：上下文占用达到阈值时自动入队，工具循环里的后续 step 也能触发
-- **手动压缩**：模型可主动调用 `compress` 工具，在任意时刻打检查点
-- **分层摘要**：T1 压缩当前对话流；T2 / T3 合并相邻摘要，层级单调递减
-- **解压**：`decompress` 还原某个块覆盖的原始消息，可只还原下一层或展开到原文
-- **缓存友好**：压缩请求保持前缀不变，尽量减少缓存未命中
-- **摘要格式**：Markdown（默认）或 Babel（首行 `T=标题|G=目标`，正文自由高密度）
-- **主动提醒**：上下文增长超过设定值时，在请求尾部追加一次提醒，让模型自己决定何时压缩
-- **TUI 面板**：查看摘要块、缓存命中率、上下文构成，设置项在插件设置里直接改
+## 架构与工作原理
 
-## 安装
+插件接管发给模型的上下文：把较早的对话折叠成摘要块，让长会话继续跑下去：
 
-插件通过 npm 分发，OpenCode 会在启动时自行安装。
+```text
+原始上下文:
+[ 系统提示词 ][ 早期历史对话 ............................. ][ 最近活跃对话 ]
+                                      ↓ 触发压缩 (T1)
+一级压缩后:
+[ 系统提示词 ][ T1 摘要块 #1 ][ T1 摘要块 #2 ] ............ [ 最近活跃对话 ]
+                                      ↓ 摘要堆积达到阈值 (T2/T3)
+分层合并后:
+[ 系统提示词 ][ T2 合并摘要 (块#1+#2) ][ T1 摘要块 #3 ] .... [ 最近活跃对话 ]
+```
 
-### 方式一：npm 包名（推荐）
+- **递归分层折叠**：
+  - **T1 级**：将溢出的原始对话流折叠为自包含检查点（原始消息移入持久化存储，释放窗口）。
+  - **T2 / T3 级**：当摘要块自身占用接近预算上限时，自动在背景对相邻摘要进行高阶合并（`T1 + T1 → T2`，`T2 + T2 → T3`）。
+- **无损按需回溯**：模型可在需要时通过 `decompress` 按块还原历史，支持只解压下一层级摘要或直接恢复原始对话流。
 
-在 OpenCode 配置里加入 `plugin` 数组（全局配置 `~/.config/opencode/opencode.json`，或项目内 `opencode.json`）：
+## 核心特性
 
-```json
-{
-  "plugin": ["compressed-context"]
-}
-```
+- **自动压缩**：上下文达到阈值时自动触发（工具调用循环中的子步骤同样生效）。
+- **主动压缩**：向模型暴露 `compress` 工具，允许模型在阶段性任务完成后主动打检查点。
+- **多级合并**：T1 负责压缩原始对话；当摘要本身积攒过多时，会自动向上合并为 T2、T3 高阶摘要。
+- **按需解压**：模型可通过 `decompress` 工具还原指定摘要块（支持逐层展开或直接恢复为原始对话）。
+- **缓存友好**：压缩请求尽量保持前缀不变，避免破坏 Prompt Cache。
+- **双摘要格式**：支持标准 `markdown`（默认）和极致压缩的 `babel` 格式（首行 `T=标题|G=目标`，正文为高密度非自然语言）。
+- **超长提醒**：上下文增长超过设定阈值时，在请求尾部追加轻量提醒，引导模型自主决定压缩时机。
+- **TUI 面板**：直观查看摘要块、缓存命中率与上下文构成，支持在面板内直接修改配置。
+
+## 安装与配置
 
-### 方式二：本地路径
+插件通过 npm 分发，OpenCode 启动时会自动安装。
 
-从源码使用或自己改代码时，直接指向仓库目录：
+由于本插件会接管上下文管理，**建议同时关闭 OpenCode 原生的自动压缩**，避免两套策略打架。在全局配置 `~/.config/opencode/opencode.json`（或项目级 `opencode.json`）中加入：
 
 ```json
 {
-  "plugin": ["/absolute/path/to/compressed-context"]
+  "plugin": ["compressed-context"],
+  "compaction": { "auto": false }
 }
 ```
 
-### 配置建议
-
-插件会接管上下文压缩，建议关掉 OpenCode 原生自动压缩，避免两套策略互相干扰：
+**本地开发调试**：如果你拉取了源码自行修改，直接填入本地仓库的绝对路径即可：
 
 ```json
 {
-  "plugin": ["compressed-context"],
+  "plugin": ["/absolute/path/to/compressed-context"],
   "compaction": { "auto": false }
 }
 ```
 
 ## 配置项
 
-都能在 TUI 的插件设置里改，也可以通过设置接口写入：
+所有配置均可直接在 TUI 的插件设置面板中修改，或通过配置文件写入：
 
-| 键 | 默认 | 说明 |
-|---|---|---|
-| `contextLimit` | `"auto"` | 上下文窗口上限；数字表示上限，实际取它与模型原生窗口的较小值 |
-| `triggerPercent` | `80` | 占用达到窗口的百分之多少时自动压缩 |
-| `autoCompress` | 开 | 是否允许自动压缩 |
-| `summaryBlockPercent` | 单条摘要占窗口的百分比 | 单个摘要块的 token 预算 |
-| `summaryTotalPercent` | 全部摘要占窗口的百分比 | 摘要总量预算，超过后触发 T2 / T3 |
-| `summaryFormat` | `markdown` | `markdown` 或 `babel` |
-| `summaryLanguage` | `auto` | 摘要语言；`babel` 格式下忽略 |
-| `nudgeGrowthTokens` | `50000` | 主动提醒的增长阈值，`0` 关闭 |
-| `enableCompressTool` | 开 | 是否暴露 `compress` 工具 |
-| `enableDecompressTool` | 开 | 是否暴露 `decompress` 工具 |
+| 配置项                 | 默认值             | 说明                                                           |
+| ---------------------- | ------------------ | -------------------------------------------------------------- |
+| `contextLimit`         | `"auto"`           | 上下文窗口上限。填具体数字时，实际取该值与模型原生窗口的较小值 |
+| `triggerPercent`       | `80`               | 上下文占用达到百分之多少时触发自动压缩                         |
+| `autoCompress`         | `true`             | 是否开启自动压缩                                               |
+| `summaryBlockPercent`  | `10` | 单个摘要块的 Token 预算（占窗口的百分比）                      |
+| `summaryTotalPercent`  | `50` | 所有摘要的总 Token 预算占比，超出后触发 T2 / T3 合并           |
+| `summaryFormat`        | `"markdown"`       | 摘要格式：`markdown` 或 `babel`                                |
+| `summaryLanguage`      | `"auto"`           | 摘要语言（`babel` 格式下忽略此项）                             |
+| `nudgeGrowthTokens`    | `50000`            | 触发“主动压缩提醒”的 Token 增长阈值，设为 `0` 则关闭           |
+| `enableCompressTool`   | `true`             | 是否允许模型调用 `compress` 工具                               |
+| `enableDecompressTool` | `true`             | 是否允许模型调用 `decompress` 工具                             |
 
-## 开发
+## 本地开发
 
 ```bash
 pnpm install
-pnpm check          # typecheck + lint + 单测 + TUI 测试
-bun scripts/e2e-nudge.mjs      # 隔离环境 + 假 provider 的提醒 e2e
-bun scripts/e2e-tool-loop.mjs  # 工具循环里的自动压缩 e2e
+pnpm check                     # 运行 typecheck + lint + 单测 + TUI 测试
+bun scripts/e2e-nudge.mjs      # E2E 测试：主动提醒（隔离环境 + Mock Provider）
+bun scripts/e2e-tool-loop.mjs  # E2E 测试：工具循环内的自动压缩
 ```
 
-## 基准
+## 效果参考
 
-在 Terminal-Bench 的 `schemelike-metacircular-eval` 上做过一次粗略对比：100k 窗口下插件把单步上下文
-压在 93,560 并让该次运行通过验证。**只跑了一次，波动很大，只能当参考**，详见
-[docs/benchmark.md](docs/benchmark.md)。
+在 Terminal-Bench 的 `schemelike-metacircular-eval` 任务上做过初步实测：在 100k 窗口限制下，插件成功将单步上下文峰值压在 93,560 tokens 并顺利通过验证。由于单次测试存在随机波动，数据仅供参考，详细记录见 [docs/benchmark.md](docs/benchmark.md)。
 
-## 协议
+## 致谢与灵感
 
-[MIT](LICENSE) © 1cyberlangke1
+- [billion-context](https://github.com/ranxianglei/billion-context)
+- [Large Language Models Do Not Always Need Readable Language](https://arxiv.org/abs/2606.19857) —— Babel 摘要格式（BabelTele）的灵感来源
 
-## 灵感
+## 协议
 
-- [billion-context](https://github.com/ranxianglei/billion-context)
+[MIT](LICENSE) © 1cyberlangke1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compressed-context",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "OpenCode 上下文管理插件：按需压缩、自包含摘要",
   "type": "module",
   "license": "MIT",
@@ -46,10 +46,10 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@opencode/plugin": "^2.0.32",
-    "@opencode/theme": "2.0.32",
-    "@opentui/core": "0.5.17",
-    "@opentui/solid": "0.5.17",
+    "@opencode/plugin": "^2.1.2",
+    "@opencode/theme": "2.1.2",
+    "@opentui/core": "0.6.6",
+    "@opentui/solid": "0.6.6",
     "@types/node": "^26.6.5",
     "eslint": "^10.13.0",
     "solid-js": "1.9.15",

package/src/compression/auto.ts

@@ -357,15 +357,29 @@ export async function maybeNudge(input: NudgeInput): Promise<void> {
     if (eligible.length === 0 || sourceChars < MIN_SOURCE_CHARS) return
 
     const hasCompressed = state.blocks.length > 0
+    const notice = buildNudgeText(growth, hasCompressed, settings.autoCompress)
     input.messages.push({
       role: "user",
-      content: [{ type: "text", text: buildNudgeText(growth, hasCompressed, settings.autoCompress) }],
+      content: [{ type: "text", text: notice }],
     })
     await saveState(input.ctx.storage, input.sessionID, {
       ...state,
       nudgeBaselineTokens: total,
       nudgeCount: (state.nudgeCount ?? 0) + 1,
     })
+    // 让 TUI 的消息流也能看到这次提醒；内容就是发给模型的那一条，不另写文案。
+    // steer 让它在当前 step 结束后投递，resume:false 不会额外唤醒新一轮。
+    try {
+      await input.ctx.session.synthetic({
+        sessionID: input.sessionID,
+        text: notice,
+        description: notice.slice(0, 120),
+        delivery: "steer",
+        resume: false,
+      })
+    } catch {
+      // best effort
+    }
   } catch {
     // 提醒是 best effort，不能影响模型请求。
   }

package/src/compression/schema.ts

@@ -1,5 +1,7 @@
 import { Schema } from "effect"
 
+import type { SummaryFormat } from "../shared/settings.ts"
+
 /**
  * 摘要的规范 JSON 形状：写入存储、渲染、校验都用这一份，所有字段必填。
  *
@@ -82,3 +84,48 @@ export const SummaryInput = Schema.Struct({
 })
 
 export type SummaryInput = Schema.Schema.Type<typeof SummaryInput>
+
+/**
+ * JSON 模式的模型输入：goal 必填，其余可选。
+ *
+ * 与 SummaryInput 的差别只有 goal：JSON 模式没有 goal 就没有内容可写。
+ */
+export const JsonSummaryInput = Schema.Struct({
+  goal: Schema.String,
+  title: Schema.optional(Schema.String),
+  constraints: Schema.optional(Schema.Array(Schema.String)),
+  decisions: Schema.optional(Schema.Array(Schema.String)),
+  progress: Schema.optional(
+    Schema.Struct({
+      completed: Schema.optional(Schema.Array(Schema.String)),
+      active: Schema.optional(Schema.Array(Schema.String)),
+      blocked: Schema.optional(Schema.Array(Schema.String)),
+    }),
+  ),
+  open_items: Schema.optional(Schema.Array(Schema.String)),
+  files: Schema.optional(Schema.Array(Schema.String)),
+  facts: Schema.optional(Schema.Array(Schema.String)),
+})
+
+/** Markdown 模式的模型输入：正文必填；title 可选，传了就省掉从首行提取。 */
+export const MarkdownSummaryInput = Schema.Struct({
+  markdown: Schema.String,
+  title: Schema.optional(Schema.String),
+})
+
+/** Babel 模式的模型输入：正文必填；title 可选，目标从首行 `G=` 解析。 */
+export const BabelSummaryInput = Schema.Struct({
+  babel: Schema.String,
+  title: Schema.optional(Schema.String),
+})
+
+/**
+ * 输入：摘要格式。
+ * 输出：该格式的模型输入 schema，只保留这个格式用得上的字段。
+ * 预期：切换格式后工具参数真的收窄，模型不会按旧习惯传别的字段。
+ */
+export function summaryInputFor(format: SummaryFormat) {
+  if (format === "markdown") return MarkdownSummaryInput
+  if (format === "babel") return BabelSummaryInput
+  return JsonSummaryInput
+}

package/src/compression/settings-rpc.ts

@@ -11,6 +11,7 @@ import {
   loadServerSettings,
   parseServerSettings,
   saveServerSettings,
+  type ServerSettings,
   windowKey,
 } from "./settings.ts"
 
@@ -19,13 +20,23 @@ export interface Disposable {
   dispose(): Promise<void>
 }
 
+/** 设置 RPC 的可选回调。 */
+export interface SettingsRpcOptions {
+  /** 输入：刚保存的设置；输出：无；预期：让 compress 工具的描述与参数跟着摘要格式切换。 */
+  readonly onSaved?: (settings: ServerSettings) => Promise<void>
+}
+
 /**
- * 输入：服务端插件上下文。
+ * 输入：服务端插件上下文 + 可选保存回调。
  * 输出：注册 settingsGet / settingsSet / blocksGet / cacheHistoryGet，并返回注销句柄。
  * 预期：TUI 推来的设置存进 ctx.storage；非法值返回 ok:false；读取时带上最近解析到的原生窗口；
- *       blocksGet 只返回 active 链，cacheHistoryGet 读取前先补写当前上下文。
+ *       blocksGet 只返回 active 链，cacheHistoryGet 读取前先补写当前上下文；
+ *       保存成功后调用 onSaved，让依赖设置的运行时（工具描述）立刻更新。
  */
-export async function registerSettingsRpc(ctx: Plugin.Context): Promise<Disposable> {
+export async function registerSettingsRpc(
+  ctx: Plugin.Context,
+  options?: SettingsRpcOptions,
+): Promise<Disposable> {
   return ctx.rpc.register(ContextRpc, {
     settingsGet: async (input) => {
       const settings = await loadServerSettings(ctx.storage)
@@ -73,6 +84,7 @@ export async function registerSettingsRpc(ctx: Plugin.Context): Promise<Disposab
       const parsed = parseServerSettings({ ...current, ...(input as Record<string, unknown>) })
       if (!parsed) return { ok: false }
       await saveServerSettings(ctx.storage, parsed)
+      if (options?.onSaved !== undefined) await options.onSaved(parsed)
       return { ok: true }
     },
     blocksGet: async (input) => {

package/src/compression/shape.ts

@@ -0,0 +1,75 @@
+import type { SummaryFormat } from "../shared/settings.ts"
+
+/**
+ * 本模块只放「摘要长什么样」的文案。
+ *
+ * 压缩提示词（summarize.ts）和 compress 工具描述（tool.ts）都从这里取，
+ * 避免两处各写一份、改一处忘另一处。
+ */
+
+const JSON_SHAPE = `{
+  "title": "optional short label for this block",
+  "goal": "required: the objective and any pivots it went through",
+  "constraints": ["optional: hard limits and user preferences"],
+  "decisions": ["optional: what was decided — why"],
+  "progress": {
+    "completed": ["optional: work actually finished"],
+    "active": ["optional: work in progress, including what the user still expects"],
+    "blocked": ["optional: what is blocked — why"]
+  },
+  "open_items": ["optional: unanswered questions, TODOs, next actions"],
+  "files": ["optional: real file paths only, full/path.ext:line — role in the work"],
+  "facts": ["optional: exact errors, signatures, versions, config keys, thresholds, measured values"]
+}`
+
+const MARKDOWN_SHAPE = `# Short title
+## Goal
+...
+## Constraints
+- ...
+## Decisions
+- ...
+## Progress
+### Completed
+- ...
+### Active
+- ...
+### Blocked
+- ...
+## Open Items
+- ...
+## Files
+- ...
+## Facts
+- ...`
+
+/** 输入：格式 + 是否要 candidate 行；输出：格式说明行。 */
+export function shapeLines(format: SummaryFormat | undefined, withCandidate: boolean): string[] {
+  if (format === "babel") {
+    return [
+      withCandidate
+        ? "Return ONLY Babel text. First line must be `c=N`, where N is the chosen candidate; second line must be `T=<short title>|G=<one-line goal>`."
+        : "Return ONLY Babel text. First line must be `T=<short title>|G=<one-line goal>`.",
+      "After the header, use adaptive Babel: only T/G is fixed; invent the shortest anchors/delimiters for this source. No fixed key schema, no Markdown headings, no JSON, no code fences, no commentary.",
+    ]
+  }
+  if (format === "markdown") {
+    return [
+      withCandidate
+        ? "Return ONLY markdown. First line must be `candidate: N`, then a self-contained markdown checkpoint."
+        : "Return ONLY markdown. Do not return JSON. Do not wrap in code fences.",
+      MARKDOWN_SHAPE,
+    ]
+  }
+  return [
+    withCandidate
+      ? "Return ONLY a JSON object with the normal summary shape PLUS a top-level `candidate` number:"
+      : "Return ONLY a JSON object with this exact shape (no markdown fences, no commentary):",
+    JSON_SHAPE,
+  ]
+}
+
+/** 输入：摘要格式；输出：该格式的写法说明，供压缩提示词和工具描述共用。 */
+export function summaryShape(format: SummaryFormat): string {
+  return shapeLines(format, false).join("\n")
+}

package/src/compression/summarize.ts

@@ -4,6 +4,7 @@ import type { SummaryFormat, SummaryLanguage } from "../shared/settings.ts"
 import { splitBabelCandidate, toBabelSummary } from "./babel.ts"
 import { toSummary } from "./normalize.ts"
 import type { Summary } from "./schema.ts"
+import { shapeLines } from "./shape.ts"
 import type { Tier } from "./state.ts"
 import { MAX_SUMMARY_CHARS, MIN_SUMMARY_CHARS, minSummaryChars, validateSummary } from "./validate.ts"
 
@@ -31,12 +32,11 @@ function promptRules(options: SummaryPromptOptions | undefined): string[] {
   const lines =
     options?.format === "babel"
       ? [
-          "- Receiver is another equally capable language model, not a human. Drop human readability and grammar; freely mix languages, emoji, math/logic symbols; replace connectives, modifiers, and long clauses with symbols.",
-          "- Only `T=<short title>|G=<one-line goal>` is fixed. Do not use a fixed key schema or long labels (`Meta:`, `Entity:`, `Decisions:`, `Progress:`). Invent the shortest one-character anchors or delimiters that fit this source and use them consistently.",
-          "- Body is a compact latent index, not prose: no headings, no paragraphs, no sentences, no JSON, no code fences.",
-          "- Preserve exactly in latent space: entity/relation graph; exact numbers, versions, config keys, thresholds, formulas; conditions, causality, exceptions; comparisons; original placeholders, paths, commands, signatures, error text. Never invent or round.",
-          "- Keep the latest objective, constraints, decisions with reasons, outcomes, open items, and work the user still expects. Drop narrative, process, logs, repeated reads, and duplicates.",
-          "- Target 400-800 tokens for T1; drop explanations before exact facts.",
+          "- Audience=peer LLM. Notation only, not content: drop grammar/connectives, mix languages/emoji/math（forall、exists、in、=>）.",
+          "- Only `T=<short title>|G=<one-line goal>` fixed; invent anchors and reuse them; no headings/paragraphs/sentences/JSON/fences.",
+          "- Anchors: `S[module]` `D[decision]:why` `F[path:line]` `C[step>step]` `Config[target]:k=v` `?cond=>action` `!edge:detail` `Eval[A/B]:result`; flatten parallel items `[A,B,C]`.",
+          "- Files `F:[...]` complete, never \"various files\"; commands `C:[...]` verbatim, never paraphrase.",
+          "- Lossless: entity graph, exact numbers (no rounding), versions, config keys, thresholds, formulas, conditions, causality, exceptions, comparisons, placeholders, paths, signatures, error text; unknown=?/NULL, never invent.",
           `- Keep this summary under ${maxChars.toString()} characters.`,
         ]
       : options?.format === "markdown"
@@ -99,74 +99,26 @@ export function sessionGenerator(session: SessionGenerateLike, sessionID: string
   }
 }
 
-const SHAPE = `{
-  "title": "optional short label for this block",
-  "goal": "required: the objective and any pivots it went through",
-  "constraints": ["optional: hard limits and user preferences"],
-  "decisions": ["optional: what was decided — why"],
-  "progress": {
-    "completed": ["optional: work actually finished"],
-    "active": ["optional: work in progress, including what the user still expects"],
-    "blocked": ["optional: what is blocked — why"]
-  },
-  "open_items": ["optional: unanswered questions, TODOs, next actions"],
-  "files": ["optional: real file paths only, full/path.ext:line — role in the work"],
-  "facts": ["optional: exact errors, signatures, versions, config keys, thresholds, measured values"]
-}`
-
-const MARKDOWN_SHAPE = `# Short title
-## Goal
-...
-## Constraints
-- ...
-## Decisions
-- ...
-## Progress
-### Completed
-- ...
-### Active
-- ...
-### Blocked
-- ...
-## Open Items
-- ...
-## Files
-- ...
-## Facts
-- ...`
-
-/** 输入：格式 + 是否要 candidate 行；输出：格式说明行。 */
-function shapeLines(format: SummaryFormat | undefined, withCandidate: boolean): string[] {
-  if (format === "babel") {
-    return [
-      withCandidate
-        ? "Return ONLY Babel text. First line must be `c=N`, where N is the chosen candidate; second line must be `T=<short title>|G=<one-line goal>`."
-        : "Return ONLY Babel text. First line must be `T=<short title>|G=<one-line goal>`.",
-      "After the header, use adaptive Babel: only T/G is fixed; invent the shortest anchors/delimiters for this source. No fixed key schema, no Markdown headings, no JSON, no code fences, no commentary.",
-    ]
-  }
-  if (format === "markdown") {
-    return [
-      withCandidate
-        ? "Return ONLY markdown. First line must be `candidate: N`, then a self-contained markdown checkpoint."
-        : "Return ONLY markdown. Do not return JSON. Do not wrap in code fences.",
-      MARKDOWN_SHAPE,
-    ]
-  }
-  return [
-    withCandidate
-      ? "Return ONLY a JSON object with the normal summary shape PLUS a top-level `candidate` number:"
-      : "Return ONLY a JSON object with this exact shape (no markdown fences, no commentary):",
-    SHAPE,
-  ]
-}
-
 const BABEL_T1_RULES = `Guidance:
-- This checkpoint replaces the messages above; write a compact latent index, not a story.
-- Only T/G is fixed. Dynamically invent the shortest anchors/delimiters for this source; do not reuse a fixed field schema or long labels.
-- Keep only what future work needs: latest objective, hard constraints, decisions with one-line reasons, outcomes, open items, and exact technical facts.
-- Preserve exact paths, line numbers, signatures, commands, error text, versions, config keys, thresholds, and measured values.
-- Drop process, logs, repeated reads, full diffs, abandoned details, and explanation prose. If space is tight, keep exact facts before narrative.`
+- This checkpoint replaces the messages above; the next reader sees it instead of them, so it must stand on its own. Describe what already happened as history, not as instructions to act now.
+- Keep the objective and hard constraints, decisions with their reasons, outcomes, open items, work the user still expects, and failure lessons.
+- Copy exact identifiers instead of describing them: full paths with line numbers, the line of code that carries the logic, signatures, error text, versions, config keys, thresholds, measured values.
+- Omit build/test logs, repeated reads, exploration that produced nothing, abandoned attempts (one line on why they failed), repeated status checks, and settled discussion.
+- If space is tight, keep in this order: objective and constraints; decisions and reasons; exact technical facts; conclusions; lessons from failures.`
+
+const BABEL_T2_RULES = `Guidance for merging existing checkpoints:
+- The sources are already compressed; merge them into one checkpoint covering all of them, without re-telling the process.
+- Keep the latest objective and hard constraints, decisions with their reasons, final outcomes, open items, blocked work, and the user's still-open expectations.
+- Merge duplicate facts and keep the latest status; mark superseded content with one short marker and drop its details.
+- Drop process, logs, full diffs, code listings, and non-load-bearing line numbers. A failed attempt may stay as one line on why it failed.
+- Target roughly 50-150 tokens per source block.`
+
+const BABEL_T3_RULES = `Guidance for ultra-condensing existing checkpoints:
+- Reduce the sources to a lookup index: one to three single-line facts per source block, subject plus outcome.
+- Keep only shipped outcomes, open work, architectural decisions, and critical constraints.
+- Drop explanations, rationale details, process, logs, and anything already obsolete or superseded.
+- Open user-requested objectives survive until a later source marks them completed or superseded.
+- Target roughly 30-60 tokens per source block.`
 
 const TIER1_RULES = `Guidance:
 - This checkpoint replaces the messages above; the next reader sees it instead of them, so it must stand on its own.
@@ -194,7 +146,7 @@ const TIER3_RULES = `Guidance for ultra-condensing existing checkpoints:
 - Target roughly 30-60 tokens per source block.`
 
 function rulesFor(tier: Tier, format?: SummaryFormat): string {
-  if (format === "babel") return tier === 1 ? BABEL_T1_RULES : tier === 2 ? TIER2_RULES : TIER3_RULES
+  if (format === "babel") return tier === 1 ? BABEL_T1_RULES : tier === 2 ? BABEL_T2_RULES : BABEL_T3_RULES
   if (tier === 2) return TIER2_RULES
   if (tier === 3) return TIER3_RULES
   return TIER1_RULES
@@ -291,13 +243,12 @@ const MARKDOWN_CHOICE_RULES = `Guidance for choosing and merging:
 
 const BABEL_CHOICE_RULES = `Guidance for choosing and merging:
 - Exactly one adjacent pair may be merged. Pick one candidate from the list below and merge ONLY that pair; every other block is context for the decision, not part of the merge.
-- First line must be \`c=N\`, where N is the chosen candidate number.
-- Second line must be \`T=<short title>|G=<one-line goal>\`. After that, write adaptive Babel: only T/G is fixed; dynamically invent the shortest anchors/delimiters and use them consistently. Do not use a fixed field schema or long labels.
-- Mix languages, emoji, and logic symbols freely for density; no Markdown headings, no JSON, no prose/sentences, no code fences.
-- Target 150-300 tokens for T2 and 60-120 tokens for T3; drop explanations before exact facts.
-- Keep the latest objective and hard constraints, decisions with reasons, final outcomes, open items, blocked work, and exact facts that still matter.
+- First line must be \`c=N\`, where N is the chosen candidate number. Second line must be \`T=<short title>|G=<one-line goal>\`; after that write adaptive Babel with anchors you invent and reuse.
+- Babel changes only notation, not content: same policy as a normal merge checkpoint. No Markdown headings, no JSON, no prose/sentences, no code fences.
+- Keep the latest objective and hard constraints, decisions with their reasons, final outcomes, open items, blocked work, and exact facts that still matter.
 - Merge duplicate facts across the chosen pair, keep the latest status, and drop process, logs, repeated reads, full diffs, and non-load-bearing line numbers.
-- Copy identifiers, paths, commands, errors, versions, and numbers verbatim. Do not invent facts.`
+- If the chosen candidate's output tier is 2, target roughly 50-150 tokens per source block. If it is tier 3, be ultra-condensed: one to three single-line facts per source block.
+- Do not invent facts.`
 
 function buildChoicePrompt(
   context: string,

package/src/compression/tool.ts

@@ -1,37 +1,65 @@
 import type { Plugin } from "@opencode/plugin"
 import { Schema } from "effect"
 
-import { resolveSummaryLimits } from "../shared/settings.ts"
+import { resolveSummaryLimits, type SummaryFormat } from "../shared/settings.ts"
 import { createT1Block } from "./block.ts"
 import { toSummary } from "./normalize.ts"
-import { SummaryInput } from "./schema.ts"
+import { summaryInputFor } from "./schema.ts"
 import { RESOLVED_WINDOW_KEY, loadServerSettings, windowKey } from "./settings.ts"
 import { eligibleMessages, messageRange, type MessageLike } from "./select.ts"
 import { sessionMessagesToMessageLikes } from "./session-message.ts"
+import { summaryShape } from "./shape.ts"
 import { loadState, saveState, withPending } from "./state.ts"
 import type { Disposable } from "./settings-rpc.ts"
 import { buildTranscript } from "./transcript.ts"
 import { saveTranscript } from "./transcript-store.ts"
 import { MIN_SOURCE_CHARS, validateSummary } from "./validate.ts"
 
-const DESCRIPTION =
+const COMMON =
   "Compress the conversation so far into a structured checkpoint. Call this when the context is getting full. " +
-  "It covers every message since the last compressed block, up to the current user message, and replaces them with " +
-  "one block. In JSON mode provide `goal` plus the optional fields; in Markdown mode provide `markdown`; in Babel " +
-  "mode provide `babel` with first line `T=<short title>|G=<one-line goal>` and a dense body. Omit any " +
-  "optional field that has no real content instead of inventing entries. Do not call while a compression is already " +
-  "pending. " +
-  "Add a short title if useful. " +
+  "It covers every message since the last compressed block, up to the current user message, and replaces them with one block. " +
+  "Do not call while a compression is already pending. Add a short title if useful."
+
+const CONTENT =
   "The block is the only remaining record of those messages, so copy exact paths with line numbers, signatures, the " +
   "code lines that carry the logic, error text, versions, config keys, thresholds, and measured values. " +
-  "Use `files` only for real file paths; put config keys and function names in `facts`. " +
-  "Put work in `progress.completed` only when it was actually finished; plans go in `progress.active` or `open_items`. " +
   "Give the reason for each decision, keep the objective and any pivots, why important actions were taken, unanswered " +
   "questions, and work the user still expects. Describe the past as past, not as a new instruction. " +
   "Leave out logs, repeated reads, exploration that produced nothing, abandoned attempts (one line on why), and " +
   "repeated status checks. If space is tight, keep objective and constraints first, then decisions and reasons, then " +
   "exact technical facts, then conclusions, then lessons. Write short factual entries, not prose."
 
+/**
+ * 输入：摘要格式。
+ * 输出：该格式的字段使用规则。
+ * 预期：只讲这个格式用得上的字段，不把三种格式混在一起讲。
+ */
+function fieldRules(format: SummaryFormat): string {
+  if (format === "babel") {
+    return (
+      "Only `T=<short title>|G=<one-line goal>` is fixed; the body is an adaptive latent index built from anchors you " +
+      "invent for this source. Keep shipped work and still-open work in that body, and never invent facts."
+    )
+  }
+  if (format === "markdown") {
+    return (
+      "Only include sections with real content; never invent entries to fill one. " +
+      "Use real file paths in `## Files`; put config keys and function names in `## Facts`. " +
+      "Put work in `### Completed` only when it was actually finished; plans go in `### Active` or `## Open Items`."
+    )
+  }
+  return (
+    "Omit any optional field that has no real content instead of inventing entries. " +
+    "Use `files` only for real file paths; put config keys and function names in `facts`. " +
+    "Put work in `progress.completed` only when it was actually finished; plans go in `progress.active` or `open_items`."
+  )
+}
+
+/** 输入：摘要格式；输出：compress 工具描述；写法部分与压缩提示词共用同一份文案。 */
+export function descriptionFor(format: SummaryFormat): string {
+  return [COMMON, summaryShape(format), fieldRules(format), CONTENT].join("\n\n")
+}
+
 function failure(message: string) {
   return {
     output: { block: "", status: "error" },
@@ -40,21 +68,29 @@ function failure(message: string) {
   }
 }
 
+/** compress 工具的注册句柄：注销 + 切换摘要格式。 */
+export interface CompressToolHandle extends Disposable {
+  /** 输入：新的摘要格式；输出：无；预期：更新工具描述与参数，并让宿主重算工具列表。 */
+  setFormat(format: SummaryFormat): Promise<void>
+}
+
 /**
  * 输入：服务端上下文。
- * 输出：注册 compress 工具。
- * 预期：执行时从会话上下文按需取消息，不再把整段历史常驻内存。
+ * 输出：注册 compress 工具，并返回可切换格式的句柄。
+ * 预期：执行时从会话上下文按需取消息，不再把整段历史常驻内存；
+ *      描述与参数按当前摘要格式生成，切换后由宿主重新计算工具列表。
  */
 export async function registerCompressTool(
   ctx: Plugin.Context,
   legacyCache?: ReadonlyMap<string, readonly MessageLike[]>,
-): Promise<Disposable> {
+): Promise<CompressToolHandle> {
+  const initial = await loadServerSettings(ctx.storage)
+  let format: SummaryFormat = initial.summaryFormat
   const registration = await ctx.tool.transform((tools) => {
     tools.add({
       name: "compress",
-      options: { codemode: false },
-      description: DESCRIPTION,
-      input: SummaryInput,
+      description: descriptionFor(format),
+      input: summaryInputFor(format),
       output: Schema.Struct({ block: Schema.String, status: Schema.String }),
       execute: async (input, toolCtx) => {
         const sessionID = toolCtx.sessionID
@@ -138,5 +174,11 @@ export async function registerCompressTool(
       },
     })
   })
-  return registration
+  return {
+    dispose: () => registration.dispose(),
+    setFormat: async (next) => {
+      format = next
+      await ctx.tool.reload()
+    },
+  }
 }

package/src/i18n/en.ts

@@ -55,9 +55,9 @@ export const en: Messages = {
     windowUnknown: "Current window unknown (run one model request first)",
     summaryLanguage: "Summary language",
     summaryFormat: "Summary format",
-    summaryFormatJson: "JSON (structured)",
-    summaryFormatMarkdown: "Markdown (natural language)",
-    summaryFormatBabel: "Babel (model-to-model dense)",
+    summaryFormatJson: "JSON",
+    summaryFormatMarkdown: "Markdown",
+    summaryFormatBabel: "Babel",
     autoCompress: "Auto compression",
     enableCompressTool: "compress tool",
     enableDecompressTool: "decompress tool",

package/src/i18n/zh.ts

@@ -55,9 +55,9 @@ export const zh: Messages = {
     windowUnknown: "当前窗口未知（先跑一次模型请求）",
     summaryLanguage: "摘要语言",
     summaryFormat: "摘要格式",
-    summaryFormatJson: "JSON（结构化）",
-    summaryFormatMarkdown: "Markdown（自然语言）",
-    summaryFormatBabel: "Babel（模型间高密度）",
+    summaryFormatJson: "JSON",
+    summaryFormatMarkdown: "Markdown",
+    summaryFormatBabel: "Babel",
     autoCompress: "自动压缩",
     enableCompressTool: "compress 工具",
     enableDecompressTool: "decompress 工具",

package/src/index.ts

@@ -37,9 +37,15 @@ export default Plugin.define({
       })
     }
 
-    disposables.push(await registerCompressTool(ctx))
+    const compressTool = await registerCompressTool(ctx)
+    disposables.push(compressTool)
     disposables.push(await registerDecompressTool(ctx))
-    disposables.push(await registerSettingsRpc(ctx))
+    // 摘要格式存在设置里；保存后让 compress 工具的描述与参数立刻跟着换。
+    disposables.push(
+      await registerSettingsRpc(ctx, {
+        onSaved: (settings) => compressTool.setFormat(settings.summaryFormat),
+      }),
+    )
     const stopEvents = startSessionEvents(ctx, {
       onSessionIdle: forgetMemory,
       onSessionDeleted: forgetMemory,
@@ -49,6 +55,8 @@ export default Plugin.define({
           await maybeAutoCompressStep({ ctx, sessionID, tokens })
         })(),
     })
+    // 工具注册后刷新一次工具表，让已存在的会话在下一次请求也能看到 compress。
+    await ctx.tool.reload()
     void reconcileAll(ctx)
 
     disposables.push(

package/src/shared/settings.ts

@@ -149,8 +149,6 @@ export interface Settings extends CompressionSettings {
   showSummaries: boolean
   /** 摘要区是否展开 */
   summariesExpanded: boolean
-  /** 当前展开的摘要块 id；undefined 表示全部收起 */
-  expandedBlockId?: string
 }
 
 export const DEFAULT_SETTINGS: Settings = {
@@ -336,9 +334,6 @@ export function normalizeSettings(value: Readonly<Record<string, unknown>>): Set
     showSummaries: typeof value["showSummaries"] === "boolean" ? value["showSummaries"] : DEFAULT_SHOW_SUMMARIES,
     summariesExpanded:
       typeof value["summariesExpanded"] === "boolean" ? value["summariesExpanded"] : DEFAULT_SUMMARIES_EXPANDED,
-    ...(typeof value["expandedBlockId"] === "string" && value["expandedBlockId"].length > 0
-      ? { expandedBlockId: value["expandedBlockId"] }
-      : {}),
     decompressInlineMax: readInt(
       value["decompressInlineMax"],
       MIN_DECOMPRESS_INLINE_MAX,

package/src/tui/index.tsx

@@ -33,7 +33,6 @@ function migrate(settings: Settings, update: UpdateSettings): void {
     cacheLogExpanded: settings.cacheLogExpanded,
     showSummaries: settings.showSummaries,
     summariesExpanded: settings.summariesExpanded,
-    ...(settings.expandedBlockId === undefined ? {} : { expandedBlockId: settings.expandedBlockId }),
     decompressInlineMax: settings.decompressInlineMax,
     decompressTempCap: settings.decompressTempCap,
     decompressShowTokens: settings.decompressShowTokens,
@@ -60,7 +59,6 @@ function migrate(settings: Settings, update: UpdateSettings): void {
     settings.cacheLogExpanded === normalized.cacheLogExpanded &&
     settings.showSummaries === normalized.showSummaries &&
     settings.summariesExpanded === normalized.summariesExpanded &&
-    settings.expandedBlockId === normalized.expandedBlockId &&
     settings.decompressInlineMax === normalized.decompressInlineMax &&
     settings.decompressTempCap === normalized.decompressTempCap &&
     settings.decompressShowTokens === normalized.decompressShowTokens

package/src/tui/panel/summaries.tsx

@@ -15,10 +15,12 @@ function tierColor(tier: SummaryBlock["tier"], theme: Context["theme"]): RGBA {
   return theme.text.feedback.error.base
 }
 
-/** 输入：无；输出：共享的 SyntaxStyle；预期：markdown 渲染器需要它，懒加载避免重复创建。 */
+/** 输入：TUI renderer；输出：共享的 SyntaxStyle，拿不到 resource owner 时返回 undefined。 */
 let sharedSyntaxStyle: SyntaxStyle | undefined
-function getSyntaxStyle(): SyntaxStyle {
-  sharedSyntaxStyle ??= SyntaxStyle.create()
+function getSyntaxStyle(renderer: Context["renderer"]): SyntaxStyle | undefined {
+  const owner = (renderer as { readonly nativeScene?: unknown }).nativeScene
+  if (owner === undefined) return undefined
+  sharedSyntaxStyle ??= SyntaxStyle.create(owner as Parameters<typeof SyntaxStyle.create>[0])
   return sharedSyntaxStyle
 }
 
@@ -49,18 +51,27 @@ export function SummaryDialog(props: {
         </text>
       </box>
       <scrollbox height={height()} scrollY={true} focused={true} width="100%">
-        <Show
-          when={props.block.format === "babel"}
-          fallback={
-            <markdown
-              content={props.block.body}
-              syntaxStyle={getSyntaxStyle()}
-              fg={props.theme.text.base}
-              conceal={true}
-              tableOptions={{ widthMode: "full", style: "columns" }}
-            />
-          }
-        >
+        <Show when={props.block.format !== "babel"}>
+          <Show
+            when={getSyntaxStyle(props.context.renderer)}
+            fallback={
+              <text fg={props.theme.text.base} wrapMode="word">
+                {props.block.body}
+              </text>
+            }
+          >
+            {(style) => (
+              <markdown
+                content={props.block.body}
+                syntaxStyle={style()}
+                fg={props.theme.text.base}
+                conceal={true}
+                tableOptions={{ widthMode: "full", style: "columns" }}
+              />
+            )}
+          </Show>
+        </Show>
+        <Show when={props.block.format === "babel"}>
           <text fg={props.theme.text.base} wrapMode="word">
             {props.block.body}
           </text>