pi-patch-keeper 1.2.0 → 1.2.2

package/README.en.md

@@ -2,15 +2,17 @@
 
 > Requires pi >= 0.74 · Node >= 20 · MIT · no runtime dependencies · no PiDeck or third-party patching
 
-Checks three classes of hazards in pi's own configuration at session start: what can be fixed is fixed, the rest is reported clearly.
+## What it solves
+
+Three configuration failures happen silently: the codemode switch disagreeing with the installed guard, a force-type extension sitting mid-list (dropping every later section), and an injected manual that is older than the one on disk. None of them error — behaviour just drifts. This extension checks at startup and fixes what it can.
 
 ## Features
 
 - **codemode single-source check**: disabling `builtin:codemode` and installing `pi-codemode-guard` must agree.
-- **force-order guard**: force-type extensions (e.g. rtk / cache-optimizer) must sit last in `packages`, otherwise later section writes are silently dropped; wrong order is fixed automatically (with a backup).
-- **Environment fingerprint drift**: notifies when `settings.json` packages / defaultTools / enabledModels / extensions / codemode change, since manuals or prior verification may be stale.
-- **Injection alignment**: compares the injected `APPEND_SYSTEM.md` version with the on-disk version and, on mismatch, tells the model to trust disk.
-- Commands `/patch-keeper` (status) and `/patch-keeper fix` (repair force order).
+- **force-order guard**: force-type extensions must sit last in `packages`; wrong order is fixed automatically (with a backup).
+- **Environment fingerprint drift**: notifies when key `settings.json` fields change, since manuals or prior verification may be stale.
+- **Injection alignment**: compares injected `APPEND_SYSTEM.md` version with disk and tells the model to trust disk.
+- Commands `/patch-keeper` and `/patch-keeper fix`.
 
 ## Install
 
@@ -21,36 +23,63 @@ pi install ./pi-patch-keeper
 
 ## Configuration
 
-**No config file**: the package only reads `settings.json` and the manual.
+### 1 · Config file
 
-| Item | Path | Description |
-| --- | --- | --- |
-| Fingerprint | `~/.pi/patch-keeper.json` | Settings snapshot from the previous start, used for drift detection (self-maintained) |
-| Manual sentinel | `~/.pi/patch-keeper-manual.json` | Manual version / content signature, catches "content changed without a version bump" |
-| Fix backup | `~/.pi/agent/settings.json.bak-force-order-*` | Backup created before repairing force order |
+**None** — it only reads `settings.json` and the manual.
+
+### 2 · Environment
 
-### Commands
+None.
+
+### 3 · Commands
 
 | Command | Purpose |
 | --- | --- |
-| `/patch-keeper` | Show codemode / force / fingerprint / injection-alignment status |
+| `/patch-keeper` | codemode / force / fingerprint / injection-alignment status |
 | `/patch-keeper fix` | Repair force order in `packages` (with backup) |
 
-### Not included (local-only module)
+### 4 · State files (self-maintained)
+
+| Item | Path | Description |
+| --- | --- | --- |
+| Fingerprint | `~/.pi/patch-keeper.json` | Settings snapshot for drift detection |
+| Manual sentinel | `~/.pi/patch-keeper-manual.json` | Manual version / content signature |
+| Fix backup | `~/.pi/agent/settings.json.bak-force-order-*` | Backup before repair |
+
+### 5 · Not included (local module)
+
+PiDeck builtin patch restore, read-only asar checks, pi-lens / pi-memory / pi-tactician source patches, local snapshot restore — all depend on the PiDeck install directory, third-party internals or local paths, so they are **not shipped**; a local module `patch-keeper-local` provides them (`/patch-keeper-local`).
+
+## Where it acts (prompt and config paths)
+
+| Stage | Does |
+| --- | --- |
+| factory (startup) | Fingerprint compare, force self-check and auto-repair; failures only notify |
+| `session_start` | Summarises drift / order / manual drift in one notification |
+| `before_agent_start` | Compares injected manual version with disk (**read-only**, never rewrites the prompt) |
+
+It never touches thinking or tool calls: it acts on the **system prompt and configuration state**.
 
-PiDeck builtin patch restoration, read-only asar checks, pi-lens / pi-memory / pi-tactician source patches, local snapshot restore — all depend on the PiDeck install directory, third-party internals or local paths, so they are **not shipped** with this package. They live in a local module `patch-keeper-local` (`/patch-keeper-local`).
+## Feedback path
+
+| Item | Path | Why |
+| --- | --- | --- |
+| Injection-alignment hint | User notification + trailing message `nextTurn`, `display:false` | The user already knows; the model must too, otherwise "use the disk version" stops at the user side |
+| Alignment text | "injected vX != disk vY -> injected is not evidence; action: read disk and continue" | Gives both criterion and action |
+| Never returns systemPrompt | Only its own section / message | Returning it replaces the whole prompt (`forceSystemPrompt`) and silently drops every later section |
+| Drift / force problems | Notification only (once per `session_start`) | Low-frequency information |
 
 ## How it works
 
-- On factory startup it compares fingerprints and self-checks force order; failures only notify, never throw or disturb the session.
-- Injection alignment compares versions in `before_agent_start` and only writes its own notification and trailing message; it **never returns systemPrompt** (which would replace the whole prompt and drop other sections).
-- All writes are atomic (temp file + rename).
+- All writes are atomic (temp file + rename); a backup precedes any repair.
+- Force repair moves known force-type packages to the end, preserving the rest.
+- Manual drift uses version + content signature, so unversioned content edits are caught.
 
 ## Limitations
 
-- Covers pi's own configuration only, not third-party plugin behaviour.
-- Force-order repair targets a built-in list of known force-type packages.
-- Fingerprint drift reports what changed, not whether the new value is correct.
+- Covers pi's own configuration only.
+- Force repair relies on a built-in known-force list.
+- Drift reports what changed, not whether the new value is right.
 
 ## License
 

package/README.md

@@ -2,15 +2,17 @@
 
 > 适用 pi ≥ 0.74 · Node ≥ 20 · MIT · 无运行时依赖 · 不含 PiDeck / 第三方补丁
 
-在每次会话启动时检查 pi 自身配置的三类隐患，能修的直接修，不能修的明确报出来。
+## 它解决什么问题
+
+pi 的配置有三类静默失效：codemode 开关与插件不一致、force 型扩展排在中途导致其后 section 被丢弃、注入的手册与磁盘版本不同步。它们都不会报错，只会让行为悄悄偏离。本扩展在启动时检查并在能修时自动修。
 
 ## 功能
 
 - **codemode 单点一致性**：禁 `builtin:codemode` 与安装 `pi-codemode-guard` 必须同时成立。
