diff --git a/src/state_gate.rs b/src/state_gate.rs
index f82563a..756f6fc 100644
--- a/src/state_gate.rs
+++ b/src/state_gate.rs
@@ -220,6 +220,27 @@
 //! 行尾的 `//` 注释不算注释（`app.js` 当前两者都没有，`is_comment_line` 的兄弟门禁同型）。
 //! 只认字面表名：`const T = D; T.MARKET` 这类别名逃得过。
 //!
+//! # C2170：身份边界要清的不只是 `Live` —— **模块级**的视图状态同样跨不过边界
+//!
+//! `resetSessionCaches()` 只清 `Live` 的那些槽，而交易视图的状态是**模块级**的：`txTable` 的
+//! `sort`/`filters`/`page`/`pageSize`（载荷的**输入**）、`txRange`/`txCustomStart`/`txCustomEnd`
+//! （时间窗），以及 `txTable.loadedPage`/`loadedPageSize`/`loadedQuerySig`（载荷的**有效性证据**）。
+//! 证据属于载荷 —— 载荷被清空而证据留下，守卫（`txQuerySig()` 的比对）就会认一份**不存在**的
+//! 载荷为「已加载」，下一位用户的首帧是空表（服务端按 `offset=(page-1)*page_size` 返回 `items: []`
+//! 而 `total` 照旧非零）且**不自愈**。
+//!
+//! 不变量两条：① 身份边界的**闭包**必须**赋值**每一个派生出来的名字 —— `txTable` 字面量的字段 ＋
+//! `txTable.loaded*` ＋ `txQuerySig()` 读到的模块级 `let`，**零手抄名册**；② 这些名字的**证据写者**
+//! 只允许装载器与边界闭包（否则在 `renderTransactions()` 里清会把守卫每次渲染都重新武装 ⇒
+//! 请求风暴，C2146 同形）。复位必须回到**声明处的字面量**（`txTable.page = 1` /
+//! `txTable.pageSize = 10` / `txRange = "24h"`）而不是一键清空：`loadTransactions()` 的
+//! `Math.max(1, txTable.pageSize || 10)` 兜底会把 `undefined` 退化成「每页 1 行」。
+//!
+//! 已知边界（如实的射程）：本门禁是**词法**的 —— 它证明闭包**赋值**了每个名字、且值回到声明处的
+//! 字面量，**不**证明这些赋值无条件执行，也不证明屏幕上真的换了数据（那半归 jsdom 探针
+//! `c2170-probe.js`，仓内 CI 无 JS 运行器）。闭包只收 `function NAME(` 形式声明的函数（`call_graph`
+//! 的键）：把复位写进箭头常量时它看不见那个体的**内容**，规则 1 因此会**红**（诚实失败，不是假绿）。
+//!
 use std::collections::{BTreeMap, BTreeSet};
 
 /// 前端源码在**编译期**读入：测试不依赖工作目录与文件系统布局。
@@ -1237,6 +1258,126 @@ fn identifiers(text: &str) -> BTreeSet<String> {
     out
 }
 
