From 100a00c7371b88c8fe0f8014a05c77a6ea010e7f Mon Sep 17 00:00:00 2001
From: argszero <argszero@gmail.com>
Date: Thu, 15 Oct 2026 18:41:56 +0800
Subject: [PATCH] feat(rollup): keep ten minutes of transaction detail by
 default
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

With the transactions page reading the read model (#406), the detail
window no longer decides how far back the page can answer — the folded
minute roll-ups carry that history. So the window can now be set to what
the record actually needs, and the host's ruling of 2026-10-15 is that no
one queries individual records at all: ten minutes.

`[rollup] retain_minutes` therefore defaults to 10 instead of 43200 (30
days), and the example config follows. The deletion itself is unchanged —
rows are still only deleted once they are folded *and* archived, so
nothing is lost: the folded part stays answerable as minute roll-ups and
the original rows stay in the JSONL archive.

The transactions note no longer converts the retention boundary into
days. It used to round the boundary to whole days, which was already
lossy and would now be wrong in a visible way — a ten-minute window
rounds to "the last 0 days". The sentence names the boundary instant
instead, which is unit-free and needs no second calculation on the
client (the server computes the boundary from the same expression the
deletion uses).

`tx_retention_gate` R1 is rewritten, because its premise was exactly
what #406 removed ("the list can always only answer from the detail
table"). It now has two halves:

- the window must be expressible in minutes — a config that has gone
  back to spelling it in days turns this red, because day granularity
  cannot express ten minutes at all: below one day there is only 0, and
  0 already means "keep no detail", a different rule;
- when the window is shallower than the deepest preset the list offers,
  the difference can only be carried by the list no longer reading the
  detail table at all — the ledger is that a page answering from the raw
  table would silently answer less, with nothing on screen saying so.

The rule is not relaxed to nothing: putting the list back on the raw
table makes it apply again. Both halves were verified by mutation on the
real corpus (config back to days => only R1 goes red; list back to the
raw table => only R1 goes red).

Tests: `cargo test` 562 passed, 0 failed. `cargo fmt --check` clean,
`cargo clippy --all-targets -- -D warnings` rc=0, `cargo build` rc=0.
---
 config/config.example.toml |   9 +--
 src/config.rs              |  20 +++---
 src/tx_retention_gate.rs   | 134 +++++++++++++++++++++++++++++++------
 ui/README.md               |  17 +++--
 ui/index.html              |   4 +-
 ui/js/app.js               |   7 +-
 ui/js/i18n.js              |   6 +-
 7 files changed, 152 insertions(+), 45 deletions(-)

diff --git a/config/config.example.toml b/config/config.example.toml
index de1302b..deb13e9 100644
--- a/config/config.example.toml
+++ b/config/config.example.toml
@@ -71,10 +71,11 @@ interval_secs = 60                  # 归档扫描间隔（秒）
 enabled = true                      # 是否启用折叠（默认 true）
 batch = 2_000                       # 每轮最多折叠多少条明细（越小 → 单次持库时间越短）
 interval_secs = 60                  # 折叠扫描间隔（秒）
-retain_minutes = 43_200             # 明细保留窗口（**分钟**，默认 43200 = 30 天）：早于
-                                    # now-retain_minutes 的已折叠明细每轮删一批。
-                                    # 0 = 不留明细（只留汇总），交易页将只答得出最近一分钟。
-                                    # 旧拼写 retain_days（天）仍认且优先 —— 新配置用本键。
+retain_minutes = 10                 # 明细保留窗口（**分钟**，默认 10）：早于 now-retain_minutes
+                                    # 的已折叠明细每轮删一批。窗口外的明细不丢 —— 交易页读读模型
+                                    # tx_facts，它们以分钟汇总行呈现（一行代表 N 条）。
+                                    # 0 = 不留明细（只留汇总），交易页上每一行都是汇总行。
+                                    # 旧拼写 retain_days（天）仍认且**优先** —— 新配置用本键。
 
 # ============================================================
 # 0.5 用量明细保留（rant 2026-10-09T12:28:58 的独立余项）：`usage_records` 是同一笔
diff --git a/src/config.rs b/src/config.rs
index 3a9380e..78238f2 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -252,7 +252,7 @@ fn default_rollup_interval_secs() -> u64 {
     60
 }
 fn default_rollup_retain_minutes() -> i64 {
-    43_200
+    10
 }
 
 /// 交易明细汇总（[rollup] 段，rant 2026-10-09T12:28:58 验收项 1）。
@@ -264,9 +264,12 @@ fn default_rollup_retain_minutes() -> i64 {
 /// 删除只删**已折叠且已归档**的 —— 于是删掉的行永远有原件（JSONL）与聚合（汇总表）两个落脚处；
 /// `[archive]` 关掉时水位 0 ⇒ 不折也不删（fail-closed），这是刻意的。
 ///
-/// 窗口是**明细**的保留窗口（不是汇总的）：窗口内的明细仍逐条留在 `transactions` 里，
-/// 交易页照常翻页；窗口外的只剩汇总行（与 JSONL 里的原件）。取 0 即「明细只留汇总」的极值
-/// —— 折叠追平后 `transactions` 会被清空，交易页只答得出最近一分钟，**这是刻意的取舍，不是缺陷**。
+/// 窗口是**明细**的保留窗口（不是汇总的）。默认 **10 分钟**：宿主 2026-10-15 的裁定是「根本没有
+/// 查询真实明细的需求」（rant 2026-10-15T16:25:04.530850+08:00），窗口内的明细仍逐条留下，
+/// 窗口外的只剩汇总行（与 JSONL 里的原件）—— 而交易页**看得到**那段历史：它读读模型
+/// `tx_facts`，窗口外的那部分以**分钟级汇总行**呈现（一行代表 N 条，行自己用 `row_count` 交代）。
+/// 取 0 即「明细只留汇总」的极值 —— 折叠追平后 `transactions` 会被清空，交易页上每一行都是
+/// 汇总行，**这是刻意的取舍，不是缺陷**。
 ///
 /// 单位是**分钟**（`retain_minutes`）。此前是**天**（`retain_days`，默认 30）—— 那个单位
 /// 表达不出「只留 10 分钟」这样的保留策略，而已落地的删除本来就按 `datetime('now', ?)` 算偏移，
@@ -283,8 +286,9 @@ pub struct Rollup {
     /// 折叠扫描间隔（秒，默认 60；最小 1）
     #[serde(default = "default_rollup_interval_secs")]
     pub interval_secs: u64,
-    /// 明细的保留窗口（**分钟**，默认 `43200` = 30 天）：早于 `now - retain_minutes` 的
-    /// **已折叠**明细每轮删一批。0 = 不留明细（只留汇总），负数按 0 计。
+    /// 明细的保留窗口（**分钟**，默认 `10`）：早于 `now - retain_minutes` 的**已折叠**明细每轮
+    /// 删一批。0 = 不留明细（只留汇总），负数按 0 计。窗口外的明细在交易页上以分钟汇总行呈现
+    /// （读模型 `tx_facts`），不丢信息、只是粒度变粗。
     #[serde(default = "default_rollup_retain_minutes")]
     pub retain_minutes: i64,
     /// **已弃用**：保留窗口的旧拼写（**天**）。给出时**优先**于 `retain_minutes`（×1440），
@@ -621,9 +625,9 @@ mod tests {
         assert!(d.enabled, "默认启用 —— 折叠是「明细只留汇总」的前置");
         assert_eq!(d.batch, 2_000);
         assert_eq!(d.interval_secs, 60);
-        assert_eq!(d.retain_minutes, 43_200, "明细默认保留 30 天（43200 分钟）");
+        assert_eq!(d.retain_minutes, 10, "明细默认只保留 10 分钟");
         assert_eq!(d.retain_days, None, "旧拼写缺省不设 —— 新字段才是真源");
-        assert_eq!(d.window_minutes(), 43_200);
+        assert_eq!(d.window_minutes(), 10);
     }
 
     /// 旧拼写 `retain_days`（**天**）仍然算数（×1440），而且**优先**于新键 —— 老配置原样可用。
diff --git a/src/tx_retention_gate.rs b/src/tx_retention_gate.rs
index 561f5c0..2bc0d74 100644
--- a/src/tx_retention_gate.rs
+++ b/src/tx_retention_gate.rs
@@ -6,19 +6,29 @@
 //! 删除只受一条约束 —— `transactions` 的**分页列表**要的是逐行身份（`id`/`counterpart`），
 //! 汇总行没有它，所以列表**永远**只能从明细表答。于是：
 //!
-//! * **保留窗口必须盖得住列表自己提供的每一个预设区间**。少一天都不行：窗口是
-//!   `time < datetime('now', '-N minutes')`，列表最深预设若比它还深，用户点那个预设会
-//!   看到「共 N 条」和实际能翻的行数一起缩水，而**没有任何提示**（`total` 与行同源，
-//!   所以也不会自相矛盾 —— 它会安静地少答一段历史）。
+//! * **保留窗口必须能用分钟表达，且它在盖不住列表的预设时必须有「还债」的载体**。
+//!   窗口是 `time < datetime('now', '-N minutes')`，列表最深预设若比它还深、而列表又**只**
+//!   答得出窗口内的明细，用户点那个预设就会看到「共 N 条」和实际能翻的行数一起缩水，而
+//!   **没有任何提示**（`total` 与行同源，所以也不会自相矛盾 —— 它会安静地少答一段历史）。
+//!   本轴的原判据到此为止；rant `2026-10-15T16:25:04` 的验收项 2 把**后半句**改掉了：列表
+//!   改从读模型 `tx_facts` 取数之后，窗口外那段历史有载体（分钟汇总行），债还清了 ——
+//!   于是判据写成「窗口盖得住 **或** 列表不再从明细表取数」，而不是把规则删掉：谁把列表搬回
+//!   明细表，这条立刻重新生效（这正是验收项 5 的变异之一）。单位那一半仍然照旧：**读不到
+//!   分钟键**（又退回按「天」写）即红 —— 天粒度表达不了「只留 10 分钟」，一天以下只剩 `0`，
+//!   而 `0` 是「完全不留明细」这条**另一条**规则。
 //!   判据两侧都**派生**：预设深度从 `ui/js/app.js::txRangeParams` 读，窗口从
-//!   `config/config.example.toml` 的 `[rollup] retain_minutes`（分钟）读。
+//!   `config/config.example.toml` 的 `[rollup] retain_minutes`（分钟）读，「列表搬没搬」从
+//!   `src/routes/wallet.rs` 的列表端点体里读（不再出现 `FROM transactions` ⇒ 搬了）。
 //! * **盖不住的那类区间 ——「无界」的 —— 必须把边界说给页面**。`#tx-range` 里有两个区间
 //!   没有深度可言（「全部时间」、自定义起点）：它们能整段落在保留窗口之外，静态门禁**表达不了**
 //!   那种深度。判据因此换成「要么不提供、要么披露」：服务端随响应发布保留边界
 //!   （`tx_rollup` 的 `DETAIL_SINCE_FIELD`，与删除同一算式），前端在**缺口**上消费它
 //!   （`summary.entries` 与 `total` 的差）。**披露必须长在缺口上，不许长在「列表空」上**：
-//!   明细还在（`total > 0`）时同样会少列，而「只在一条明细都没有时才解释」正好让说明只在
-//!   **最不需要它**的场合发射（R104）。两侧同样**全派生**：选项名册从 `ui/index.html` 的
+//!   R104 轴的原形状是「只在一条明细都没有时才解释」，而那正好让说明只在**最不需要它**的
+//!   场合发射（零行态屏幕本来就写着「没有匹配记录」）。⚠️ 验收项 2 之后「缺口」的含义换了：
+//!   `entries > total` 不再说「有一段列不出来」，而说「这一屏里有行代表多条记录」（分钟汇总行）。
+//!   判据的形状（以缺口为准、不带空态闸门、被调用）不变 —— 那句话今天要说的正是「更早的行
+//!   是分钟级汇总」，所以它仍然必须长在**有行**的时候。两侧同样**全派生**：选项名册从 `ui/index.html` 的
 //!   `#tx-range` 读（哪些无界由「该分支有没有 `MS(…)` 深度」判定），字段名从 `tx_rollup.rs`
 //!   的常量读。
 //! * **删除的边界是「已折叠 ∧ 已归档」**。折叠水位（`transactions_rollup.up_to_id`）与
@@ -83,9 +93,17 @@ const OPTION_VALUE: &str = "<option value=\"";
 /// 明细保留边界字段名的**唯一拼写点**（`tx_rollup.rs` 的 `pub const`）。
 const BOUNDARY_CONST: &str = "pub const DETAIL_SINCE_FIELD: &str = \"";
 
-/// 服务端发布边界的地方（R4 的发布侧）。
+/// 服务端发布边界的地方（R4 的发布侧）。它同时是**列表端点**所在的那个文件。
 const PUBLISH_FILE: &str = "wallet.rs";
 
+/// 交易列表端点（R1 后半：它从哪个载体取数，决定窗口的「债」还不还得清）。
+const LIST_FN: &str = "pub async fn transactions(";
+
+/// 明细表在 SQL 里的拼法 —— 列表端点的体里**不得**再出现它（口径即「不再从明细表取数」；
+/// 与 `deletes_details_only` 同一种「反面即判据」的写法，理由同：正面的证据是**另一个门禁**
+/// 的事 —— `tx_facts_gate` R4 守「列表真的读视图」）。
+const RAW_TABLE: &str = "FROM transactions";
+
 /// 前端消费边界的地方（R4 的消费侧）—— `ui/js/app.js`，即 `oracle` 里那份语料。
 const CONSUME_FILE: &str = "app.js";
 
@@ -142,16 +160,32 @@ struct Reading {
     /// 前端真的在生产披露它 —— 生产函数的形状（见 `Disclosure`）：以**缺口**为准、不带空态
     /// 闸门、且被调用过。
     disclosure: Disclosure,
+    /// 交易列表端点**不再**从明细表取数（R1 后半的还债凭证）：它的函数体里有 `tx_facts::source(`
+    /// 而没有 `FROM transactions`。
+    list_reads_view: bool,
 }
 
 impl Reading {
-    /// R1：产品自己提供的每个预设区间都落在保留窗口内。
+    /// R1：窗口能用**分钟**表达，且它盖不住列表的预设时那个「欠」必须有人还。
+    ///
+    /// ① 单位：示例配置里读不到 `retain_minutes` ⇒ 又退回按「天」写 ⇒ 红。这不是形式主义 ——
+    ///    本轴存在的理由就是「只留 10 分钟」这个窗口在天的粒度下**写不出来**。
+    /// ② 覆盖债：窗口比列表最深预设浅时，只允许列表**不再从明细表取数**（那时窗口外那段历史
+    ///    由读模型的分钟汇总行承载）。列表若搬回明细表，这条立刻重新生效。
+    ///
+    /// ⚠️ 两侧**同单位**比较（预设是「天」、窗口是「分钟」）—— 直接比会把「10 分钟」当成 10 天，
+    /// 或（换算成天再取整）当成 0 天。
     fn r1(&self) -> bool {
-        match (self.presets_days.last(), self.retain_minutes) {
-            // 两侧**同单位**比较（预设是「天」、窗口是「分钟」）—— 直接比会把「10 分钟」
-            // 当成 10 天，或（换算成天再取整）当成 0 天。
-            (Some(deepest), Some(window)) => deepest.saturating_mul(MINUTES_PER_DAY) <= window,
-            _ => false,
+        let Some(window) = self.retain_minutes else {
+            return false;
+        };
+        match self.presets_days.last() {
+            Some(deepest) => {
+                deepest.saturating_mul(MINUTES_PER_DAY) <= window || self.list_reads_view
+            }
+            // 一个预设都没读出来 ⇒ 不做无据的断言（提取器失真由 `the_scanner_sees_both_sides`
+            // 的阳性对照兜：它要求至少 3 个预设、且含最深那个）。
+            None => false,
         }
     }
 
@@ -176,7 +210,7 @@ impl Reading {
 
     fn blame(&self) -> String {
         format!(
-            "r1={} r2={} r3={} r4={} · 预设 {:?} 天 · 窗口 {:?} 分钟 · 读不懂 {:?} · 只删明细 {} · 折叠界 {} · 归档界 {} · 两界同句 {} · 时间窗 {} · 区间选项 {:?} · 无界 {:?} · 边界字段 {:?} · 已发布 {} · 披露生产函数 {:?}（以缺口为准 {} · 空态闸门 {} · 被调用 {}）",
+            "r1={} r2={} r3={} r4={} · 预设 {:?} 天 · 窗口 {:?} 分钟 · 读不懂 {:?} · 列表读读模型 {} · 只删明细 {} · 折叠界 {} · 归档界 {} · 两界同句 {} · 时间窗 {} · 区间选项 {:?} · 无界 {:?} · 边界字段 {:?} · 已发布 {} · 披露生产函数 {:?}（以缺口为准 {} · 空态闸门 {} · 被调用 {}）",
             self.r1(),
             self.r2(),
             self.r3(),
@@ -184,6 +218,7 @@ impl Reading {
             self.presets_days,
             self.retain_minutes,
             self.unreadable,
+            self.list_reads_view,
             self.deletes_details_only,
             self.has_fold_bound,
             self.has_archive_bound,
@@ -206,6 +241,31 @@ impl Reading {
     }
 }
 
+/// 从**掩码文本**里切出某个具名函数的体（**含**第一个 `{`、**不含**配平的 `}`）。
+///
+/// 掩码等长（`mask_js` / `code_mask` 只把注释与可选的字符串正文涂成空格）⇒ 在掩码文本上算出的
+/// 下标对原文同样有效。函数的体一旦含多字节字符，按字节切**才**是安全的 —— 这正是本仓所有
+/// 走查器都走掩码文本的原因。
+fn function_body<'a>(masked: &'a str, marker: &str) -> Option<&'a str> {
+    let start = masked.find(marker)?;
+    let tail = &masked[start..];
+    let open = tail.find('{')?;
+    let mut depth = 0i32;
+    for (k, ch) in tail[open..].char_indices() {
+        match ch {
+            '{' => depth += 1,
+            '}' => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(&tail[open..=open + k]);
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
 /// `txRangeParams` 函数体在源码里的**字节区间** `[open, end)`（含第一个 `{`，不含配平的 `}`）。
 ///
 /// 掩码是**等长**的（`mask_js` 只把注释/字符串/正则的字节涂成空格）⇒ 在**掩码文本**上算出的
@@ -483,10 +543,17 @@ fn read() -> Reading {
         .unwrap_or_default();
     let field = boundary_field(&rollup);
     // 发布侧：引用常量名（不是又写一遍字面量 —— 那会变成第二个拼写点）。
-    let published = source_files()
+    let wallet = source_files()
         .into_iter()
         .find(|(name, _)| name.ends_with(PUBLISH_FILE))
-        .map(|(_, src)| src.contains("tx_rollup::DETAIL_SINCE_FIELD"))
+        .map(|(_, src)| src)
+        .unwrap_or_default();
+    let published = wallet.contains("tx_rollup::DETAIL_SINCE_FIELD");
+    // R1 后半的还债凭证：列表端点的体里**不再出现明细表**，却经 `tx_facts::source(` 取数。
+    // ⚠️ 掩码只掩注释（`false`）：要看的正是 SQL **字符串字面量**里的表名；掩掉字符串会让
+    // 「搬回明细表」在读数上消失（判据跟着一起瞎）。
+    let list_reads_view = function_body(&code_mask(&wallet, false), LIST_FN)
+        .map(|b| b.contains("tx_facts::source(") && !b.contains(RAW_TABLE))
         .unwrap_or(false);
     let consumed = field
         .as_deref()
@@ -526,6 +593,7 @@ fn read() -> Reading {
         boundary_field: field,
         boundary_published: published,
         disclosure: consumed,
+        list_reads_view,
     }
 }
 
@@ -534,8 +602,10 @@ fn the_retention_window_covers_every_preset_the_list_offers() {
     let r = read();
     assert!(
         r.r1(),
-        "交易列表提供的预设区间比明细保留窗口还深 ⇒ 点那个预设会安静地少答一段历史（`total` \
-         与行同源，不会自相矛盾，只会一起缩水）：{}",
+        "明细保留窗口必须能用**分钟**表达（示例配置里读不到 `{RETAIN_KEY}` ⇒ 又退回按「天」写），\
+         且它比列表自己提供的预设还深时那个「欠」必须有人还：要么窗口盖得住，要么列表**不再从\
+         明细表取数**（读读模型 `tx_facts`，窗口外那段历史由分钟汇总行承载）。两者都没有 ⇒ 用户点\
+         深预设会安静地少答一段历史（`total` 与行同源，不会自相矛盾，只会一起缩水）：{}",
         r.blame()
     );
 }
@@ -563,12 +633,28 @@ fn the_retention_window_covers_every_preset_the_list_offers_negatives() {
     assert!(base.all(), "基线: {}", base.blame());
 
     for (name, mutate) in [
+        // R1 ① 单位：示例配置里读不到分钟键（又退回按「天」写）⇒ 该窗口表达不出来。
+        (
+            "窗口退回按「天」写（示例配置里读不到分钟键）",
+            Box::new(|r: &mut Reading| {
+                r.retain_minutes = None;
+            }) as Box<dyn Fn(&mut Reading)>,
+        ),
+        // R1 ② 覆盖债：窗口比最深预设浅，而列表也**搬回**明细表取数 ⇒ 深预设没人答得出来。
         (
-            "窗口收到列表最深的预设之下",
+            "窗口收到列表最深的预设之下，而列表也搬回明细表取数",
             Box::new(|r: &mut Reading| {
                 r.retain_minutes =
                     Some(r.presets_days.last().copied().unwrap_or(0) * MINUTES_PER_DAY - 1);
-            }) as Box<dyn Fn(&mut Reading)>,
+                r.list_reads_view = false;
+            }),
+        ),
+        // R1 ② 的另一半（这才是验收项 5 点名的变异）：窗口仍然盖不住，但把列表搬回明细表。
+        (
+            "把列表搬回明细表取数（窗口盖不住最深预设 ⇒ 债没人还）",
+            Box::new(|r: &mut Reading| {
+                r.list_reads_view = false;
+            }),
         ),
         (
             "删掉折叠水位界限",
@@ -699,6 +785,12 @@ fn the_scanner_sees_both_sides() {
         "服务端没引用那个常量（发布侧又写了一遍字面量，或发布点没了）：{}",
         r.blame()
     );
+    assert!(
+        r.list_reads_view,
+        "没在列表端点的体里看见「不再从明细表取数」（函数名变了？又或者列表真的搬回明细表了）—— \
+         这条是 R1 后半的凭证，它假阴性会让 R1 恒假、假阳性会让 R1 恒真：{}",
+        r.blame()
+    );
     assert!(
         r.disclosure.reaches_page(),
         "`{CONSUME_FILE}` 里没有一个「以缺口为准、不带空态闸门、且被调用过」的披露生产函数\
diff --git a/ui/README.md b/ui/README.md
index 1a496b8..25de49b 100644
--- a/ui/README.md
+++ b/ui/README.md
@@ -1309,6 +1309,10 @@ key**（正常操作）于是让运营者看到红色故障警报，而屏幕上
 
 ## 交易页列表从读模型取数（rant 2026-10-15T16:25:04.530850+08:00 验收项 2，2026-10-15）
 
+> **明细保留窗口的默认值同期改为 10 分钟**（验收项 1）：`[rollup] retain_minutes` 默认由
+> `43200`（30 天）改为 `10`，示例配置同步。窗口外的那段历史不丢 —— 它由本节说的分钟汇总行承载，
+> 交易的说明句因此不再把边界换算成「天」（那会变成「最近 0 天」），而是直接说**边界那一刻**。
+
 - **数据源**：`GET /api/transactions` 的**行与 `total` 都读读模型** `tx_facts`（＝分钟级汇总行 ∪
   未折叠明细，`src/tx_facts.rs`）。此前列表读裸 `transactions` ⇒ 「真实明细只留一小段」等于
   「交易页只答得出那一小段」；现在更早的历史以**分钟汇总行**的形式照样列得出来，`total` 与列表
@@ -1335,10 +1339,12 @@ key**（正常操作）于是让运营者看到红色故障警报，而屏幕上
   统计（`COUNT(`）必须存在 —— R1/R2/R3 全是「不许」，只剩它们时「列表搬回原始表」照样全绿，
   门禁就守不住本轮的成果（这条正是验收项 5 的变异腿）。数「**条数**」必须 `SUM(row_count)`
   那半归**事实**管（分母：`tx_facts.rs::counting_view_rows_is_not_counting_calls`）。
-- ⚠️ **下一片（rant 的 R5）**：`src/tx_retention_gate.rs` 的两条规则（R1「窗口必须盖住列表自己
-  提供的每一个预设区间」、R4「无界区间必须把边界说给页面」）建立在本轮已经消失的前提上
-  （「列表**永远**只能从明细表答」）—— 它们**今天仍绿**（前提过时，不是被违反），规则与那句文案
-  的重写与本节分开落地。
+- **门禁 R1 的判据随本轮改写**（rant 的 R5，2026-10-15）：原判据「窗口必须盖住列表自己提供的
+  每一个预设区间」建立在本轮已消失的前提上（「列表**永远**只能从明细表答」）。新判据是两半：
+  ①窗口必须能用**分钟**表达（示例配置里读不到 `retain_minutes` 即红 —— 天粒度写不出「10 分钟」）；
+  ②窗口比最深预设浅时，「欠」只能由**列表不再从明细表取数**来还（判据：列表端点的函数体里不再
+  出现 `FROM transactions`）。**不是**把规则删掉：谁把列表搬回明细表，这条立刻重新生效。
+  两条都做过 A/B（配置退回按天 ⇒ 只 R1 红；列表搬回明细表 ⇒ 只 R1 红）。
 
 ## 明细缺口的说明必须长在「缺口」上，不许长在「列表空」上（R105，2026-10-09；判据随验收项 2 改读读模型，2026-10-15）
 
@@ -1353,7 +1359,8 @@ key**（正常操作）于是让运营者看到红色故障警报，而屏幕上
   与 `summary.entries`）；「这句话落在哪儿」交给两个消费者 —— 明细还有行（`total > 0`）时由
   `renderTxArchivedNote()` 常驻在 `#tx-archived-note`（在 `renderTransactions()` 里每次重算），
   一条明细都没有时交给表格自己的零行态副标题（`txArchivedEmptySub()`）。⚠️ 列表改读读模型后
-  `entries > 0 ⇒ total > 0`（每条命中至少占一行）⇒ 零行态那条插槽**今天不可达**（措辞与规则重写归 R5）。
+  `entries > 0 ⇒ total > 0`（每条命中至少占一行）⇒ 零行态那条插槽**今天不可达**（保留是因为
+  判据只有一处、插槽是位置的选择；门禁只证那句话到得了页面）。
   ⛔ 两个插槽**同时**说 ⇒
   同一句话在一屏上出现两遍，也是缺陷（仓外探针有专门一条腿）。这不是「按列表空不空决定要不要说」
   —— 两种状态**都在说**，区别只是**落在哪儿**。
diff --git a/ui/index.html b/ui/index.html
index 696ed44..7a013e9 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -864,7 +864,7 @@ <h3 id="chat-title">使用模型</h3>
 
 <script src="js/api.js?v=20261012-1"></script>
 <script src="js/data.js?v=20260914-11"></script>
-<script src="js/i18n.js?v=20261015-1"></script>
-<script src="js/app.js?v=20261015-2"></script>
+<script src="js/i18n.js?v=20261015-2"></script>
+<script src="js/app.js?v=20261015-3"></script>
 </body>
 </html>
diff --git a/ui/js/app.js b/ui/js/app.js
index b7a38f7..ab7632f 100644
--- a/ui/js/app.js
+++ b/ui/js/app.js
@@ -1980,9 +1980,10 @@
     if (entries <= total) return null;
     const since = new Date(t.detail_since);
     if (isNaN(since.getTime())) return null;
-    // 天数由边界**现算**（边界是服务端按同一个算子算出来的），前端不另存一份「30」。
-    const days = Math.max(0, Math.round((Date.now() - since.getTime()) / 86400000));
-    return T("tx.empty.archived", { n: days });
+    // ⚠️ 不再把边界换算成「天」（rant 2026-10-15T16:25:04.530850+08:00 验收项 1：窗口的默认值
+    // 是 **10 分钟**）—— 分钟级的窗口取整成天会变成「最近 0 天」，一句错话。直接说**边界那一刻**：
+    // 单位无关，前端也不必再算一遍窗口（边界本来由服务端按同一个算子算出）。
+    return T("tx.empty.archived", { t: fmtPrecise(t.detail_since) });
   }
 
   // 上面那句话的**常驻**插槽：写进 `#tx-archived-note`，每次渲染重算（判据只有上面一处）。
diff --git a/ui/js/i18n.js b/ui/js/i18n.js
index 8f5e321..489ac1c 100644
--- a/ui/js/i18n.js
+++ b/ui/js/i18n.js
@@ -404,7 +404,9 @@
     "tx.status.credited": "入账",
     "tx.empty": "没有匹配的记录",
     "tx.empty.sub": "试试调整筛选条件",
-    "tx.empty.archived": "更早的记录已归档，明细仅保留最近 {n} 天（其汇总仍计入上方卡片）",
+    // 边界那一刻由服务端给（同一算子），前端只负责说出来 —— 窗口是分钟级（默认 10 分钟），
+    // 换算成「天」会变成「0 天」（rant 2026-10-15T16:25:04.530850+08:00 验收项 1/2）。
+    "tx.empty.archived": "更早的行是分钟级汇总：真实明细仅保留到 {t}（其汇总仍计入上方卡片）",
     // 读模型的汇总行代表 N 条真实明细（rant 2026-10-15T16:25:04.530850+08:00 验收项 2）——
     // 交易列表的「×N」标记的悬停说明，唯一写者是 `ui/js/app.js::txRowCount()`。
     "tx.row.bucket": "本行是分钟级汇总，代表 {n} 条真实明细",
@@ -1239,7 +1241,7 @@
     "tx.status.credited": "Credited",
     "tx.empty": "No matching records",
     "tx.empty.sub": "Try adjusting filters",
-    "tx.empty.archived": "Earlier entries are archived — details are kept for the last {n} days only (their totals still count in the cards above)",
+    "tx.empty.archived": "Earlier rows are per-minute roll-ups — individual records are kept until {t} only (their totals still count in the cards above)",
     "tx.row.bucket": "Per-minute roll-up — this row covers {n} records",
     "tx.filter.placeholder": "Filter…",
     "tx.filter.min": "min",