-- **force 顺序守卫**：force 型扩展（如 rtk / cache-optimizer）必须排在 `packages` 末尾，否则其后的 section 写入会被静默丢弃；发现乱序自动修复（先备份）。
-- **环境指纹漂移**：`settings.json` 的 packages / defaultTools / enabledModels / extensions / codemode 变化时提示「手册或上轮验证结论可能过期」。
-- **注入对齐**：比对注入的 `APPEND_SYSTEM.md` 版本与磁盘版本，不一致时提示「以磁盘版为准」，并同步回灌模型。
-- 命令 `/patch-keeper` 查看全部状态，`/patch-keeper fix` 修复 force 顺序。
+- **force 顺序守卫**：force 型扩展必须排在 `packages` 末尾，乱序自动修复（先备份）。
+- **环境指纹漂移**：`settings.json` 的关键字段变化时提示「手册或验证结论可能过期」。
+- **注入对齐**：比对注入的 `APPEND_SYSTEM.md` 版本与磁盘版本，不一致时按磁盘版执行。
+- 命令 `/patch-keeper` / `/patch-keeper fix`。
 
 ## 安装
 
@@ -21,36 +23,63 @@ pi install ./pi-patch-keeper
 
 ## 配置
 
-**无配置文件**：本包只读 `settings.json` 与手册，不引入自己的配置项。
+### 1 · 配置文件
 
-| 项 | 路径 | 说明 |
-| --- | --- | --- |
-| 环境指纹 | `~/.pi/patch-keeper.json` | 上次启动时的配置快照，用于漂移对比（自动维护） |
-| 手册哨兵 | `~/.pi/patch-keeper-manual.json` | 手册版本 / 内容签名，用于检测「改了内容没升版本」 |
-| 自动修复备份 | `~/.pi/agent/settings.json.bak-force-order-*` | 修复 force 顺序前的备份 |
+**无配置文件**：本包只读 `settings.json` 与手册，不引入自己的键。
+
+### 2 · 环境变量
 
-### 命令
+无。
+
+### 3 · 命令
 
 | 命令 | 作用 |
 | --- | --- |
-| `/patch-keeper` | 输出 codemode / force / 指纹 / 注入对齐状态 |
+| `/patch-keeper` | codemode / force / 指纹 / 注入对齐状态 |
 | `/patch-keeper fix` | 修复 `packages` 的 force 顺序（带备份） |
 
-### 不包含（本机专用模块）
+### 4 · 状态文件（自动维护）
+
+| 项 | 路径 | 说明 |
+| --- | --- | --- |
+| 环境指纹 | `~/.pi/patch-keeper.json` | 上次启动的配置快照，用于漂移对比 |
+| 手册哨兵 | `~/.pi/patch-keeper-manual.json` | 手册版本 / 内容签名，抓「改了内容没升版本」 |
+| 修复备份 | `~/.pi/agent/settings.json.bak-force-order-*` | 修复前备份 |
+
+### 5 · 不包含（本机模块）
+
+PiDeck builtin 补丁双份恢复、asar 只读检测、pi-lens / pi-memory / pi-tactician 源码补丁、本机快照恢复 —— 依赖 PiDeck 安装目录、第三方包内部实现与本机路径，**不随本包发布**；由本机模块 `patch-keeper-local` 提供（`/patch-keeper-local`）。
+
+## 作用点（配置与提示通路）
+
+| 阶段 | 做什么 |
+| --- | --- |
+| factory（启动） | 指纹对比、force 自检与自动修复；失败只提示 |
+| `session_start` | 汇总漂移 / 顺序 / 手册漂移，一次通知 |
+| `before_agent_start` | 比对注入手册版本与磁盘版本（**只读**，不改 prompt） |
+
+它不碰 thinking，也不碰工具调用：作用的是**系统提示与配置状态**。
 
-PiDeck builtin 补丁双份恢复、asar 只读检测、pi-lens / pi-memory / pi-tactician 源码补丁、本机快照恢复 —— 这些依赖 PiDeck 安装目录、第三方包内部实现与本机路径，**不随本包发布**，由本机模块 `patch-keeper-local` 提供，命令 `/patch-keeper-local`。
+## 回灌（反馈回到模型的通路）
+
+| 项 | 通路 | 设计理由 |
+| --- | --- | --- |
+| 注入对齐提示 | 通知用户 + 尾部消息 `nextTurn`、`display:false` | 用户已收到通知，模型也必须知道，否则「以磁盘版执行」只停在用户侧 |
+| 注入对齐文本 | 「注入 vX ≠ 磁盘 vY → 注入版不可作判断依据；动作：读回全文后执行」 | 给出判据与动作，而不是只报事实 |
+| 绝不返回 systemPrompt | 只写自己的 section / 消息 | 返回即 forceSystemPrompt **覆盖式替换**，会静默丢弃其后所有 section 的修改 |
+| 指纹漂移 / force 问题 | 仅通知（`session_start` 一次） | 低频信息，不需要每轮打扰 |
 
 ## 机制
 
-- 启动时（factory）执行指纹对比与 force 自检；失败只提示，绝不抛错、不影响会话。
-- 注入对齐在 `before_agent_start` 比较版本，只写自己的通知与尾部消息，**绝不返回 systemPrompt**（避免覆盖式替换丢掉其他 section）。
-- 所有写盘走「临时文件 + rename」原子写。
+- 所有写盘走「临时文件 + rename」原子写；修复前留备份。
+- force 顺序修复只移动已知 force 型包到末尾，其余相对顺序不变。
+- 手册漂移用「版本号 + 内容签名」双判据，避免只看版本号漏掉未登记的正文改动。
 
 ## 限制
 
-- 只覆盖 pi 自身配置；不检查第三方插件行为。
-- force 顺序修复只对已知的 force 型包生效（列表内置，随版本更新）。
-- 指纹对比只报「变了什么」，不判断新值是否正确。
+- 只覆盖 pi 自身配置，不检查第三方插件行为。
+- force 修复依赖内置的 known-force 列表（随版本更新）。
+- 指纹只报「变了什么」，不判断新值是否正确。
 
 ## License
 

package/index.ts