+/// `prefix` + 标识符 在 `src` 里出现过的**完整名字**（去重、字典序）。
+///
+/// 左边界也锚：`xtxTable.loaded` 不算（坑 #333 同族：兄弟标识符不是证据）。
+fn names_with_prefix(src: &str, prefix: &str) -> Vec<String> {
+    let mut out: BTreeSet<String> = BTreeSet::new();
+    let bytes = src.as_bytes();
+    let mut from = 0usize;
+    while let Some(rel) = src[from..].find(prefix) {
+        let at = from + rel;
+        from = at + prefix.len();
+        if at > 0 && is_ident_byte(bytes[at - 1]) {
+            continue;
+        }
+        let rest = &src[at + prefix.len()..];
+        let tail: String = rest
+            .chars()
+            .take_while(|c| c.is_ascii_alphanumeric() || *c == '_')
+            .collect();
+        if !tail.is_empty() {
+            out.insert(format!("{prefix}{tail}"));
+        }
+    }
+    out.into_iter().collect()
+}
+
+/// `text` 里有没有对 `lhs` 的**赋值**（`lhs = …`）。
+///
+/// **两侧都锚**：右侧必须是分隔符 —— `txTable.page` 是 `txTable.pageSize` 的前缀、
+/// `txTable.loadedPage` 是 `txTable.loadedPageSize` 的前缀，只锚左侧就会把「复位了兄弟字段」
+/// 判成「复位了它」（坑 #333）。`==` / `===` / `=>` 都不是赋值。
+fn assigns_in(text: &str, lhs: &str) -> bool {
+    let mut from = 0usize;
+    while let Some(rel) = text[from..].find(lhs) {
+        let at = from + rel;
+        from = at + lhs.len();
+        if at > 0 && is_ident_byte(text.as_bytes()[at - 1]) {
+            continue;
+        }
+        let after = &text[at + lhs.len()..];
+        if let Some(c) = after.chars().next() {
+            if c.is_ascii_alphanumeric() || c == '_' {
+                continue;
+            }
+        }
+        let t = after.trim_start();
+        if let Some(rest) = t.strip_prefix('=') {
+            if !rest.starts_with('=') && !rest.starts_with('>') {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// 模块级 `let`（行首 2 空格缩进）的名字 —— 会话级视图状态就长这样（`app.js:15-22`）。
+fn module_level_lets(src: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    for line in src.lines() {
+        if let Some(rest) = line.strip_prefix("  let ") {
+            let name: String = rest
+                .chars()
+                .take_while(|c| c.is_ascii_alphanumeric() || *c == '_')
+                .collect();
+            if !name.is_empty() {
+                out.push(name);
+            }
+        }
+    }
+    out
+}
+
+/// `const TABLE = { … }` 字面量里 `field` 声明处的字面量文本（到 `,` / `}` 为止）。
+fn declared_literal(src: &str, table: &str, field: &str) -> Option<String> {
+    let (open, close) = object_literal_span(src, table)?;
+    let body = &src[open + 1..close - 1];
+    let needle = format!("{field}:");
+    let at = body.find(&needle)? + needle.len();
+    let rest = &body[at..];
+    // `[',', '}']` (a char-array pattern) rather than a closure: CI runs
+    // `cargo clippy --all-targets -- -D warnings`, and the closure form trips
+    // `clippy::manual_pattern_char_comparison` (measured: rustc/clippy 1.98.0).
+    let end = rest.find([',', '}']).unwrap_or(rest.len());
+    Some(rest[..end].trim().to_string())
+}
+
+/// `let NAME = <字面量>;` 声明处的字面量文本。
+fn declared_let_literal(src: &str, name: &str) -> Option<String> {
+    let needle = format!("let {name} = ");
+    let at = src.find(&needle)? + needle.len();
+    let rest = &src[at..];
+    let end = rest.find(';')?;
+    Some(rest[..end].trim().to_string())
+}
+
+/// 身份边界复位函数的**闭包**：`resetSessionCaches` 可达的函数名集合 + 它们的代码文本。
+///
+/// 闭包是必需的 —— 把复位抽进 `resetTxView()` 正是推荐写法（「一张表一处真源」），只看
+/// `resetSessionCaches` 自己的函数体会把抽出去的复位判成「没复位」。
+fn boundary_reset(src: &str) -> (String, Vec<String>) {
+    let graph = call_graph(src);
+    // ⚠️ **只保留本文件声明过的函数**（第 94 轮实测修）。`call_graph()` 的值是「行里以 `(` 结尾的
+    //    标识符」（`callee_names`），所以**方法名**（`Object.keys(...)`、`.forEach(...)`、`.push(...)`）
+    //    也会进图；而 `reachable()` 不看对方在不在图里就往 `seen` 里插 ⇒ 闭包混进
+    //    `forEach`/`keys`。它们没有函数体 ⇒ 下面那条自证「函数声明数 == 闭包大小」在**每一棵树**上
+    //    都为假（实测 live `1≠3`、fix `2≠4`）⇒ 门禁不是「诚实地红」，是**坏的**。
+    //    图的键**恰好**是声明集合（`call_graph` 只插 `function_name()` 认出来的名字）。
+    let reach: Vec<String> = reachable(&graph, &["resetSessionCaches".to_string()])
+        .into_iter()
+        .filter(|f| graph.contains_key(f))
+        .collect();
+    let mut text = String::new();
+    for f in &reach {
+        text.push_str(&function_code(src, f));
+        text.push('\n');
+    }
+    (text, reach)
+}
+
+//
+
 /// `stat(<label>, <value>, <sub>…)` 调用里**第二段实参**（取值表达式）的文本。
 ///
 /// 逗号按圆括号配平切分、字符串里的逗号不算分隔符 ⇒ 取值里可以嵌函数调用
@@ -2398,11 +2539,23 @@ mod tests {
         );
 
         // ── 不变量：写槽的人 == 记证据的人（守卫比的就是那三项）───────────────────────
-        assert_eq!(
-            writers,
-            holders,
-            "写 `Live.{TX_SLOT}` 的函数与写 `{TX_EVIDENCE}*` 的函数不是同一批 —— \
-             缓存内容与守卫手上的证据脱钩。实测证据写点：{:?}",
+        //
+        // C2170 起，身份边界（会话结束 / 建立）是**复位者**，不是第二个生产者：它清掉证据
+        // （`txTable.loaded*`）——证据是守卫信任的东西；槽本身由 `resetSessionCaches()` 的通用擦除负责
+        // （`Object.keys(Live).forEach(k => Live[k] = null)`，`transactions` 是 `Live` 字面量的字段）。
+        // 所以证据的写者合法地比槽的写者多一个；多出来的那个必须在**边界闭包里** ——
+        // 名册**派生**自边界闭包，不维护第二份手写名单。上面那条名册（槽的生产者）**逐字节不动**。
+        let boundary: BTreeSet<String> = boundary_reset(APP_JS).1.into_iter().collect();
+        assert!(
+            writers.is_subset(&holders),
+            "写了 `Live.{TX_SLOT}` 却不记 `{TX_EVIDENCE}*`：缓存内容与守卫手上的证据脱钩。             writers={writers:?} holders={holders:?}"
+        );
+        assert!(
+            holders
+                .difference(&writers)
+                .all(|h| boundary.contains(h)),
+            "`{TX_EVIDENCE}*` 的写者既不是装载器、也不在身份边界闭包里：             {:?} —— 在 `renderTransactions()` 里清会把守卫每次渲染都重新武装 ⇒ 请求风暴（C2146 同形）。             实测证据写点：{:?}",
+            holders.difference(&writers).collect::<Vec<_>>(),
             witnesses(APP_JS, writes_evidence)
         );
     }
@@ -5501,3 +5654,168 @@ mod tests {
         }
     }
 }
+
+/// C2170：身份边界必须连**模块级**视图状态一起清 —— `Live` 之外的会话状态同样跨不过边界。
+///
+/// 反例（实测，`c2170-probe.js`）：`resetSessionCaches()` 只清 `Object.keys(Live)`，而交易视图的
+/// 分页/筛选/时间段是模块级的 —— 尤其 `txTable.loaded*` 是**载荷的有效性证据**。载荷
+/// （`Live.transactions`）被清空而证据留下 ⇒ 下一位用户进入交易视图时守卫按 `txTable.page`
+/// （上一位用户的第 5 页）发请求；服务端 `offset=(page-1)*page_size` + `LIMIT ? OFFSET ?`
+/// （`wallet.rs:389/396/410`）回 `items: []` 而 `total: 3` ⇒ 屏幕上「没有匹配的记录」旁边写着
+/// 「共 3 条」，且**不自愈**（`buildDataTable` 把 `state.page` 夹到 1 发生在渲染**内部**，守卫
+/// 不会因此重跑；实测 2.5s 内零次纠正请求）。同一跳里 `type=consume` + 7 天 `start=` 也从
+/// 上一位用户手里带过来，新用户的视图被静默收窄。
+#[test]
+fn the_identity_boundary_resets_the_transaction_view_state() {
+    let src = code_only(APP_JS);
+
+    // ── 派生：载荷守卫**真正依赖**的状态（不手抄名册，坑 #293 的两侧牙齿）────────────
+    let fields = object_literal_keys(&src, "txTable").expect("找不到 `txTable` 对象字面量");
+    let inputs: Vec<String> = fields.iter().map(|f| format!("txTable.{f}")).collect();
+    let evidence = names_with_prefix(&src, "txTable.loaded");
+    let sig = code_body(&src, "txQuerySig");
+    let lets = module_level_lets(&src);
+    let mut ranges: Vec<String> = identifiers(&sig)
+        .into_iter()
+        .filter(|n| lets.contains(n))
+        .collect();
+    ranges.sort();
+
+    // ── 前置：提取器必须真的看见东西（空集上的断言会假绿，坑 68）─────────────────────
+    assert!(inputs.len() >= 4, "`txTable` 只派生出 {inputs:?}");
+    assert!(
+        evidence.len() >= 3,
+        "只派生出 {evidence:?} 个 `txTable.loaded*`"
+    );
+    assert!(
+        !sig.is_empty(),
+        "找不到 `txQuerySig()` 的函数体 —— 提取器坏了"
+    );
+    assert!(
+        ranges.len() >= 3,
+        "`txQuerySig()` 读到的模块级状态只有 {ranges:?} —— 判别式太弱"
+    );
+    assert_eq!(
+        declared_literal(&src, "txTable", "page").as_deref(),
+        Some("1"),
+        "`txTable.page` 的声明默认值变了 —— 规则 3 的判别式要跟着改"
+    );
+
+    let (boundary, fns) = boundary_reset(&src);
+    assert!(!boundary.is_empty(), "找不到 `resetSessionCaches()` 的闭包");
+    // 反-吞并守卫（坑 #319/#332）：`js_function_body` 对**单行**函数会吞进下一个多行函数 ——
+    // 抽到的「证据」可能来自别的函数。多行函数下声明行数应恰等于闭包大小
+    // （若边界闭包里出现了嵌套 `function` 声明，请把这条守卫改成按名字逐个断言）。
+    assert_eq!(
+        boundary.matches("function ").count(),
+        fns.len(),
+        "边界闭包提取可疑（函数声明数 != 闭包大小）：{fns:?} —— 提取吞了别的函数，或边界里有嵌套声明"
+    );
+
+    // ── 规则 1：闭包必须复位每一个被守卫依赖的名字 ────────────────────────────────
+    for lhs in inputs.iter().chain(evidence.iter()).chain(ranges.iter()) {
+        assert!(
+            assigns_in(&boundary, lhs),
+            "身份边界没有复位 `{lhs}`（C2170）：`Live` 之外的模块级视图状态同样跨不过边界。\
+             载荷的有效性证据留下 ⇒ 守卫认一份「不存在的载荷」为已加载 ⇒ 下一位用户首帧即空表\
+             且不自愈。边界闭包 = {fns:?}"
+        );
+    }
+
+    // ── 规则 3：复位到**声明处的默认值**，不是一键清空 ────────────────────────────
+    let page = declared_literal(&src, "txTable", "page").expect("`txTable.page` 没有声明默认值");
+    let size =
+        declared_literal(&src, "txTable", "pageSize").expect("`txTable.pageSize` 没有默认值");
+    let range = declared_let_literal(&src, "txRange").expect("`txRange` 没有声明默认值");
+    for (lhs, lit) in [
+        ("txTable.page", page.as_str()),
+        ("txTable.pageSize", size.as_str()),
+        ("txRange", range.as_str()),
+    ] {
+        let want = format!("{lhs} = {lit}");
+        assert!(
+            boundary.contains(&want),
+            "复位没有回到声明处的默认值（期望 `{want}`）：清成 `undefined` 只会让 \
+             `loadTransactions()` 的 `Math.max(1, txTable.pageSize || 10)` 把每页退化到 1 行"
+        );
+    }
+
+    // ── 规则 2：有效性证据的写者只有装载器与身份边界 ──────────────────────────────
+    let graph = call_graph(&src);
+    let writers: Vec<String> = graph
+        .keys()
+        .filter(|f| {
+            let code = function_code(&src, f);
+            evidence.iter().any(|e| assigns_in(&code, e))
+        })
+        .cloned()
+        .collect();
+    let allowed: BTreeSet<String> = std::iter::once("loadTransactions".to_string())
+        .chain(fns.iter().cloned())
+        .collect();
+    let strays: Vec<&String> = writers.iter().filter(|w| !allowed.contains(*w)).collect();
+    assert!(
+        strays.is_empty(),
+        "`txTable.loaded*` 被 {strays:?} 写 —— 除装载器与身份边界外谁都不许写它：在 \
+         `renderTransactions()` 里清会把守卫每次渲染都重新武装 ⇒ 请求风暴（C2146 同形）"
+    );
+}
+
+/// C2170 提取器自证：两侧锚定、注释剥离、闭包跨函数，都要在**合成输入**上有牙齿。
+#[test]
+fn the_session_state_scanners_have_teeth() {
+    // (a) 右侧锚定：`txTable.page` 是 `txTable.pageSize` 的前缀 —— 复位了 pageSize 不算复位 page
+    assert!(
+        !assigns_in("    txTable.pageSize = 10;\n", "txTable.page"),
+        "兄弟字段被当成了证据（坑 #333）"
+    );
+    assert!(assigns_in("    txTable.page = 1;\n", "txTable.page"));
+    assert!(
+        !assigns_in("    if (txTable.page === 1) x();\n", "txTable.page"),
+        "比较被当成了赋值"
+    );
+    assert!(
+        !assigns_in("    const y = txTable.page;\n", "txTable.page"),
+        "读取被当成了赋值"
+    );
+    // (b) 左侧锚定
+    assert!(!assigns_in("    xtxTable.page = 1;\n", "txTable.page"));
+    // (c) 注释不是证据（坑 #296 的镜像：修法自己就在复位旁写了提到字段名的解释）
+    let commented = code_only(
+        "  function resetTxView() {\n    // txTable.page = 1;\n    txTable.pageSize = 10;\n  }\n",
+    );
+    assert!(!assigns_in(&commented, "txTable.page"), "注释被当成了赋值");
+    // (d) 前缀扫描不吞兄弟
+    let synth = "  a = txTable.loadedPage;\n  b = txTable.loadedPageSize;\n";
+    assert_eq!(
+        names_with_prefix(synth, "txTable.loaded"),
+        vec![
+            "txTable.loadedPage".to_string(),
+            "txTable.loadedPageSize".to_string()
+        ]
+    );
+    // (e) 闭包必须跨函数：复位写在被调用者里也算（抽 helper 是推荐写法）
+    let synth2 = concat!(
+        "  function resetSessionCaches() {\n",
+        "    Object.keys(Live).forEach((k) => { Live[k] = null; });\n",
+        "    resetTxView();\n",
+        "  }\n\n",
+        "  function resetTxView() {\n",
+        "    txTable.page = 1;\n",
+        "  }\n"
+    );
+    let (text, fns) = boundary_reset(synth2);
+    assert!(
+        fns.contains(&"resetTxView".to_string()),
+        "闭包没跨函数：{fns:?}"
+    );
+    assert!(
+        assigns_in(&text, "txTable.page"),
+        "闭包文本里读不到被调用者的赋值"
+    );
+    // (f) 模块级 `let` 只认 2 空格缩进的声明
+    assert_eq!(
+        module_level_lets("  let txRange = \"24h\";\n    let nested = 1;\n"),
+        vec!["txRange".to_string()]
+    );
+}
diff --git a/ui/README.md b/ui/README.md
index e61cc6e..163bc23 100644
--- a/ui/README.md
+++ b/ui/README.md
@@ -436,6 +436,7 @@ ui/
   1. **身份边界必须丢弃每一个槽**。会话建立（`loadSession`：boot / 登录，两者都经 `restoreSession`）与会话结束（`exitGuest`：登出 / 401）两侧都要清空。清空必须**派生自** `Live` 的对象字面量（`Object.keys(Live).forEach((k) => { Live[k] = null; })`）—— 手抄名册会在新增槽时静默漏掉。
   2. **`renderView` 的每个分支都必须「既渲染又拉取」**。它是唯一允许「先同步渲染缓存、再异步拉取」的地方，于是「只渲染不拉取」的分支就是**永远显示缓存**的分支。
   3. **边界要收拾的不只是 `#app`**（C2171）。`#app` 之外的浮层（帮助面板 / 聊天弹窗 / 首启引导）是它的**兄弟节点** ⇒ `$("#app").classList.add("hidden")` **不会**连带隐藏它们。`exitGuest()` 因此还要调 `resetSessionOverlays()`，把每个浮层交回它自己的关闭器（`toggleHelp(false)` / `closeChat()` / `closeTour()`）。元素集合由 `state_gate::the_identity_boundary_closes_the_panels_outside_the_app` 与 `ui/index.html` **派生比对**（`#app` 起始行之后的**顶行**元素、其 `class` 含独立 token `hidden`），**零豁免清单**。⚠️ **射程**：门禁是**词法**的 —— 它证明「每个派生元素各有一个宣称要隐藏它的关闭器落在边界的调用闭包内」，**不**证明运行期屏幕上真的隐藏了（那是 `c2171-probe.js` 的射程，仓内 CI 无 JS 运行器）；已知盲区＝只认顶行（列 0）元素、只认字面量 `"#<id>"`、`classList.toggle("hidden", false)` 这种带第二布尔实参的隐藏不在判别式内。
+  4. **边界清的不只是槽**（C2170）。`Live` 之外还有**模块级**的会话状态：交易视图的 `txTable`（`sort` / `filters` / `page` / `pageSize`）与 `txRange` / `txCustomStart` / `txCustomEnd` 都是模块级的，其中 `txTable.loadedPage` / `loadedPageSize` / `loadedQuerySig` 是载荷的**有效性证据** —— 证据属于载荷：载荷被清空而证据留下，守卫（`txQuerySig()` 比对）就会认一份**不存在**的载荷为「已加载」，下一位用户的首帧因此是**空表**（服务端按 `offset=(page-1)*page_size` 返回 `items: []`，而 `total` 照旧非零）且**不自愈**。`resetSessionCaches()` 因此还要调 `resetTxView()`，复位到**声明处的默认值**（含 `txTable.pageSize = 10` —— 清成 `undefined` 会让 `Math.max(1, txTable.pageSize || 10)` 的兜底把每页退化到 1 行）。名字集合由 `state_gate::the_identity_boundary_resets_the_transaction_view_state` **派生**（`txTable` 字面量的字段 + `txTable.loaded*` + `txQuerySig()` 读到的模块级 `let`），**零手抄名册**；证据的写者只允许装载器与边界闭包——否则在 `renderTransactions()` 里清会把守卫每次渲染都重新武装成**请求风暴**（C2146 同形）。
 - **修前的两张脸**（jsdom 启真 `index.html` + 四脚本、只 stub `fetch`，驱动真导航 / 真登出 / 真登录表单）：甲用完仪表盘登出、乙登录后打开钱包 —— `#wallet-forever`（「永久点数」）显示的是**甲的** `Live.wallet.balance`（实测 `4,242.42424`，乙应为 `7.5`），**且永不自愈**：`renderView("wallet")` 当时是八个分支里**唯一**只 `renderWallet()` 的，缓存不被清就再也没人刷新它。同一根因的**瞬态**脸：乙落在仪表盘时，`renderView` 先**同步**用甲的缓存渲染 `#dash-stats`（冻结乙自己的 `/api/wallet` 即可读到：本月用量是甲的 `12,345.6789`）。
 - **改法两半，缺一留红**：① `resetSessionCaches()`（派生式）在 `exitGuest()` 与 `loadSession()` 开头各调一次；② 钱包分支补上自己的 loader `loadWallet()`（镜像 `loadDashboard` 的尾段：`refreshWallet()` → `renderWallet()`）。② 顺带修掉**单会话**下的口径错 —— 此前登录后直接进钱包，`Live.wallet` 永远是 `null`，单元格只能回落到 `D.USER.balance`（= `available` = 永久 + 当日赠送）冒充「永久」。
 - **CI 覆盖**：`src/state_gate.rs` 再加两条 —— `the_identity_boundaries_drop_every_session_cache`（清空必须含 `Object.keys(Live)`；体内**不得**出现逐个槽的赋值，否则就是第二份名册；`loadSession` 与 `exitGuest` 都必须调用它）与 `the_view_router_renders_and_loads_in_every_branch`（`renderView` 每个分支行都既含 `render` 又含 `load`）。两条都带**提取器自证**与**合成输入**（手抄名册 / 缺 loader 的分支必须变红）。
diff --git a/ui/index.html b/ui/index.html
index 8c1f56e..58304f9 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -855,6 +855,6 @@ <h3 id="chat-title">使用模型</h3>
 <script src="js/api.js?v=20260914-13"></script>
 <script src="js/data.js?v=20260914-11"></script>
 <script src="js/i18n.js?v=20260921-3"></script>
-<script src="js/app.js?v=20260922-1"></script>
+<script src="js/app.js?v=20260922-2"></script>
 </body>
 </html>
diff --git a/ui/js/app.js b/ui/js/app.js
index e46218b..f125158 100644
--- a/ui/js/app.js
+++ b/ui/js/app.js
@@ -3320,6 +3320,26 @@
   // 槽名**派生自**上面那个对象字面量（新增槽自动纳入）—— 不维护第二份名册。
   function resetSessionCaches() {
     Object.keys(Live).forEach((k) => { Live[k] = null; });
+    resetTxView();
+  }
+
+  // C2170：身份边界要清的不只是 `Live` —— 交易视图的状态是**模块级**的。前四项是载荷的**输入**
+  // （`txQuerySig()` 的签名 + 页码 / 每页行数），后三项是载荷的**有效性证据**：证据属于载荷，
+  // 载荷被清空而证据留下，守卫就会认一份**不存在**的载荷为「已加载」，下一位用户的首帧因此是
+  // 空表（服务端按 `offset=(page-1)*page_size` 返回 `items: []`）且不自愈。复位取**声明处的默认
+  // 值**，不能一键清空 —— `loadTransactions()` 用 `Math.max(1, txTable.pageSize || 10)` 兜底，
+  // 清成 `undefined` 只会让每页退化到 1 行。
+  function resetTxView() {
+    txTable.sort = [];
+    txTable.filters = {};
+    txTable.page = 1;
+    txTable.pageSize = 10;
+    txTable.loadedPage = undefined;
+    txTable.loadedPageSize = undefined;
+    txTable.loadedQuerySig = undefined;
+    txRange = "24h";
+    txCustomStart = "";
+    txCustomEnd = "";
   }
 
   function loggedIn() { return !!api.getToken() && !isGuest; }