dsh-ledger-memory 0.1.1 → 0.2.0

package/README.md

@@ -69,18 +69,40 @@ dsh plugin add dsh-ledger-memory
 /ledger light      轻量压缩
 /ledger log        查活动日志
 /ledger handoff    写一份交接单
+/ledger mode       看/切换压缩模式（steady / surgical）
 ```
 
 ### 设置面板
 
-**设置 → 项目台账（台账 / 压缩 / 日志）**，可调十二项：回合末卡片开关、高保真压缩水位、
-增量压缩的涨幅与保留量、活动日志五档开关、活跃台账行数上限、变更登记条数、水位提醒档位等。
+**设置 → 项目台账（台账 / 压缩 / 日志）**，可调十三项：**压缩模式**、回合末卡片开关、
+高保真压缩水位、增量压缩的涨幅与保留量、活动日志五档开关、活跃台账行数上限、
+变更登记条数、水位提醒档位等。
 
-> 一条要知道的语义：`maxActiveLines` / `changeRegisterMax` / `logLevels` **以每个项目
-> 自己清单里的值为准**（日志是只追加的证据，全局设置改不动它）。
-> 面板里这三项是**新项目初始化时写进去的默认值**。
+> 一条要知道的语义：`mode` / `maxActiveLines` / `changeRegisterMax` / `logLevels`
+> **以每个项目自己清单里的值为准**。面板里这几项是**新项目初始化时写进去的默认值**。
 
-## 十二个工具
+## 两个压缩模式
+
+压缩方式可以按项目选。默认是「正常推进」，两者共用同一套压缩，区别只在压缩前后多做或少做什么：
+
+| | **正常推进**（`steady`，默认） | **反复追究**（`surgical`） |
+|---|---|---|
+| 压缩时怎么切 | **按位置**：只压最旧一段，更早的一刀切 | **按内容分流**，再压 |
+| 谁做判断 | 不用判断（省一次模型输出） | AI 做一次分流 |
+| 适合 | 一路向前干活 | 要反复回看约束与假设的活 |
+
+**「反复追究」怎么工作**：水位到点时会先让 AI 调 `ledger_triage` 把这一段分成三个桶 ——
+
+- **留（`keep`）**：下一轮不知道就会做错的东西（当前状态、未验证的假设、你定过的约束）。压缩后**逐字注回**。
+- **落（`stash`）**：以后可能要查、但不该占上下文的（判断与理由、走不通的路、关键文件位置）。
+  写进项目的 `_stash/`，**永不注入**，需要时自己 grep。
+- **丢（`drop`）**：已被取代的，只进日志。
+
+`keep` 有条数上限——**留得太多等于没压**，超了会按 AI 给的顺序截断并如实报出截掉几条。
+
+切换：设置面板里选，或 `/ledger mode steady` / `/ledger mode surgical`（只影响当前项目）。
+
+## 十三个工具
 
 AI 在对话里调用，你也可以让它调用：
 
@@ -96,6 +118,7 @@ AI 在对话里调用，你也可以让它调用：
 | `ledger_log` | 查活动日志（五档，**从不注入上下文**） |
 | `ledger_log_write` | 追加一条回合小结 |
 | `ledger_handoff` | 写交接单，供下一个会话接手 |
+| `ledger_triage` | 把阶段性产出分成「留 / 落 / 丢」三个桶（「反复追究」模式用） |
 | `ledger_compact` | 请求一次高保真压缩 |
 | `ledger_checkpoint` | 把这一刻的选择交给用户（记台账 / 记+压缩 / 记+交接 / 跳过） |
 

package/lib/client.js

@@ -266,6 +266,22 @@ window.__ModuleLoader__.load({
   border: 1px solid var(--dsw-alias-border-l1); border-radius: 8px;
 }
 .pl-settings__mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+/* 二选一（模式）：把两个选项的**取舍**都摆在眼前，不下拉折叠 */
+.pl-settings__choices { display: flex; flex-direction: column; gap: 6px; width: 100%; }
+.pl-settings__choice {
+  display: flex; gap: 8px; align-items: flex-start; cursor: pointer;
+  padding: 8px 10px; border-radius: 8px;
+  border: 1px solid var(--dsw-alias-border-l1);
+  background: var(--dsw-alias-bg-layer-1);
+}
+.pl-settings__choice--on {
+  border-color: var(--dsw-alias-state-success-primary);
+  background: var(--dsw-alias-bg-layer-2);
+}
+.pl-settings__choice input { margin-top: 2px; flex: none; }
+.pl-settings__choice-body { display: flex; flex-direction: column; gap: 2px; }
+.pl-settings__choice-label { font-size: 13px; color: var(--dsw-alias-label-primary); }
+.pl-settings__choice-hint { font-size: 12px; line-height: 1.55; color: var(--dsw-alias-label-secondary); }
 `;
 
     function installCss(ctx) {
@@ -334,6 +350,51 @@ window.__ModuleLoader__.load({
       ]);
     }
 