@@ -1,65 +1,35 @@
 /**
- * patch-keeper —— 补丁自愈与状态检测（pi 扩展，外置 · 模块化 · 抗上游升级）
+ * patch-keeper（发布版 · 纯 pi）—— 只看 pi 自身配置：不碰 PiDeck、不改第三方源码、不读本机快照。
  *
- * ## 为什么存在
- * 本机对「别人的东西」的全部改动登记在快照 `05-脚本补丁/PATCH-REGISTRY.md`（唯一权威清单）：
- * PiDeck app.asar ×3（只检测）、npm 包 ×2（pi-lens / pi-memory，自愈）、PiDeck builtin ×5（双份自愈）、
- * npm 包注入通道 ×2（pi-memory / tactician 改 section）。
- * 上游一升级就覆盖，得重跑桌面上的补丁脚本 —— 容易忘。这个扩展把它变成自愈：
- * 每次 pi 启动时检查一遍，能修的直接修，不能修的（PiDeck 正开着，asar 被锁）明确报出来。
- *
- * ## 为什么能修 pi-lens
- * pi 的资源加载有优先级（dist/core/package-manager.js resourcePrecedenceRank）：
- *   0/1 project · 2/3 user（本扩展）· 4 package（pi-lens）· 5 builtin
- * 本扩展是「user 扩展」= rank 2，pi-lens 是「package 扩展」= rank 4，**先加载**。
- * 所以在 factory 里同步改 dist/index.js，pi-lens 随后 import 到的就是打过补丁的内容 —— 当轮生效。
- *
- * ## 边界（刻意的）
- * - PiDeck asar：**只检测不修**。PiDeck 正开着，文件被锁；且插件无权碰 Electron 主进程。
- *   检测到未打补丁 → 提示跑 `run-all.cmd` / `launch-pideck.cmd`（桌面 PI脚本补丁/ 不在时用快照副本 05-脚本补丁/）。
- * - 任何失败都只 notify，不抛错、不影响会话（纪律：不合法就跳过 + 记日志，绝不崩溃）。
+ * 职责：codemode 单点一致性 · force 顺序守卫（可自动修复）· 环境指纹漂移 · 注入对齐（手册版本）。
+ * 依赖 PiDeck / 第三方包源码 / 本机快照的部分在 patch-keeper-local（不发布）。
  */
+
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { existsSync, readFileSync, writeFileSync, copyFileSync, readdirSync, renameSync } from "node:fs";
-import { createHash } from "node:crypto";
+
+import { existsSync, readFileSync, writeFileSync, copyFileSync, renameSync } from "node:fs";
+
 import * as os from "node:os";
+
 import * as path from "node:path";
 
-// 路径从 home / %LOCALAPPDATA% 推导（不写死用户名：换机 / 换用户名 / 复刻包到别的机器仍可用）
 const HOME = os.homedir();
-const LOCALAPPDATA = process.env.LOCALAPPDATA ?? path.join(HOME, "AppData", "Local");
-const PI_LENS = path.join(HOME, ".pi", "agent", "npm", "node_modules", "pi-lens", "dist", "index.js");
-const PI_MEMORY = path.join(HOME, ".pi", "agent", "npm", "node_modules", "pi-memory", "index.ts");
-const ASAR = path.join(LOCALAPPDATA, "Programs", "PiDeck", "resources", "app.asar");
-// 唯一处置入口：快照 05-脚本补丁/（桌面旧目录 PI脚本补丁/ 已不存在，2026-10-15 核实）
-const SNAPSHOT_PATCH_DIR = path.join(HOME, "Desktop", "pi-env-snapshot", "05-脚本补丁");
-// 自建扩展保护：发布精简版覆盖自愈版时（2026-10-18 实证）从快照恢复
-const SELF_EXT = path.join(HOME, ".pi", "agent", "extensions", "patch-keeper", "index.ts");
-const SELF_SNAP = path.join(HOME, "Desktop", "pi-env-snapshot", "01-pi核心配置", "extensions", "patch-keeper", "index.ts");
-const SELF_MARK = "SNAPSHOT_PATCH_DIR"; // 自愈版特征：发布精简版没有这行
-// 环境指纹文件（settings 关键字段，用于漂移检测）
+
 const FINGERPRINT = path.join(HOME, ".pi", "patch-keeper.json");
+
 const SETTINGS = path.join(HOME, ".pi", "agent", "settings.json");
 // 手册（注入对齐检测：本轮注入文本的版本行 vs 磁盘版）
+
 const MANUAL = path.join(HOME, ".pi", "agent", "APPEND_SYSTEM.md");
 
-// PiDeck 内置扩展补丁（本机修改；升级会覆盖，缺失时提示从快照恢复）
-const PIDECK_BUILTIN = path.join(HOME, "AppData", "Roaming", "PiDeck", "builtin-extensions");
-const PIDECK_INSTALL = path.join(process.env.LOCALAPPDATA ?? path.join(HOME, "AppData", "Local"), "Programs", "PiDeck", "resources", "extensions");
-// needle = 本机修复特征串（不是 section 名）：命中即视为已打；升级覆盖后从快照恢复。
-const BUILTIN_PATCHES: Array<{ file: string; install: string; needle: string; name: string }> = [
-  { file: path.join(PIDECK_BUILTIN, "pi-deck-security-gate.ts"), install: path.join(PIDECK_INSTALL, "pi-deck-security-gate.ts"), needle: "越界操作先说明理由", name: "security-gate" },
-  { file: path.join(PIDECK_BUILTIN, "pi-deck-plan-mode.ts"), install: path.join(PIDECK_INSTALL, "pi-deck-plan-mode.ts"), needle: "keepThirdParty", name: "plan-mode" },
-  { file: path.join(PIDECK_BUILTIN, "pi-deck-goal-mode.ts"), install: path.join(PIDECK_INSTALL, "pi-deck-goal-mode.ts"), needle: "roundLine", name: "goal-mode" },
-  { file: path.join(PIDECK_BUILTIN, "pi-deck-trash-guard.ts"), install: path.join(PIDECK_INSTALL, "pi-deck-trash-guard.ts"), needle: "deleteFlagStyle", name: "trash-guard" },
-  { file: path.join(PIDECK_BUILTIN, "pi-deck-session-title.ts"), install: path.join(PIDECK_INSTALL, "pi-deck-session-title.ts"), needle: "TITLE_SOURCE_MARKER_HEAD", name: "session-title" },
-];
-const SNAPSHOT_BUILTIN = path.join(HOME, "Desktop", "pi-env-snapshot", "03-PiDeck", "builtin-extensions");
+
 const MANUAL_STATE = path.join(HOME, ".pi", "patch-keeper-manual.json");
+
 /**
  * 从手册文本里取版本号（标题「自主工作手册」后 200 字符内的第一个 vNN.NN）。
  * 取不到返回 null（注入文本若不含标题即静默跳过，绝不猜）。
  */
+
 function manualVer(text: string): string | null {
   const i = text.indexOf("自主工作手册");
   if (i < 0) return null;
@@ -67,126 +37,10 @@ function manualVer(text: string): string | null {
   return m ? m[1] : null;
 }
 
-// ── pi-lens word index 补丁：两处替换（与 patches/pi-lens-wordindex-patch.js 同源）
-const A1_FROM = "    warmWordIndexes.set(key4, entry);\n  }\n  entry.leases++;";
-const A1_MARK = "if (entry && !entry.index) {";
-const A1_TO = "    warmWordIndexes.set(key4, entry);\n  }\n  if (entry && !entry.index) {\n    const late = deserializeWordIndex(loadProjectSnapshot(key4)?.wordIndex) ?? void 0;\n    if (late?.forward) entry.index = late;\n  }\n  entry.leases++;";
-const A2_FROM = "if (!snapshot.wordIndex && existing.wordIndex && existing.seq === snapshot.seq && (snapshot.incomplete || !existing.incomplete)) {";
-const A2_MARK = "existing.wordIndex && (snapshot.incomplete";
-const A2_TO = "if (!snapshot.wordIndex && existing.wordIndex && (snapshot.incomplete || !existing.incomplete)) {";
-// 上游修复标记（#4583 / PR #4586）：build 完成即推送 warm cache；出现即停打 A 补丁（与 patches/pi-lens-wordindex-patch.js 同源）
-const UPSTREAM_MARK = "warm_cache_adopted";
-
-
-// ── pi-memory exit summary 空行规范化补丁（幂等；与 pi-memory/index.ts 内已打状态一致）
-const ME_MARK = "normalizeExitSummaryMarkdown";
-const ME_FROM_FN = "function formatExitSummaryEntry(";
-const ME_FROM_RET = 'header, "", summary.trim()].join("\\n");';
-const ME_TO_RET = 'header, "", normalizeExitSummaryMarkdown(summary.trim())].join("\\n");';
-const ME_FN = ['/**', ' * 规范 exit summary 的块级空行（MD022 / MD032：标题 / 列表前后须空行）；代码围栏内不动。', ' */', 'function normalizeExitSummaryMarkdown(text: string): string {', '\tconst lines = text.split(/\\r?\\n/);', '\tconst out: string[] = [];', '\tconst isFence = (l: string) => /^\\s*(\\x60{3,}|~{3,})/.test(l);', '\tconst isHeading = (l: string) => /^#{1,6}\\s/.test(l);', '\tconst isList = (l: string) => /^\\s*(?:[-*+]|\\d+\\.)\\s/.test(l);', '\tlet inFence = false;', '\tfor (const line of lines) {', '\t\tconst fenceLine = isFence(line);', '\t\tif (fenceLine) inFence = !inFence;', '\t\tconst prev = out.length ? out[out.length - 1] : "";', '\t\tif (!fenceLine && !inFence && prev !== "") {', '\t\t\tconst startsBlock = (isHeading(line) || isList(line)) && !(isList(line) && isList(prev));', '\t\t\tconst afterBlock = isHeading(prev) || (isList(prev) && !isList(line));', '\t\t\tif (startsBlock || afterBlock) out.push("");', '\t\t}', '\t\tout.push(line);', '\t}', '\treturn out.join("\\n");', '}'].join("\n");
-const MEM_SECTION_MARK = 'sections["pi_memory"]';
-const MEM_SECTION_ANCHOR = [
-	"\t\treturn {",
-	"\t\t\tsystemPrompt: event.systemPrompt + headerLines.join(\"\\n\"),",
-	"\t\t};",
-].join("\n");
-const MEM_SECTION_BLOCK = [
-	"\t\t// R7：有 sections 的宿主优先写 section —— 返回 systemPrompt 是 force 覆盖，",
-	"\t\t// 会丢弃其后（builtin 组）goal / plan / security 的 section 写入",
-	"\t\t// （2026-10-17 实证：goal 的 Objective 与 Rules 从 system 消失，只剩 Round 消息）。",
-	"\t\tconst sections = (event as { systemPromptOptions?: { sections?: Record<string, string> } }).systemPromptOptions?.sections;",
-	"\t\tif (sections) {",
-	"\t\t\tsections[\"pi_memory\"] = headerLines.join(\"\\n\").replace(/^\\n+/, \"\");",
-	"\t\t\treturn;",
-	"\t\t}",
-	"\t\treturn {",
-	"\t\t\tsystemPrompt: event.systemPrompt + headerLines.join(\"\\n\"),",
-	"\t\t};",
-].join("\n");
-const TACT = path.join(HOME, ".pi", "agent", "npm", "node_modules", "@khanhicetea", "pi-tactician", "src", "index.ts");
-const TACT_MARK = 'sections["tactician"]';
-const TACT_ANCHOR = [
-	"\t\tif (event.systemPrompt.includes(GUIDANCE_MARKER)) return;",
-	"\t\treturn { systemPrompt: `${event.systemPrompt}\\n\\n${TACTICIAN_GUIDANCE}` };",
-].join("\n");
-const TACT_BLOCK = [
-	"\t\t// R7b：有 sections 的宿主写 section（不 force）——force 会让其后 builtin 组",
-	"\t\t// （goal / plan / security）的 section 写入被整组丢弃（2026-10-17 实证）。",
-	"\t\tconst sections = (event as { systemPromptOptions?: { sections?: Record<string, string> } }).systemPromptOptions?.sections;",
-	"\t\tif (sections) {",
-	"\t\t\tsections[\"tactician\"] = TACTICIAN_GUIDANCE;",
-	"\t\t\treturn;",
-	"\t\t}",
-	"\t\tif (event.systemPrompt.includes(GUIDANCE_MARKER)) return;",
-	"\t\treturn { systemPrompt: `${event.systemPrompt}\\n\\n${TACTICIAN_GUIDANCE}` };",
-].join("\n");
-
-/** pi-memory 状态：done / none。 */
-function piMemoryState(src: string): "done" | "none" {
-  return src.includes(ME_MARK) ? "done" : "none";
-}
-
-/** 打/补 pi-memory exit summary 规范化（幂等）。 */
-function healPiMemory(): Result {
-  if (!existsSync(PI_MEMORY)) return { ok: false, detail: "pi-memory/index.ts 不存在（未安装？）" };
-  const src = safeRead(PI_MEMORY);
-  if (src === null) return { ok: false, detail: "读取失败" };
-  if (piMemoryState(src) === "done") return { ok: true, detail: "已是最新（无需动作）" };
-  if (!src.includes(ME_FROM_FN) || !src.includes(ME_FROM_RET)) return { ok: false, detail: "锚点未找到（版本变化？）—— 需人工确认" };
-  let next = src.replace(ME_FROM_RET, ME_TO_RET);
-  next = next.replace(ME_FROM_FN, ME_FN + "\n\n" + ME_FROM_FN);
-  if (!next.includes(ME_MARK) || next === src) return { ok: false, detail: "打补丁失败（结果校验不通过）" };
-  try {
-    const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-    const bak = `${PI_MEMORY}.bak-exitsummary-${stamp}`;
-    if (!existsSync(bak)) copyFileSync(PI_MEMORY, bak);
-    writeAtomic(PI_MEMORY, next);
-  } catch (e) { return { ok: false, detail: `写入失败：${(e as Error).message}` }; }
-  return { ok: true, detail: "已自动修补（exit summary 空行规范化）—— 本轮即生效" };
-}
-/** R7：memory 段改 section（防 force 吞掉其后 builtin 组的 section）。 */
-function healMemorySection(): Result {
-  if (!existsSync(PI_MEMORY)) return { ok: false, detail: "pi-memory/index.ts 不存在（未安装？）" };
-  const src = safeRead(PI_MEMORY);
-  if (src === null) return { ok: false, detail: "读取失败" };
-  if (src.includes(MEM_SECTION_MARK)) return { ok: true, detail: "已是最新（无需动作）" };
-  if (!src.includes(MEM_SECTION_ANCHOR)) return { ok: false, detail: "锚点未找到（版本变化？）—— 需人工确认" };
-  const next = src.replace(MEM_SECTION_ANCHOR, MEM_SECTION_BLOCK);
-  if (!next.includes(MEM_SECTION_MARK) || next === src) return { ok: false, detail: "打补丁失败（结果校验不通过）" };
-  try {
-    const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-    const bak = `${PI_MEMORY}.bak-memsec-${stamp}`;
-    if (!existsSync(bak)) copyFileSync(PI_MEMORY, bak);
-    writeAtomic(PI_MEMORY, next);
-  } catch (e) { return { ok: false, detail: `写入失败：${(e as Error).message}` }; }
-  return { ok: true, detail: "已自动修补（memory 段改 section）—— 重启后生效" };
-}
-/** R7b：tactician 改 section（防 force 吞掉其后 builtin 组的 section）。 */
-function healTactician(): Result {
-  if (!existsSync(TACT)) return { ok: false, detail: "pi-tactician/src/index.ts 不存在（未安装？）" };
-  const src = safeRead(TACT);
-  if (src === null) return { ok: false, detail: "读取失败" };
-  if (src.includes(TACT_MARK)) return { ok: true, detail: "已是最新（无需动作）" };
-  if (!src.includes(TACT_ANCHOR)) return { ok: false, detail: "锚点未找到（版本变化？）—— 需人工确认" };
-  const next = src.replace(TACT_ANCHOR, TACT_BLOCK);
-  if (!next.includes(TACT_MARK) || next === src) return { ok: false, detail: "打补丁失败（结果校验不通过）" };
-  try {
-    const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-    const bak = `${TACT}.bak-tactician-${stamp}`;
-    if (!existsSync(bak)) copyFileSync(TACT, bak);
-    writeAtomic(TACT, next);
-  } catch (e) { return { ok: false, detail: `写入失败：${(e as Error).message}` }; }
-  return { ok: true, detail: "已自动修补（tactician 改 section）—— 重启后生效" };
-}
-// ── PiDeck asar 补丁：只读检测（needle 出现次数）
-const ASAR_CHECKS: Array<{ name: string; needle: string; expected: number }> = [
-  { name: "history-race", needle: "runtime.tab.runtimeGeneration !== runtimeGeneration", expected: 8 },
-  { name: "katex", needle: "singleDollarTextMath: !0", expected: 0 },
-  { name: "noise", needle: "appLogger.warn(\"app\", \"Main window renderer console error\"", expected: 0 },
-];
 
 type Result = { ok: boolean; detail: string };
 
+
 /** 读文件；失败返回 null（永不抛）。 */
 function safeRead(p: string): string | null {
   try { return readFileSync(p, "utf8"); } catch { return null; }
@@ -206,105 +60,7 @@ function count(hay: string, needle: string): number {
   return n;
 }
 
-/** pi-lens 状态：both / partial / none / missing。 */
-export function piLensState(src: string): { state: "upstream" | "both" | "partial" | "none"; a1: boolean; a2: boolean } {
-  const upstream = src.includes(UPSTREAM_MARK); // 上游已修 #4583：A 无需本机补丁
-  const a1 = src.includes(A1_MARK);
-  const a2 = !src.includes(A2_FROM) && src.includes(A2_MARK);
-  let state: "upstream" | "both" | "partial" | "none" = "none";
-  if (upstream) state = "upstream";
-  else if (a1 && a2) state = "both";
-  else if (a1 || a2) state = "partial";
-  return { state, a1, a2 };
-}
-
-/** 只在未打或半打时修补 pi-lens（幂等）。 */
-function healPiLens(): Result {
-  if (!existsSync(PI_LENS)) return { ok: false, detail: "pi-lens dist 不存在（未安装？）" };
-  const src = safeRead(PI_LENS);
-  if (src === null) return { ok: false, detail: "读取失败" };
-  const { state, a1, a2 } = piLensState(src);
-  if (state === "both") return { ok: true, detail: "已是最新（无需动作）" };
-  if (state === "upstream" && a2) return { ok: true, detail: "上游已修复 #4583（B 已打，无需动作）" };
-  let next = src;
-  // 半打状态先还原，再整体重打（避免只打一半造成新的不一致）
-  if (a2 && !a1) next = next.replace(A2_TO, A2_FROM); // 半打：先把 B 还原，再由下面两步整体重打
-  if (state !== "upstream" && !next.includes(A1_MARK)) next = next.replace(A1_FROM, A1_TO);
-  if (next.includes(A2_FROM)) next = next.replace(A2_FROM, A2_TO);
-  const after = piLensState(next);
-  if (after.state !== "both" && after.state !== "upstream") return { ok: false, detail: `打补丁失败（结果 ${after.state}，锚点可能已随版本变化）` };
-  try {
-    const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-    const bak = `${PI_LENS}.bak-wordindex-${stamp}`;
-    if (!existsSync(bak)) copyFileSync(PI_LENS, bak);
-    writeAtomic(PI_LENS, next);
-  } catch (e) { return { ok: false, detail: `写入失败：${(e as Error).message}` }; }
-  return { ok: true, detail: state === "upstream" ? `上游已修复 #4583 —— 跳过 A，仅补 B${a1 ? "（A 残留，建议 npm 重装清除）" : ""}` : `已自动修补（原状态 ${state}）—— 本轮即生效` };
-}
-
-
-/** 记忆文件格式规范化（压连续空行 + 单尾换行；围栏内不动）。 */
-function normMd(txt: string): string {
-  const lines = txt.split(/\r?\n/);
-  const out: string[] = [];
-  let inFence = false;
-  for (const line of lines) {
-    const isF = /^\s*(?:`{3,}|~{3,})/.test(line);
-    if (isF) inFence = !inFence;
-    if (!inFence && line.trim() === "" && out.length > 0 && out[out.length - 1].trim() === "") continue;
-    out.push(line);
-  }
-  while (out.length > 0 && out[out.length - 1].trim() === "") out.pop();
-  return out.join("\n") + "\n";
-}
 
-/** 第 3 处自愈：memory_write 每次写入都会引入 MD012/MD047（同日复发 3 次后机制化）——启动即规范。 */
-function healMemoryFormat(): Result {
-  try {
-    const dir = path.join(HOME, ".pi", "agent", "memory");
-    if (!existsSync(dir)) return { ok: true, detail: "memory 目录不存在（跳过）" };
-    let fixed = 0;
-    const walk = (d: string): void => {
-      for (const e of readdirSync(d, { withFileTypes: true })) {
-        const p = path.join(d, e.name);
-        if (e.isDirectory()) { if (e.name !== ".git") walk(p); continue; }
-        if (!e.name.endsWith(".md")) continue;
-        const txt = safeRead(p);
-        if (txt === null) continue;
-        const norm = normMd(txt);
-        if (norm !== txt) { try { writeAtomic(p, norm); fixed += 1; } catch { /* 静默 */ } }
-      }
-    };
-    walk(dir);
-    return { ok: true, detail: fixed > 0 ? `已规范化 ${fixed} 个记忆文件（空行 / 尾换行）` : "记忆格式无需动作" };
-  } catch (e) { return { ok: false, detail: (e as Error).message }; }
-}
-/** PiDeck asar：只读检测，返回未打补丁的项名。 */
-let asarOk = false;
-/** 未打补丁时的处置提示（纯函数，便于单测）。 */
-function patchTip(lines: string[]): string {
-  if (!lines.some((l) => l.includes("未打") || l.includes("半打"))) return "";
-  const dir = existsSync(SNAPSHOT_PATCH_DIR) ? SNAPSHOT_PATCH_DIR : "pi-env-snapshot/05-脚本补丁/（也未找到）";
-  return ` → PiDeck 补丁需退出 PiDeck 后重跑补丁脚本（快照副本：${dir}；或用其中的 launch-pideck.cmd 启动 PiDeck 时自动重打）`;
-}
-
-
-function checkAsar(): { ran: boolean; missing: string[]; detail: string } {
-  if (asarOk) return { ran: true, missing: [], detail: "三个补丁都在" };
-  if (!existsSync(ASAR)) return { ran: false, missing: [], detail: "app.asar 不存在" };
-  let buf: Buffer;
-  try { buf = readFileSync(ASAR); } catch (e) { return { ran: false, missing: [], detail: `读取失败：${(e as NodeJS.ErrnoException).code ?? (e as Error).message}` }; }
-  const txt = buf.toString("utf8");
-  const missing: string[] = [];
-  for (const c of ASAR_CHECKS) {
-    const n = count(txt, c.needle);
-    if (n !== c.expected) missing.push(`${c.name}(=${n}, 期望 ${c.expected})`);
-  }
-  if (!missing.length) asarOk = true; // 只在通过时缓存：缺失时每次都实测，便于打完补丁后立刻复检
-  return { ran: true, missing, detail: missing.length ? `未打补丁：${missing.join(" ")}` : "三个补丁都在" };
-}
-
-/** 汇总报告（给命令与启动提示共用）。 */
 // ── 环境指纹：settings 关键字段漂移 → 提示「手册 / 验证结论可能过期」
 function fingerprint(): Record<string, string[]> | null {
   const txt = safeRead(SETTINGS);
@@ -350,24 +106,6 @@ export function consistencyCheck(exts: string[], pkgs: string[]): string[] {
 }
 
 
-function restoreBuiltinPatches(): string | null {
-  const out: string[] = [];
-  for (const bp of BUILTIN_PATCHES) {
-    for (const target of [bp.install, bp.file]) {
-      if (!existsSync(target)) continue; // 未装 PiDeck / 路径不同：跳过，不算缺失
-      const cur = safeRead(target);
-      if (cur !== null && cur.includes(bp.needle)) continue;
-      const snap = path.join(SNAPSHOT_BUILTIN, path.basename(target));
-      if (!existsSync(snap)) { out.push(`${bp.name}: 缺补丁且快照无副本`); continue; }
-      try {
-        if (cur !== null) copyFileSync(target, `${target}.bak-restore-${Date.now()}`);
-        copyFileSync(snap, target);
-        out.push(`${bp.name}（${target === bp.install ? "安装目录" : "用户层"}）: 已从快照恢复`);
-      } catch (e) { out.push(`${bp.name}: 恢复失败（${(e as Error).message}）`); }
-    }
-  }
-  return out.length ? out.join("；") : null;
-}
 
 /** 手册内容漂移：版本号未变但正文变了（只比版本号会漏）。 */
 function manualDrift(): string | null {
@@ -466,121 +204,37 @@ export function scanForceFallbacks(packages: string[]): string[] {
   return classifyPackages(packages).fallback;
 }
 
-/** 自建扩展保护：本地 patch-keeper 被发布精简版覆盖时，从快照恢复（幂等）。 */
-function healSelfExtension(): Result {
-  if (!existsSync(SELF_EXT)) return { ok: false, detail: "本地 patch-keeper 不存在" };
-  const src = safeRead(SELF_EXT);
-  if (src === null) return { ok: false, detail: "读取失败" };
-  if (src.includes(SELF_MARK)) return { ok: true, detail: "自愈版完好（无需动作）" };
-  if (!existsSync(SELF_SNAP)) return { ok: false, detail: "疑似被发布精简版覆盖，快照缺失 —— 需人工恢复" };
-  const snap = safeRead(SELF_SNAP);
-  if (snap === null || !snap.includes(SELF_MARK)) return { ok: false, detail: "快照不含自愈版 —— 需人工确认" };
-  try {
-    const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-    const bak = `${SELF_EXT}.bak-overwrite-${stamp}`;
-    if (!existsSync(bak)) copyFileSync(SELF_EXT, bak);
-    writeAtomic(SELF_EXT, snap);
-  } catch (e) { return { ok: false, detail: `恢复失败：${(e as Error).message}` }; }
-  return { ok: true, detail: "疑似被发布精简版覆盖 —— 已从快照恢复（重启后生效）" };
-}
+
 function report(): string[] {
   const lines: string[] = [];
-  const lensSrc = safeRead(PI_LENS);
-  if (lensSrc === null) lines.push("pi-lens : 读不到 dist/index.js");
-  else {
-    const st = piLensState(lensSrc);
-    let label = `半打（A=${st.a1} B=${st.a2}）`;
-    if (st.state === "upstream") label = `上游已修复 #4583（B=${st.a2 ? "已打" : "未打"}；A 无需补丁）`;
-    else if (st.state === "both") label = "已打（A+B）";
-    else if (st.state === "none") label = "未打";
-    lines.push(`pi-lens : ${label}`);
-  }
-  const memSrc = safeRead(PI_MEMORY);
-  if (memSrc === null) lines.push("pi-memory: 读不到 index.ts");
-  else lines.push(`pi-memory: ${memSrc.includes(ME_MARK) ? "已打（exit summary 空行规范化）" : "未打"} · ${memSrc.includes(MEM_SECTION_MARK) ? "已打（section 优先）" : "未打（section 优先）"}`);
-  const tactSrc = safeRead(TACT);
-  lines.push(`tactician: ${tactSrc === null ? "读不到" : tactSrc.includes(TACT_MARK) ? "已打（section 优先）" : "未打（section 优先）"}`);
-  lines.push(`自建扩展: ${safeRead(SELF_EXT)?.includes(SELF_MARK) ? "自愈版" : "疑似被覆盖（跑 /patch-keeper fix）"}`);
-  const asar = checkAsar();
-  lines.push(`PiDeck  : ${asar.detail}`);
-  for (const bp of BUILTIN_PATCHES) {
-    const st = (p: string): string => { const src = safeRead(p); return src === null ? "无" : src.includes(bp.needle) ? "已打" : "未打"; };
-    lines.push(`builtin  : ${bp.name} 生效版=${st(bp.install)} 用户层=${st(bp.file)}`);
-  }
   const fp = fingerprint();
   const cm = fp ? consistencyCheck(fp.extensions, fp.packages) : [];
-  let cmLabel = "读不到 settings";
-  if (fp) cmLabel = cm.length ? cm[0] : "单点一致";
-  lines.push(`codemode : ${cmLabel}`);
+  lines.push("codemode : " + (fp ? (cm.length ? cm[0] : "单点一致") : "读不到 settings"));
   const fo = fp ? forceOrderIssues(fp.packages) : [];
-  lines.push(`force序  : ${fp ? (fo.length ? fo[0] : "OK") : "读不到 settings"}`);
+  lines.push("force序  : " + (fp ? (fo.length ? fo[0] : "OK") : "读不到 settings"));
   const fe = fp ? scanForcePackages(fp.packages) : [];
-  lines.push(`forceExt: ${fp ? (fe.length ? "疑似 " + fe.join(" / ") : "无（静态扫描）") : "读不到 settings"}`);
+  lines.push("forceExt: " + (fp ? (fe.length ? "疑似 " + fe.join(" / ") : "无（静态扫描）") : "读不到 settings"));
   const fb = fp ? scanForceFallbacks(fp.packages) : [];
-  lines.push(`force兜底: ${fp ? (fb.length ? fb.join(" / ") : "无") : "读不到 settings"}`);
+  lines.push("force兜底: " + (fp ? (fb.length ? fb.join(" / ") : "无") : "读不到 settings"));
   return lines;
 }
 
 export default function (pi: ExtensionAPI) {
-  // 启动自愈：factory 是同步上下文，此时 pi-lens（rank 4）尚未加载。
-  let healNote: string | null = null;
-  try {
-    const r = healPiLens();
-    if (!r.ok) healNote = `patch-keeper: pi-lens 自愈失败 —— ${r.detail}`;
-  } catch (e) { healNote = `patch-keeper: pi-lens 自愈异常 —— ${(e as Error).message}`; }
-  try {
-    const r = healPiMemory();
-    if (!r.ok) healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: pi-memory 自愈失败 —— ${r.detail}`;
-  } catch (e) { healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: pi-memory 自愈异常 —— ${(e as Error).message}`; }
-  try {
-    const r = healMemorySection();
-    if (!r.ok) healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: pi-memory section 自愈失败 —— ${r.detail}`;
-  } catch (e) { healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: pi-memory section 自愈异常 —— ${(e as Error).message}`; }
-  try {
-    const rt = healTactician();
-    if (!rt.ok) healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: tactician section 自愈失败 —— ${rt.detail}`;
-  } catch (e) { healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: tactician section 自愈异常 —— ${(e as Error).message}`; }
-  try {
-    const r = healSelfExtension();
-    if (!r.ok) healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: 自建扩展保护失败 —— ${r.detail}`;
-  } catch (e) { healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: 自建扩展保护异常 —— ${(e as Error).message}`; }
-  try {
-    const r = healMemoryFormat();
-    if (!r.ok) healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: 记忆格式自愈失败 —— ${r.detail}`;
-  } catch (e) { healNote = (healNote ? healNote + "\n" : "") + `patch-keeper: 记忆格式自愈异常 —— ${(e as Error).message}`; }
-
   pi.registerCommand("patch-keeper", {
-    description: "查看 / 自愈本机源码补丁状态（PiDeck asar ×3、pi-lens ×1、pi-memory ×1）",
+    description: "pi 配置守卫：codemode 一致性 / force 顺序 / 环境指纹 / 注入对齐",
     handler: async (args: string, ctx: ExtensionContext) => {
       const arg = (args || "").trim().toLowerCase();
       if (arg === "fix") {
-        const r = healPiLens();
-        ctx.ui.notify(`pi-lens: ${r.detail}`, r.ok ? "info" : "error");
-
-        const r2 = healPiMemory();
-        ctx.ui.notify(`pi-memory: ${r2.detail}`, r2.ok ? "info" : "error");
-        const r3 = healMemorySection();
-        ctx.ui.notify(`pi-memory section: ${r3.detail}`, r3.ok ? "info" : "error");
-        const r4 = healTactician();
-        ctx.ui.notify(`tactician section: ${r4.detail}`, r4.ok ? "info" : "error");
-        const r5 = healSelfExtension();
-        ctx.ui.notify(`自建扩展: ${r5.detail}`, r5.ok ? "info" : "error");
         const rForce = fixForceOrder();
-        if (rForce) ctx.ui.notify(`patch-keeper: ${rForce}`, "info");
-        const rb = restoreBuiltinPatches();
-        if (rb) ctx.ui.notify(`patch-keeper: ${rb}`, "warning");
+        ctx.ui.notify("patch-keeper: " + (rForce || "force 顺序无需修复"), "info");
         return;
       }
-      const lines = report();
-      const tip = patchTip(lines);
-      ctx.ui.notify(`补丁状态\n${lines.join("\n")}${tip}`, "info");
+      ctx.ui.notify("配置守卫状态" + String.fromCharCode(10) + report().join(String.fromCharCode(10)), "info");
     },
   });
 
-  // 启动提示：只在「PiDeck 补丁缺失」时出声（pi-lens 已自动修好，不打扰）
   pi.on("session_start", async (_event, ctx: ExtensionContext) => {
     try {
-      const asar = checkAsar();
       const msgs: string[] = [];
       const drift = fingerprintDrift();
       const forceFix = fixForceOrder();
@@ -594,35 +248,13 @@ export default function (pi: ExtensionAPI) {
         const mid = fe.filter((n) => fp.packages.indexOf(n) < fp.packages.length - 1);
         if (mid.length) msgs.push("patch-keeper: 疑似 force 型扩展不在末尾（其后的 section 可能被静默丢弃）：" + mid.join(" / ") + " —— 核源码后移到 packages 末尾");
       }
-      if (drift.length) msgs.push(`patch-keeper: 环境指纹已变（${drift.join("；")}）—— 手册 / 上轮验证结论可能过期，按 08-台账核对纪律逐项重验`);
-      if (asar.ran && asar.missing.length) {
-        msgs.push(`patch-keeper: PiDeck 补丁缺失 —— ${asar.detail}`);
-        msgs.push(`关闭 PiDeck 后重跑补丁脚本（快照 ${SNAPSHOT_PATCH_DIR}；或用其中的 launch-pideck.cmd 启动 PiDeck 时自动重打）`);
-      }
-      for (const bp of BUILTIN_PATCHES) {
-        const missing = [bp.install, bp.file].filter((p: string) => { const src = safeRead(p); return src !== null && !src.includes(bp.needle); });
-        if (missing.length) {
-          const where = missing.length === 2 ? "两处" : missing[0] === bp.install ? "安装目录（生效版）" : "用户层";
-          msgs.push(`patch-keeper: PiDeck 内置扩展补丁缺失（${bp.name}，${where}）—— 升级覆盖？从快照 03-PiDeck/builtin-extensions 恢复`);
-        }
-      }
-      {
-        const memSrc2 = safeRead(PI_MEMORY);
-        if (memSrc2 !== null && !memSrc2.includes(MEM_SECTION_MARK)) msgs.push("patch-keeper: pi-memory 未打 section 优先补丁 —— goal / plan / security 的 section 会被 force 吞掉，建议 /patch-keeper fix");
-      }
-      {
-        const tactSrc2 = safeRead(TACT);
-        if (tactSrc2 !== null && !tactSrc2.includes(TACT_MARK)) msgs.push("patch-keeper: tactician 未打 section 优先补丁 —— 会 force 吞掉其后的 section（goal / plan / security），建议 /patch-keeper fix");
-      }
+      if (drift.length) msgs.push("patch-keeper: 环境指纹已变（" + drift.join("；") + "）—— 手册 / 上轮验证结论可能过期，按 08-台账核对纪律逐项重验");
       const md = manualDrift();
-      if (md) msgs.push(`patch-keeper: ${md}`);
-      if (healNote) msgs.push(healNote);
+      if (md) msgs.push("patch-keeper: " + md);
       for (const m of msgs) ctx.ui.notify(m, "warning");
     } catch { /* 静默：检测不该影响会话 */ }
   });
 
-  // 注入对齐（手册 §2 纪律区）：注入的是宿主上次读取的文本，可能与磁盘版不同步。每轮比对一次，不一致时提示一次。
-  // 纪律：**绝不返回 systemPrompt** —— 返回即 forceSystemPrompt 覆盖式替换，会静默丢弃其后所有 section 的修改。
   let lastPair = "";
   pi.on("before_agent_start", async (event, ctx: ExtensionContext) => {
     try {
@@ -634,19 +266,14 @@ export default function (pi: ExtensionAPI) {
       const pair = vi + "|" + vd;
       if (vi === vd || pair === lastPair) return undefined;
       lastPair = pair;
-      ctx.ui.notify(`注入对齐：注入 v${vi} ≠ 磁盘 v${vd}（观察者 = 磁盘版）→ 判据：注入版不可作判断依据；动作：读回全文执行，重启后自愈`, "warning");
-      // 回灌四律②：用户已收到通知；模型也需要知道，否则「以磁盘版执行」停在用户侧。
+      ctx.ui.notify("注入对齐：注入 v" + vi + " ≠ 磁盘 v" + vd + "（观察者 = 磁盘版）→ 判据：注入版不可作判断依据；动作：读回全文执行，重启后自愈", "warning");
       try {
         (pi as unknown as { sendMessage?: (m: unknown, o?: unknown) => void }).sendMessage?.(
-          {
-            customType: "patch-keeper",
-            content: `注入对齐：注入 v${vi} ≠ 磁盘 v${vd}（观察者 = 磁盘版）→ 注入版不可作判断依据；动作：读回 APPEND_SYSTEM.md 全文后执行，重启后自愈。`,
-            display: false,
-          },
+          { customType: "patch-keeper", content: "注入对齐：注入 v" + vi + " ≠ 磁盘 v" + vd + "（观察者 = 磁盘版）→ 注入版不可作判断依据；动作：读回 APPEND_SYSTEM.md 全文后执行，重启后自愈。", display: false },
           { deliverAs: "nextTurn" },
         );
-      } catch { /* 静默：回灌失败不影响会话 */ }
-    } catch { /* 静默：检测不该影响会话 */ }
+      } catch { /* 静默 */ }
+    } catch { /* 静默 */ }
     return undefined;
   });
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-patch-keeper",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "pi config guards: codemode single-source check, force-order guard (auto-fix), settings fingerprint drift, injected-manual alignment. (PiDeck / third-party source patches are a local-only module, not bundled.)",
   "type": "module",
   "license": "MIT",