+    /**
+     * 二选一（含以上）行 —— 每个选项一个单选按钮 + 名字 + 说明。
+     *
+     * ★ 为什么不用下拉框：这一项的两个选项**各有各的取舍**（省一次模型输出 vs
+     *   按内容分流），用户需要**看见取舍**才能选对。下拉框把说明藏起来了。
+     * ★ 选项来自宿主（`spec.options` 是**已展开的数组** —— 宿主那边是取值函数，
+     *   为躲 TDZ；见宿主 `SETTING_SPECS` 的注释）。客户端**不认识任何模式名**，
+     *   只按 `value`/`label`/`hint` 渲染 ⇒ 以后加第三个模式**不用改本文件**。
+     */
+    function ChoiceRow(props) {
+      const { spec, value, onChange, disabled } = props;
+      const opts = Array.isArray(spec.options) ? spec.options : [];
+      return h(Row, { label: spec.label, hint: spec.hint, stack: true }, [
+        h(
+          "div",
+          { key: "g", className: "pl-settings__choices" },
+          opts.map((o) =>
+            h(
+              "label",
+              {
+                key: String(o.value),
+                className:
+                  "pl-settings__choice" + (String(o.value) === String(value) ? " pl-settings__choice--on" : ""),
+              },
+              [
+                h("input", {
+                  key: "r",
+                  type: "radio",
+                  name: spec.key,
+                  value: o.value,
+                  checked: String(o.value) === String(value),
+                  disabled: disabled === true,
+                  onChange: () => onChange(o.value),
+                }),
+                h("span", { key: "t", className: "pl-settings__choice-body" }, [
+                  h("span", { key: "l", className: "pl-settings__choice-label" }, o.label || String(o.value)),
+                  o.hint ? h("span", { key: "h", className: "pl-settings__choice-hint" }, o.hint) : null,
+                ]),
+              ]
+            )
+          )
+        ),
+      ]);
+    }
+
     /** 档位行（文本框，逗号分隔）。 */
     function TiersRow(props) {
       const { spec, value, onChange, disabled } = props;
@@ -394,6 +455,7 @@ window.__ModuleLoader__.load({
       const value = draft[spec.key];
       const set = (v) => setDraft(Object.assign({}, draft, { [spec.key]: v }));
       if (spec.kind === "boolean") return h(BoolRow, { key: spec.key, spec, value, onChange: set, disabled });
+      if (spec.kind === "choice") return h(ChoiceRow, { key: spec.key, spec, value, onChange: set, disabled });
       if (spec.kind === "number") return h(NumberRow, { key: spec.key, spec, value, onChange: set, disabled });
       if (spec.kind === "tiers") return h(TiersRow, { key: spec.key, spec, value, onChange: set, disabled });
       if (spec.kind === "levels") return h(LevelsRow, { key: spec.key, spec, value, onChange: set, disabled });

package/lib/index.js

@@ -142,6 +142,8 @@ export const inject = ["tools"];
  */
 function settingDefaults() {
   return {
+    // ★★ 两个模式（2026-10-10，用户拍板）。见 `MODE_*` 常量与 `modeOf` 的注释。
+    mode: MODE_STEADY, // 默认「正常推进」= 与今天的行为逐条一致
     turnEndOffer: false, // 回合末四选一卡片（2026-10-09 用户决定默认关）
     highFidelityCompact: true, // 水位到点跑我们自己的高保真压缩
     // 触发水位：**复用那个常量**，不抄字面量（早于内核的 0.8）
@@ -171,6 +173,33 @@ function settingDefaults() {
  * `kind` 决定面板画什么控件；`scope` 说明它是否被项目清单覆盖。
  */
 const SETTING_SPECS = [
+  {
+    key: "mode",
+    kind: "choice",
+    label: "压缩模式",
+    // ★★ 这里**必须用取值函数**，不能直接写 `MODE_STEADY`：
+    //   本数组是**顶层 const**，模块初始化时当场求值；而那两个常量定义在文件更后面
+    //   ⇒ 直接引用会 `ReferenceError: Cannot access 'MODE_STEADY' before initialization`
+    //   （实测撞到，`import` 当场失败 ⇒ 内核起不来）。
+    //   ★ 这与 `settingDefaults()` 为什么是函数**同一个坑**，见它上面的长注释。
+    options: () => [
+      {
+        value: MODE_STEADY,
+        label: "正常推进",
+        hint: "按位置压缩：只压最旧一段、保留最近一段。省一次模型输出，适合一路向前干活。",
+      },
+      {
+        value: MODE_SURGICAL,
+        label: "反复追究",
+        hint:
+          "压缩前先让 AI 把这一段**分三个桶**：留在上下文 / 落进项目按需查 / 丢掉。" +
+          "适合要反复回看约束与假设的活。代价是每次多一段模型输出。",
+      },
+    ],
+    hint:
+      "★ 这一项**项目清单优先**：如果项目的 .dsh-ledger.json 里登记了 mode，以那个为准；" +
+      "这里的值只是**新项目**登记的默认值。也可以用 `/ledger mode` 随时切换。",
+  },
   {
     key: "turnEndOffer",
     kind: "boolean",
@@ -315,6 +344,16 @@ function normalizeSettings(raw) {
       value.logLevels = parseLevels(v, settingDefaults().logLevels);
       continue;
     }
+    if (k === "mode") {
+      // ★ 只接受登记过的模式名。打错一个字就**丢弃并如实报告**，
+      //   而不是静默退到默认 —— 否则用户以为切到了"反复追究"，实际还在"正常推进"。
+      if (typeof v !== "string" || !MODES.includes(v)) {
+        dropped.push(k);
+        continue;
+      }
+      value.mode = v;
+      continue;
+    }
     if (k === "pressureTiers") {
       if (!Array.isArray(v)) {
         dropped.push(k);
@@ -472,6 +511,44 @@ const MANIFEST_REL = ".dsh-ledger.json";
 /** 注入消息的 source.kind。自定义 kind ⇒ 官方 pre-step 的清理逻辑认不出它、动不了它。 */
 const INJECT_KIND = "project-ledger-notes";
 
+// ══════════════════════════════════════════════════════════════════════════════
+// ★★★ 两个模式（2026-10-10，用户拍板）
+//
+// 用户原话：*"我们把它定义为这个插件的两个模式。因为其实两个模式各有各的优劣性。
+//   正常向前推进的任务就执行现在的这个模式，如果需要反复追究的话，就执行第二种模式。"*
+//
+// 机制上的真实差别（**只有一个**，其余全同）：
+//
+//   · `steady`（正常推进）：压缩时**按位置**切 —— 从末尾往回攒够 `deltaKeepPoints`
+//     点，更早的一刀切掉。**不做内容判断**，省一次模型输出。
+//     代价：位置 ≠ 重要性，最旧那一段里可能正好有这个任务**最早的约束**。
+//
+//   · `surgical`（反复追究）：压缩**前**先让 AI 对这 20 点做一次**分流**（三个桶）：
+//       留（keep）  → 下一轮一定要知道的，压缩后**逐字重注入**
+//       落（stash） → 以后可能要查的，写进项目的 `_stash/`，**不占上下文**
+//       丢（drop）  → 已被取代的，只进日志
+//     代价：每次多一段模型输出；分错了会把垃圾留在上下文里。
+//
+// ★ 为什么这是"在 A 之上加一层"而不是另起一套：**内核的摘要提示词写死在
+//   `dsh-compaction-basic` 里**（实测它的可配置项只有 thresholdRatio / retainRatio /
+//   retainTokens / summarization* / maxTokens / modelPolicies —— **没有摘要模板**）。
+//   所以"压缩时保什么内容"我们改不了；能做的是**压缩后把该留的注回去**
+//   （胶囊已经在走这条路）。⇒ 两模式共用同一套压缩，差别只在压缩前后多做什么。
+//
+// ★ 默认必须是 `steady`：与今天的行为逐条一致（自检情形 27 有断言钉住默认值）。
+const MODE_STEADY = "steady";
+const MODE_SURGICAL = "surgical";
+const MODES = [MODE_STEADY, MODE_SURGICAL];
+
+/** 分流单的桶名（用户说的"划分"）。 */
+const TRIAGE_KEEP = "keep";
+const TRIAGE_STASH = "stash";
+const TRIAGE_DROP = "drop";
+
+/** `_stash/` 只存桶的目录名（在项目根下）。 */
+const STASH_DIR = "_stash";
+
+
 /** 活跃台账行数阈值默认值。 */
 const DEFAULT_MAX_ACTIVE_LINES = 300;
 
@@ -622,6 +699,33 @@ function changeRegisterMaxOf(info) {
   return currentSettings().changeRegisterMax;
 }
 
+/**
+ * 这个项目用哪个压缩模式 —— **项目清单优先**（与 `maxActiveLines` / `changeRegisterMax`
+ * 同一条口径，见 D25「一个事实只能有一个判定出口」）。
+ *
+ * ★ 为什么模式属于**项目**而不是全局：用户说的是*"正常向前推进的**任务**…需要反复追究的"*
+ *   —— 同一个仓库里，"把这个特性做完"和"查清这个 bug 为什么只在周二复现"就是两种活。
+ *   做成全局开关，就没法"平时推进、查问题时转追究"。
+ *
+ * ★ 清单里的值**只认登记过的模式名**：写错了就退回默认，并**不静默**——
+ *   `ledger_status` 会如实报"清单里的 mode 不认识"。
+ *
+ * @param {object} info `inspect()` 的结果
+ * @returns {"steady"|"surgical"} 生效模式
+ */
+function modeOf(info) {
+  const m = info?.manifest?.mode;
+  if (typeof m === "string" && MODES.includes(m)) return m;
+  const setting = currentSettings().mode;
+  return MODES.includes(setting) ? setting : MODE_STEADY;
+}
+
+/** 清单里的 mode 是不是写错了（供 `ledger_status` 如实报告，不静默）。 */
+function modeManifestSuspect(info) {
+  const m = info?.manifest?.mode;
+  return m !== undefined && !(typeof m === "string" && MODES.includes(m));
+}
+
 /**
  * 一段台账文本**去掉变更登记区之后**的行数。
  *
@@ -741,6 +845,31 @@ function bumpRevision(root) {
   }
 }
 
+/**
+ * 把「压缩模式」写进**项目清单**（`.dsh-ledger.json`）。
+ *
+ * ★ 为什么**不**改 `revision`：revision 是**台账内容**的并发保护（见 `bumpRevision`
+ *   的注释 —— 它防的是"两个会话各写各的、后者覆盖前者"）。模式是**配置**不是内容，
+ *   动它不该让别人的 `ledger_write(ifRevision)` 失败。
+ *   混在一起的代价是：用户敲一次 `/ledger mode`，另一个会话的台账写入就被拒了。
+ *
+ * @returns {{ok:boolean, reason?:string}}
+ */
+function writeManifestMode(root, info, mode) {
+  try {
+    if (!MODES.includes(mode)) return { ok: false, reason: `不认识的模式：${String(mode)}` };
+    const prev = info?.manifest ?? readManifest(root);
+    if (prev === undefined) return { ok: false, reason: "读不到清单" };
+    const next = { ...prev, mode, updatedAt: stamp(new Date()) };
+    const abs = path.join(root, MANIFEST_REL);
+    if (!isUnder(root, abs)) return { ok: false, reason: "清单路径逃出项目根" };
+    fs.writeFileSync(abs, JSON.stringify(next, null, 2) + "\n", "utf8");
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, reason: String(e?.message ?? e) };
+  }
+}
+
 /**
  * 「看起来像台账」的保守候选名。
  * ★ 刻意保守：只认名字里带 ledger / 台账 / status / progress 的。
@@ -1338,6 +1467,104 @@ function persistCapsule(root, info, sid, snap, opts) {
   }
 }
 
+/**
+ * 把「分流单」里 `落（stash）` 那一桶写进项目的只存区（`_stash/`）。
+ *
+ * ★ 用户原话（2026-10-10）：*"有必要查到的就放进项目中…没有必要保留的就归档"*
+ *   以及他对"落"的定位：**以后可能要查、但不该占上下文**。
+ *
+ * ★ 为什么不复用活动日志：日志的硬不变量是「**一行 = 一条**」（解析 / grep / limit
+ *   全建立在它上面），而一条分流项天然是**多行**（判断 + 理由 + 出处）。硬塞进去
+ *   会破坏那个不变量 —— 胶囊当年就踩过这个坑，所以它也是一个独立文件。
+ *
+ * ★ 为什么一个会话一个文件、而不是一条一个文件：
+ *   分流本来就**按次**发生（每次压缩一次），一次会话可能分流几十条。一条一文件
+ *   会把 `_stash/` 撑成几千个小文件；一天一文件又不好按会话回溯。
+ *   一张单子一个文件 = **可 diff、可按会话查、条数可控**。
+ *
+ * ★ 为什么**不需要**启用活动日志（与胶囊不同）：
+ *   胶囊是"日志的衍生物"，而 `_stash/` 是**用户明确要的中间层**（他拍板选的
+ *   "项目里的新文件区"）。但**仍然**只在有台账的项目里写 —— 与"没登记就不往
+ *   项目里写任何东西"那条承诺一致。
+ *
+ * @param {string} root 项目根
+ * @param {object} info `inspect(root)` 的结果
+ * @param {string} sid 会话 id
+ * @param {Array<{what:string, why?:string, where?:string}>} items 要"落"的条目
+ * @param {{source?:string, at?:Date, kept?:number, dropped?:number}} [opts]
+ * @returns {{ok:boolean, rel?:string, count?:number, reason?:string}}
+ */
+function persistStash(root, info, sid, items, opts) {
+  if (!Array.isArray(items) || items.length === 0) {
+    return { ok: false, count: 0, reason: "没有要「落」的条目" };
+  }
+  // ★ 与胶囊同一条承诺：**没有台账就不往项目里写任何东西**。
+  if (info?.activeRel === undefined) {
+    return { ok: false, count: 0, reason: "这个项目还没有台账 ⇒ 按约定不往项目里写文件" };
+  }
+  const now = opts?.at instanceof Date ? opts.at : new Date();
+  const { dir: period } = archiveStamp(now, info?.manifest?.archiveWeekMode);
+  const relDir = `${STASH_DIR}/${period}`;
+  const absDir = path.resolve(root, relDir);
+  if (!isUnder(root, absDir)) return { ok: false, count: 0, reason: "只存目录路径逃出项目根" };
+
+  const tag = tagOfId(sid);
+  const rel = `${relDir}/${capsuleFileStamp(now)}-${tag}.md`;
+  const abs = path.resolve(root, rel);
+  if (!isUnder(root, abs)) return { ok: false, count: 0, reason: "只存文件路径逃出项目根" };
+
+  const src =
+    opts?.source === "auto:delta" ? "自动（增量压缩前）"
+    : opts?.source === "auto:70%" ? "自动（70% 水位压缩前）"
+    : opts?.source === "manual" ? "手动（工具）"
+    : typeof opts?.source === "string" && opts.source !== "" ? String(opts.source)
+    : "未知来源";
+
+  const rows = items
+    .map((it) => {
+      const what = String(it?.what ?? "").trim();
+      if (what === "") return "";
+      const why = String(it?.why ?? "").trim();
+      const where = String(it?.where ?? "").trim();
+      return (
+        `- **${what}**\n` +
+        (why === "" ? "" : `  - 为什么留着：${why}\n`) +
+        (where === "" ? "" : `  - 去哪查：${where}\n`)
+      );
+    })
+    .filter((x) => x !== "")
+    .join("");
+  if (rows === "") return { ok: false, count: 0, reason: "条目全是空的" };
+
+  const body =
+    `# 只存单 · ${stampSec(now)} · [${tag}]\n\n` +
+    `> **来源**：${src}\n` +
+    `> **会话**：\`${sid}\`\n` +
+    `> **这是什么**：压缩时被判为「**以后可能要查、但不该占上下文**」的东西。\n` +
+    "> 它**不参与归档、永不注入上下文** —— 需要时自己 grep 这个目录。\n" +
+    (Number.isFinite(opts?.kept) || Number.isFinite(opts?.dropped)
+      ? `> **同一次分流的其余去向**：留在上下文 ${opts?.kept ?? 0} 条 · 丢掉 ${opts?.dropped ?? 0} 条。\n`
+      : "") +
+    "\n" +
+    rows;
+
+  try {
+    ensureDir(absDir);
+    // ★ `wx` = 永不覆写（记录是证据），与胶囊同一道保证。
+    try {
+      fs.writeFileSync(abs, body, { encoding: "utf8", flag: "wx" });
+      return { ok: true, rel, count: items.length };
+    } catch (e) {
+      if (e?.code !== "EEXIST") throw e;
+      const rel2 = `${relDir}/${capsuleFileStamp(now)}-${tag}-2.md`;
+      fs.writeFileSync(path.resolve(root, rel2), body, { encoding: "utf8", flag: "wx" });
+      return { ok: true, rel: rel2, count: items.length };
+    }
+  } catch (e) {
+    return { ok: false, count: 0, reason: `写只存单失败：${String(e?.message ?? e)}` };
+  }
+}
+
 
 /**
  * 采集缓冲的落盘延迟（毫秒）。
@@ -2032,7 +2259,13 @@ function deriveSettingsView(ctx) {
   const editor = typeof ctx?.get === "function" ? ctx.get("configEditor") : undefined;
   const out = {
     settings: currentSettings(),
-    specs: SETTING_SPECS.map((s) => ({ ...s })),
+    // ★ `options` 是**取值函数**（见 SETTING_SPECS 上的 TDZ 注释）：出站给客户端前
+    //   必须**展开成数组**，否则 `{...s}` 会带一个函数过去 —— `JSON.stringify`
+    //   直接把它丢掉，面板上那个选择器就成了空的，而且**不报错**。
+    specs: SETTING_SPECS.map((s) => ({
+      ...s,
+      ...(typeof s.options === "function" ? { options: s.options() } : {}),
+    })),
     defaults: settingDefaults(),
     writable: false,
   };
@@ -2696,11 +2929,26 @@ function renderAfterCompaction(info, capsule, meta) {
       ? "本插件在上下文水位到 **70%** 时主动执行了一次压缩（比内核默认的 80% 早），" +
         "为的是在丢失之前把状态落袋。"
       : "本会话的较早历史已被压缩。";
+  // ★ 「反复追究」模式：压缩**前** AI 自己分出来的 keep 桶，这里逐字注回。
+  //   它与机械胶囊**并列**而不是取代 —— 两者失败模式不同（见 `state.triageKeep` 注释）。
+  const keep = Array.isArray(meta?.keep) ? meta.keep : [];
+  const keepBlock =
+    keep.length === 0
+      ? ""
+      : "---\n\n## ★ 分流单 · 留在上下文的那一份（**压缩前你自己挑的**）\n\n" +
+        "> 这是你在压缩前判为「下一轮不知道就会做错」的东西，**逐字**注回。\n" +
+        "> 其余已按你的划分处理：能查的落进了 `_stash/`，被取代的丢了。\n\n" +
+        keep.map((k, i) => `${i + 1}. ${String(k?.what ?? "").trim()}`).join("\n") +
+        "\n\n";
   return (
     head +
-    "\n## 上下文刚被压缩（台账 + 高保真胶囊已重新注入）\n\n" +
+    "\n## 上下文刚被压缩（台账" +
+    (keep.length > 0 ? " + 分流单" : "") +
+    " + 高保真胶囊已重新注入）\n\n" +
     why +
-    "\n\n下面是**当前生效的台账**与**逐字胶囊**，请以它们为准接上工作，" +
+    "\n\n下面是**当前生效的台账**" +
+    (keep.length > 0 ? "、**你自己挑的分流单**" : "") +
+    "与**逐字胶囊**，请以它们为准接上工作，" +
     "**不要**凭记忆复述被压掉的历史。\n\n" +
     // ★★ 需求 ④（D35）：**必须**声明"这些是历史素材，不是用户此刻的指令"。
     //
@@ -2719,6 +2967,7 @@ function renderAfterCompaction(info, capsule, meta) {
     "③ 若台账已超行数上限，先 `ledger_archive` 再写；" +
     "④ **若你需要某个文件的确切内容，直接重读磁盘**（胶囊里有路径）—— " +
     "重读是确定性的，比回忆可靠。\n\n" +
+    keepBlock +
     (capsule === undefined
       ? ""
       : `---\n\n## 高保真胶囊（**逐字**，本插件在压缩前整理）\n${capsule}\n---\n\n`) +
@@ -3303,27 +3552,46 @@ function headOf(info) {
 function renderPressureNotice(info, pressure, tier) {
   const pct = Math.round(pressure.ratio * 100);
   const line = Math.round(tier * 100);
+  // ★ 「反复追究」模式：提醒里**多一件事** —— 分流单（用户说的"对输出的东西做划分"）。
+  //   用户原话：*"对这 20 输出的工作量进行划分…最终只有 10%"*
+  const surgical = modeOf(info) === MODE_SURGICAL;
   const head =
     headOf(info) +
     `\n## 上下文水位已到 ${line}%（现 ${pct}%）\n\n` +
     `实测：已用 ${pressure.total} tokens / 官方上限 ${pressure.window} tokens。` +
     "官方会在 **80%** 处自动压缩，那时已读进上下文的东西会丢。\n\n";
 
+  // 分流那一步的文案（两种模式共用同一段，避免两处各写一份而分叉）。
+  const triageStep =
+    "3. ★ **做一次分流**（`ledger_triage`）—— 把这一段产出**当场分成三个桶**：\n" +
+    "   - `keep` **留在上下文**：下一轮不知道就会做错的东西（当前任务状态、" +
+    "还没验证的假设、**用户定过的约束**）。压缩后它会被**逐字注回**。\n" +
+    "   - `stash` **落进项目**：以后可能要查、但不该占上下文的（判断与理由、" +
+    "走不通的路、关键文件位置）。写进 `_stash/`，**永不注入**，需要时自己 grep。\n" +
+    "   - `drop` **丢掉**：已被取代 / 已完成且不再影响判断的。\n" +
+    "   ⚠️ **留得太多等于没压** —— `keep` 只放「不知道就会做错」的，" +
+    `最多 ${TRIAGE_KEEP_MAX} 条（超了按你给的顺序截断，并会如实告诉你截掉几条）。\n`;
+
   if (tier >= 0.7) {
     return (
       head +
-      "**顺序只有两步：先固化这一步的进展，然后照常继续干活。**\n" +
+      (surgical
+        ? "**顺序是三步：先固化这一步的进展，再分流，然后照常继续干活。**\n"
+        : "**顺序只有两步：先固化这一步的进展，然后照常继续干活。**\n") +
       "1. 把本轮进展写进活跃台账（`ledger_write`，带 `ifRevision` 与你的会话编号）；\n" +
       (info.logRel !== undefined
         ? "2. 写一条活动日志 L1 摘要（`ledger_log_write`，title 必填）。\n"
         : "") +
-      "\n★★ **压缩会等你写完**：在你把上面两步做完之前，插件**不会**压缩" +
+      (surgical ? triageStep : "") +
+      "\n★★ **压缩会等你写完**：在你把上面这些做完之前，插件**不会**压缩" +
       "（先记台账、再压缩 —— 否则压掉的正是这一轮唯一的那份进展）。\n" +
-      "\n★★ **做完这两步就继续手上的工作，不要停、也不要为此提问。**" +
+      "\n★★ **做完就继续手上的工作，不要停、也不要为此提问。**" +
       "本插件会在你结束本轮后**自动执行一次高保真压缩**（它拦不住官方的 80%，" +
       "所以**在 70% 就提前把自己的那份做好**）。\n" +
       "压缩对你**基本无感**：旧历史会被换成摘要，同时插件会把你这一段用过的" +
-      "**逐字胶囊**（用户原话 / 报错原文 / 器物索引 / 可重读路径）重新注回来 —— " +
+      "**逐字胶囊**（用户原话 / 报错原文 / 器物索引 / 可重读路径）" +
+      (surgical ? "与**你自己挑的分流单**" : "") +
+      "重新注回来 —— " +
       "所以压完之后你仍然知道我们刚才在做什么、改过哪些文件。\n\n" +
       "★ 若你**确实**想在这个水位把选择权交给用户（例如本轮要做的事一时说不完，" +
       `值得写交接单），那才调用 \`${CHECKPOINT_TOOL}\`；否则**不必打扰他**。\n\n` +
@@ -3338,7 +3606,13 @@ function renderPressureNotice(info, pressure, tier) {
     (info.logRel !== undefined
       ? "2. 写一条活动日志 L1 摘要（`ledger_log_write`，title 必填）。\n"
       : "") +
+    // ★ 分流**只在 70% 那一档要**（它比写台账贵：要 AI 判断）。
+    //   30/50% 只做"低成本固化"，不打扰它做分类 —— 否则每档都要它多产出一段。
     "\n★ **压缩会等你写完**（先记台账、再压缩）；写完就继续干活，**不要为此停顿**。\n" +
+    (surgical
+      ? "★ 本项目在**反复追究**模式：到 **70%** 那一档，除了上面两步，" +
+        "插件还会要求你做一次 `ledger_triage` **分流**（留 / 落 / 丢）。\n"
+      : "") +
     "★ **70%** 那一档也是照常继续干活 —— 区别只是插件会在那一档**自己压一次**，\n" +
     "  把状态在官方 80% 压缩之前落袋。\n" +
     "★ 任何时候你**自己觉得有必要**（做完一个阶段、要换方向、改动很大），" +
@@ -3968,6 +4242,31 @@ function noteFlushed(state, exec) {
   }
 }
 
+/**
+ * 「反复追究」模式下的**分流义务**：我们要求过它分流吗？它分了吗？
+ *
+ * ★ 为什么**不能**塞进 `flushOwedAt` 一起判：
+ *   `noteFlushed` 在写台账时**就会**清掉 `flushOwedAt`（那是"落盘"的义务）。
+ *   而分流是**另一件事** —— 若共用一个标记，AI"只写了台账没分流"就会**静默**
+ *   通过闸门 ⇒ 压缩照跑、keep 桶是空的 ⇒ **模式退化成正常推进，且没人知道**。
+ *   ⇒ 两条义务各自记，闸门两条都查。这与 `flushOwedAt` 当初为什么要独立于
+ *     周期判据，是同一个道理（**做成参数/共用一个标记，就会有人漏**）。
+ *
+ * @returns {{owed:boolean}} `owed` = 要求过但还没做
+ */
+function triageOwed(state, sid) {
+  const key = String(sid);
+  const owedAt = state.triageOwedAt?.get?.(key);
+  if (owedAt === undefined) return { owed: false };
+  const doneAt = state.triageAt?.get?.(key);
+  if (doneAt !== undefined && doneAt > owedAt) {
+    // 它照做了（`ledger_triage` 里已经清掉，这里是双保险）。
+    state.triageOwedAt.delete(key);
+    return { owed: false };
+  }
+  return { owed: true, owedAt };
+}
+
 /**
  * 「压缩前强制落盘」的那道闸门。
  *
@@ -4101,6 +4400,35 @@ function flushBeforeCompact(state, sid, info, opts) {
   if (flushedAt > lastCompactAt) {
     // 本周期真落过盘 ⇒ 之前的"被拦"计数清零（它只描述"连续没落盘"）。
     state.flushBlocked.delete(key);
+    // ★★ 但**分流**是另一条义务：落盘不等于分过流。
+    //   在「反复追究」模式下，若我们要求过分流而它没做，**仍然不许压** ——
+    //   否则 keep 桶是空的，压缩照跑，模式**静默退化**成正常推进。
+    if (modeOf(info) === MODE_SURGICAL && triageOwed(state, sid).owed === true) {
+      const trec = state.triageBlocked.get(key) ?? { count: 0 };
+      trec.count += 1;
+      state.triageBlocked.set(key, trec);
+      if (trec.count < FLUSH_BLOCK_GIVEUP) {
+        return {
+          ok: false,
+          missing: ["分流单"],
+          reason:
+            "本项目在**反复追究**模式：压缩前要先做一次分流，而**这一轮还没做**。" +
+            "用 `ledger_triage` 把这一段分成三个桶（`keep` 留上下文 / `stash` 落进项目 / " +
+            "`drop` 丢掉），之后压缩会自动继续。",
+          hint: "ledger_triage",
+          blockedCount: trec.count,
+          owedTriage: true,
+        };
+      }
+      // 死锁防护：等不到就放行，但如实标注（不假装分过流）。
+      state.triageOwedAt.delete(key);
+      state.triageBlocked.delete(key);
+      return {
+        ok: true,
+        why: `已连续 ${trec.count} 次要求分流仍未做，本次放行（避免压缩永不发生）`,
+        forcedThrough: true,
+      };
+    }
     return { ok: true, why: "本周期内已落盘" };
   }
 
@@ -5100,6 +5428,24 @@ function defineStatusTool(ctx) {
         activeLines: info.activeLines,
         maxActiveLines: info.maxActiveLines,
         overThreshold: info.overThreshold,
+        // ★★★ 两个模式（2026-10-10）：**生效值**与**它是从哪来的**分开报。
+        //   只报生效值不够 —— 用户改了清单却发现"没变"，必须能一眼看出是清单没读到、
+        //   还是清单里那个值不认识（后者要**说出来**，不许静默退默认）。
+        mode: modeOf(info),
+        modeSource: (() => {
+          const m = info.manifest?.mode;
+          if (typeof m === "string" && MODES.includes(m)) return "manifest";
+          const s = currentSettings().mode;
+          if (typeof m === "string") return "manifest-unknown";
+          return MODES.includes(s) ? "setting" : "default";
+        })(),
+        modeManifestValue: info.manifest?.mode ?? null,
+        modeManifestSuspect: modeManifestSuspect(info),
+        modeHint: modeManifestSuspect(info)
+          ? `清单里的 \`mode\` = ${JSON.stringify(info.manifest?.mode)} **不认识** ⇒ ` +
+            `当前按「正常推进」跑。认得的只有：${MODES.join(" / ")}。`
+          : null,
+        modeLabel: modeOf(info) === MODE_SURGICAL ? "反复追究" : "正常推进",
         git: gitAvailable() ?? null,
         // ★★ 把"压缩服务够不够得着"**报出来**。
         //
@@ -6732,6 +7078,161 @@ function defineHandoffTool() {
   };
 }
 
+/**
+ * ⑦之二 `ledger_triage` —— 「反复追究」模式下的**分流单**（用户说的"划分"）。
+ *
+ * ★ 用户原话（2026-10-10）：*"对这 20 输出的工作量进行划分…最终只有 10%"*
+ *   以及 *"没必要保留的是有必要查到的就放进项目中，然后没有必要保留的就归档"*
+ *
+ * 三个桶（**必须由 AI 判断**，不是机械规则 —— 规则抓不到"假设 / 走不通的路"）：
+ *
+ *   keep  留在上下文：**下一轮一定要知道**的。压缩后**逐字重注入**。
+ *   stash 落进项目：以后可能查，但**不该占上下文**。写进 `_stash/`，按需 grep。
+ *   drop  丢掉：已被取代 / 已完成且不再影响判断。
+ *
+ * ★ 为什么 `keep` 必须有硬上限：不限的话，"什么都重要"会把上下文撑回去，
+ *   等于没压。超上限就**按顺序截断**（AI 给的顺序即优先级），
+ *   并**如实报出被截掉几条** —— 否则分流不可验证。
+ */
+const TRIAGE_KEEP_MAX = 12;
+
+function defineTriageTool(state) {
+  return {
+    name: "ledger_triage",
+    description:
+      "Split the work done so far into three buckets before a compaction runs. Use it in the " +
+      "'surgical' (反复追究) mode, or whenever you are about to lose detail you may need later. " +
+      "`keep` = must be known next turn; it is re-injected VERBATIM after the compaction. " +
+      "`stash` = may be needed later but should not occupy context; written into the project's " +
+      "_stash/ directory and never injected. `drop` = superseded. Being honest here is the whole " +
+      "point: if you put everything in `keep`, nothing is compressed.",
+    parameters: {
+      type: "object",
+      properties: {
+        keep: {
+          type: "array",
+          description:
+            "Things that MUST be known next turn — current task state, unverified assumptions, " +
+            "constraints the user set. Re-injected verbatim after compaction. Keep it SHORT. " +
+            `At most ${TRIAGE_KEEP_MAX} items; extras are truncated (in your order) and reported.`,
+          items: {
+            type: "object",
+            properties: {
+              what: { type: "string", description: "The thing itself, one line." },
+            },
+            required: ["what"],
+            additionalProperties: false,
+          },
+        },
+        stash: {
+          type: "array",
+          description:
+            "Worth keeping but NOT worth context — decisions and their reasons, dead ends you " +
+            "already ruled out, key file locations. Written to the project's _stash/ for later grep.",
+          items: {
+            type: "object",
+            properties: {
+              what: { type: "string", description: "What it is, one line." },
+              why: { type: "string", description: "Why it may be worth finding again." },
+              where: {
+                type: "string",
+                description: "Where to look — an exact path or command. ★ Paths, not descriptions.",
+              },
+            },
+            required: ["what"],
+            additionalProperties: false,
+          },
+        },
+        drop: {
+          type: "array",
+          description:
+            "Superseded or finished-and-irrelevant. Listed so the split is auditable; nothing is written.",
+          items: {
+            type: "object",
+            properties: { what: { type: "string" } },
+            required: ["what"],
+            additionalProperties: false,
+          },
+        },
+        root: ROOT_PARAM,
+      },
+      additionalProperties: false,
+    },
+    output: { schema: OK_SCHEMA, render: renderResult },
+    async execute(args, exec) {
+      const root = rootFromExec(exec, args);
+      const info = inspect(root);
+      if (info.activeRel === undefined) {
+        return {
+          ok: false,
+          reason:
+            "这个项目还没有台账 ⇒ 按约定不往项目里写文件。先 `/ledger init`，" +
+            "或者用 `root` 点名一个已经有台账的项目。",
+        };
+      }
+      const arr = (v) => (Array.isArray(v) ? v.filter((x) => x !== null && typeof x === "object") : []);
+      const keepAll = arr(args?.keep);
+      const stash = arr(args?.stash);
+      const drop = arr(args?.drop);
+
+      const keep = keepAll.slice(0, TRIAGE_KEEP_MAX).map((x) => ({
+        what: String(x?.what ?? "").trim(),
+      })).filter((x) => x.what !== "");
+      const overflow = Math.max(0, keepAll.length - TRIAGE_KEEP_MAX);
+
+      if (keep.length === 0 && stash.length === 0 && drop.length === 0) {
+        return { ok: false, reason: "三个桶都是空的 —— 没有内容可分。" };
+      }
+
+      const sid = String(exec?.agent?.session?.header?.id ?? "");
+      const at = stampSec(new Date());
+
+      // ★ keep 桶存进 state，压缩后由重注那一步消费（与胶囊同一条通道）。
+      if (keep.length > 0 && sid !== "") {
+        state.triageKeep.set(String(sid), { at, items: keep });
+      }
+      // ★★ 记下"这次分流做过了" ⇒ 闸门那条**分流义务**随之兑现（见 `triageOwed`）。
+      //   ⚠️ 即使 keep 是空的也要记：只 stash / 只 drop 也是一次**合法的分流**，
+      //      否则闸门会一直等它做一件它已经做过的事（活锁）。
+      if (sid !== "") {
+        const key = String(sid);
+        state.triageAt.set(key, Date.now());
+        state.triageOwedAt?.delete?.(key);
+        state.triageBlocked?.delete?.(key);
+      }
+
+      // ★ stash 桶落盘（只在有台账的项目里写）。
+      let stashResult = { ok: false, count: 0 };
+      if (stash.length > 0) {
+        stashResult = persistStash(root, info, sid, stash, {
+          source: "manual",
+          kept: keep.length,
+          dropped: drop.length,
+        });
+      }
+
+      return {
+        ok: true,
+        kept: keep.length,
+        stashed: stashResult.ok === true ? stashResult.count : 0,
+        dropped: drop.length,
+        stashPath: stashResult.rel ?? null,
+        overflow,
+        mode: modeOf(info),
+        note:
+          `分流完成：留 ${keep.length} 条（压缩后逐字重注） · ` +
+          `落 ${stashResult.ok === true ? stashResult.count : 0} 条` +
+          (stashResult.ok === true ? `到 \`${stashResult.rel}\`` : `（未落盘：${stashResult.reason}）`) +
+          ` · 丢 ${drop.length} 条。` +
+          (overflow > 0
+            ? `\n★ keep 超上限 ${TRIAGE_KEEP_MAX}，**已截掉 ${overflow} 条**（按你给的顺序保留前 ${TRIAGE_KEEP_MAX} 条）。`
+            : "") +
+          "\n★ 提醒：**留得太多等于没压。** keep 只放「下一轮不知道就会做错」的东西。",
+      };
+    },
+  };
+}
+
 /**
  * ⑦ ledger_log —— 回溯读活动日志（**不注入上下文**，只在需要时读切片）。
  */
@@ -6957,6 +7458,14 @@ const LEDGER_SUBCOMMANDS = [
       "立刻做一次**轻量**压缩：**只压最旧一段、保留最近一大块**。水位小幅回落，新近细节完整保留。",
   },
   { sub: "log", label: "看活动日志状态", description: "四档粒度开没开、有多少文件。不注入上下文。" },
+  {
+    sub: "mode",
+    label: "切换压缩模式（正常推进 / 反复追究）",
+    description:
+      "在「**正常推进**」（按位置压最旧一段，省一次模型输出）与「**反复追究**」" +
+      "（压缩前由 AI 分流：留上下文 / 落进项目 `_stash/` / 丢掉）之间切换。" +
+      "★ 写进**这个项目**的 `.dsh-ledger.json`，只影响本项目；不带参数则只报当前模式。",
+  },
   {
     sub: "handoff",
     label: "写交接单（给下一场会话）",
@@ -7232,7 +7741,7 @@ async function runManualLightCompactNow(ctx, invocation, state, root) {
  * 真正执行一个子命令。**卡片选中的与手打的走的是同一条路** ——
  * 同一个子命令无论从哪个入口进来，后果必须一模一样。
  */
-async function runLedgerSub(ctx, invocation, state, sub, capsule) {
+async function runLedgerSub(ctx, invocation, state, sub, capsule, argument) {
   const root = projectRootOf(invocation?.agent);
   if (root === undefined) {
     return { kind: "error", text: "找不到本会话的工作目录，无法定位项目。" };
@@ -7256,6 +7765,74 @@ async function runLedgerSub(ctx, invocation, state, sub, capsule) {
     return await runManualLightCompactNow(ctx, invocation, state, root);
   }
 
+  // ── `/ledger mode [steady|surgical]` —— 切换本项目压缩模式（2026-10-10）──
+  //
+  // ★ 为什么**写进项目清单**而不是全局设置：模式是**项目**的性质（见 `modeOf`）。
+  //   写全局会把别的项目一起改掉 —— 而那正是用户明确排除的（他选的是"项目级"）。
+  // ★ 为什么**必须**有这条命令：设置面板那一项的 hint 里写了"也可以用 `/ledger mode`
+  //   随时切换"。写了就得有，否则是空承诺（本文件反复强调的那条纪律）。
+  if (sub === "mode") {
+    const info = inspect(root);
+    const want = typeof argument === "string" ? argument.trim().toLowerCase() : "";
+    const cur = modeOf(info);
+    const label = (m) => (m === MODE_SURGICAL ? "反复追究" : "正常推进");
+
+    if (info.activeRel === undefined) {
+      return {
+        kind: "error",
+        text:
+          "这个项目还没有台账，写不了模式（模式登记在 `.dsh-ledger.json` 里）。\n\n" +
+          "先 `/ledger init`，或直接给工具传 `root` 点名一个有台账的项目。",
+      };
+    }
+    // 不带参数 = 只报当前模式（只读，不改任何东西）。
+    if (want === "") {
+      const suspect = modeManifestSuspect(info);
+      return {
+        kind: "success",
+        text:
+          `**压缩模式：${label(cur)}**（\`${cur}\`）\n\n` +
+          (suspect
+            ? `⚠ 清单里的 \`mode\` 是 \`${JSON.stringify(info.manifest?.mode)}\`，**不认识** ⇒ ` +
+              `当前按默认的「${label(MODE_STEADY)}」在跑。\n\n`
+            : "") +
+          "· `正常推进`（steady）：压缩时**按位置**只压最旧一段、保留最近一段。" +
+          "省一次模型输出，适合一路向前干活。\n" +
+          "· `反复追究`（surgical）：压缩**前**先让 AI 分三个桶 —— " +
+          "`keep` 留上下文（压缩后逐字注回）/ `stash` 落进项目 `_stash/`（不占上下文，按需查）/ " +
+          "`drop` 丢掉。适合要反复回看约束与假设的活。\n\n" +
+          `切换：\`/ledger mode steady\` 或 \`/ledger mode surgical\`。` +
+          (info.manifest?.mode === undefined
+            ? "\n\n（当前项目清单里**没有**登记 mode ⇒ 走的是设置面板里的默认值。）"
+            : `\n\n（当前项目清单里登记的 mode = \`${info.manifest.mode}\`。）`),
+      };
+    }
+    if (!MODES.includes(want)) {
+      return {
+        kind: "error",
+        text:
+          `认不出模式 \`${want}\`。只有两个：\`steady\`（正常推进）、\`surgical\`（反复追究）。\n\n` +
+          "★ 这里**故意不改**任何东西 —— 打错一个字就静默退到默认，" +
+          "会让用户以为切过去了（配置类功能最难查的失败模式）。",
+      };
+    }
+    const r = writeManifestMode(root, info, want);
+    if (r.ok !== true) {
+      return { kind: "error", text: `写清单失败：${r.reason}` };
+    }
+    return {
+      kind: "success",
+      text:
+        `已把**这个项目**的压缩模式切到「**${label(want)}**」（\`${want}\`）。\n\n` +
+        `登记位置：\`${path.join(root, MANIFEST_REL)}\`\n\n` +
+        (want === MODE_SURGICAL
+          ? "★ 下一档水位提醒（70%）起，压缩前会要求你做一次 `ledger_triage` 分流，" +
+            "压完把 `keep` 桶**逐字注回**。\n"
+          : "★ 已回到常态：压缩只按位置压最旧一段，不再要求分流。\n") +
+        "★ 这项**只影响本项目** —— 别的项目各按自己清单里的模式走。",
+    };
+  }
+
   if (sub === "log") {
     const info = inspect(root);
     if (info.logRel === undefined) {
@@ -7430,6 +8007,11 @@ async function runLedgerSub(ctx, invocation, state, sub, capsule) {
 async function handleLedgerCommand(ctx, invocation, state, capsule) {
   const raw = String(invocation?.rawInput ?? "").trim();
   const sub = (raw.split(/\s+/)[0] ?? "").toLowerCase();
+  // ★ 第二个及之后的词 = 参数（目前只有 `mode <steady|surgical>` 用）。
+  //   ★ 平台**没有** `invocation.argument` 这个东西 —— 命令拿到的是整串 `rawInput`
+  //     （见上面 `raw.split(/\s+/)[0]` 的原本写法）。所以要自己切出来，
+  //     不能想当然地读一个不存在的字段（读了就是永远 `""`）。
+  const rest = raw.split(/\s+/).slice(1).join(" ");
 
   // 显式帮助：不弹卡片，直接印文字（脚本化/观察时不该被一张卡片挡住）。
   if (sub === "help") return { kind: "success", text: ledgerHelpText() };
@@ -7440,10 +8022,10 @@ async function handleLedgerCommand(ctx, invocation, state, capsule) {
     if (picked === undefined) {
       return { kind: "success", text: ledgerHelpText("（没有选择，以下是用法）") };
     }
-    return await runLedgerSub(ctx, invocation, state, picked, capsule);
+    return await runLedgerSub(ctx, invocation, state, picked, capsule, "");
   }
 
-  return await runLedgerSub(ctx, invocation, state, sub, capsule);
+  return await runLedgerSub(ctx, invocation, state, sub, capsule, rest);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -7628,6 +8210,30 @@ function newState() {
      *   正是我们要救的东西。
      */
     capsuleSnapshot: new Map(),
+    /**
+     * sid → 「反复追究」模式里 **keep 桶**（压缩后逐字重注，与胶囊同一条通道）。
+     *
+     * ★ 为什么与胶囊**分开存**而不是并进胶囊：
+     *   胶囊是**插件机械抓的**（用户原话 / 报错 / 器物索引），它保证"模型忘了我也不会忘"；
+     *   keep 桶是**模型判断的**（假设 / 当前状态），它会漏。
+     *   两者来源不同、失败模式不同 ⇒ 分开存，压缩后**两份都注**，
+     *   一份当地板（零成本、不会漏），一份当天花板（有判断力）。见 `MODE_SURGICAL` 注释。
+     *
+     * ★ 用完即删：它只描述"紧接着的那一次压缩"，不是会话状态（与 `hfSource` 同一条口径）。
+     */
+    triageKeep: new Map(),
+    /**
+     * sid → **我们要求过分流的时刻**（「反复追究」模式的第二道义务）。
+     *
+     * ★ 为什么不与 `flushOwedAt` 共用：`noteFlushed` 在写台账时就会清掉那个标记，
+     *   而"写了台账"**不等于**"分过流"。共用 ⇒ "只写台账没分流"会静默通过闸门
+     *   ⇒ keep 桶空着压缩照跑 ⇒ **模式退化且无人察觉**。
+     */
+    triageOwedAt: new Map(),
+    /** sid → 上一次**真的做完分流**的时刻（与 `triageOwedAt` 比大小判是否兑现）。 */
+    triageAt: new Map(),
+    /** sid → 连续被"要求分流却没做"拦下的次数（死锁防护，与 `flushBlocked` 同口径）。 */
+    triageBlocked: new Map(),
     /**
      * sid → **这一次压缩是谁发起的**（需求 ②③：四条入口要分得清）。
      *
@@ -8047,6 +8653,7 @@ export function apply(ctx, config) {
     ["ledger_log_write", () => defineLogWriteTool(state)],
     ["ledger_note", defineNoteTool],
     ["ledger_handoff", defineHandoffTool],
+    ["ledger_triage", () => defineTriageTool(state)],
     ["ledger_conform", defineConformTool],
     ["ledger_compact", () => defineCompactTool(ctx, state, capsule)],
     [CHECKPOINT_TOOL, () => defineCheckpointTool(ctx, state)],
@@ -8169,9 +8776,13 @@ export function apply(ctx, config) {
           // 真正的输入对应物）；没有就现取（例如官方 80% 那次压缩，我们没参与）。
           const snap = state.capsuleSnapshot.get(String(sid));
           state.capsuleSnapshot.delete(String(sid));
+          // ★ 「反复追究」模式：AI 自己分的 keep 桶，**消费掉**（同胶囊，描述"紧接着那一次压缩"）。
+          const tri = state.triageKeep.get(String(sid));
+          state.triageKeep.delete(String(sid));
           text = renderInjection(info, undefined, {
             capsule: snap ?? renderCapsule(info, capsule?.get(String(sid))),
             ours: snap !== undefined,
+            keep: tri?.items,
           });
         } else {
           // 没变化就别重复注入 —— 去重靠"指纹 + 文本"两道。
@@ -8235,6 +8846,13 @@ export function apply(ctx, config) {
               //     立了会永久卡住压缩 ⇒ 所以加 `activeRel` 判断。
               if (info.activeRel !== undefined) {
                 state.flushOwedAt.set(String(sid), Date.now());
+                // ★★ 「反复追究」模式：**同一刻**再立一条**分流**义务。
+                //   ★ 只在 tier≥0.7 立 —— 分流比写台账贵（要 AI 判断），
+                //     30/50% 那两档的文案里也**没有**要求分流（见 `renderPressureNotice`），
+                //     立了就成了"要求一件我没说的事"。
+                if (hit >= 0.7 && modeOf(info) === MODE_SURGICAL) {
+                  state.triageOwedAt.set(String(sid), Date.now());
+                }
               }
             }
           }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-ledger-memory",
-  "version": "0.1.1",
-  "description": "台账记忆（Ledger Memory）：为 DSH 提供工程化的项目记忆 —— 台账的检测/注入/归档/Git 配合，活动日志（L0–L4），三层上下文压缩与逐字胶囊落盘，以及跨会话的交接单闭环。可回溯、可追查。",
+  "version": "0.2.0",
+  "description": "台账记忆（Ledger Memory）：为 DSH 提供工程化的项目记忆 —— 台账的检测/注入/归档/Git 配合，活动日志（L0–L4），三层上下文压缩与逐字胶囊落盘，两种压缩模式（正常推进 / 反复追究），以及跨会话的交接单闭环。可回溯、可追查。",
   "keywords": [
     "dsh",
     "dsh-plugin",
@@ -10,6 +10,7 @@
     "memory",
     "context",
     "compaction",
+    "triage",
     "handoff",
     "traceability",
     "agent"