dsh-rule-engine 0.3.0

package/lib/core/state.js

@@ -0,0 +1,185 @@
+// state.js - 插件运行时状态（内存态）。
+// 所有会话级状态以 sessionId 为 key；turn 级状态在 turn/start 重置。
+import { statSync } from "node:fs";
+import { loadRules } from "./parser.js";
+import { agentsFilePath } from "./paths.js";
+import { understandAll } from "./understander.js";
+import { AUTH_TTL_MS } from "./authorization.js";
+
+const MAX_SESSIONS = 200;
+const MAX_RETRY_KEYS = 500;
+const MAX_INJECT_KEYS = 500;
+const MTIME_CHECK_INTERVAL_MS = 2000;
+
+export function createState() {
+  return {
+    loadedAt: 0,
+    enabled: true,
+    rules: [],
+    configs: [],
+    configOk: true,
+    configError: null,
+    bypassUntil: 0,
+    unlockUntil: 0,
+    mtimeMs: 0,
+    lastMtimeCheck: 0,
+    sessions: new Map(),
+    retryCounts: new Map(),
+    injectCounts: new Map(),
+    globalAuthorizations: [],
+    skillNames: null,
+    llmEnrichedKeys: new Set(),
+    lastActive: [],
+    lastEvent: null,
+    reloadCount: 0,
+    mountRevision: 0,
+    mountSignature: ""
+  };
+}
+
+/** AGENTS.md mtime 变化时自动重解析（规则 21：规则是流动数据） */
+export function maybeReloadIfChanged(state, now = Date.now()) {
+  if (now - state.lastMtimeCheck < MTIME_CHECK_INTERVAL_MS) return false;
+  state.lastMtimeCheck = now;
+  pruneState(state);
+  try {
+    const mtime = statSync(agentsFilePath()).mtimeMs;
+    if (mtime !== state.mtimeMs) {
+      reloadRules(state);
+      return true;
+    }
+  } catch {
+    // AGENTS.md 暂时不可读时保持旧规则，不崩
+  }
+  return false;
+}
+
+/** 清理过期/超量内存状态：会话、重试计数、注入计数 */
+export function pruneState(state) {
+  const now = Date.now();
+  if (state.sessions.size > MAX_SESSIONS) {
+    const entries = [...state.sessions.entries()].sort((a, b) => (a[1].lastSeen || 0) - (b[1].lastSeen || 0));
+    const excess = entries.slice(0, state.sessions.size - MAX_SESSIONS);
+    for (const [key] of excess) state.sessions.delete(key);
+  }
+  if (state.retryCounts.size > MAX_RETRY_KEYS) {
+    const keys = [...state.retryCounts.keys()];
+    for (let i = 0; i < keys.length - MAX_RETRY_KEYS; i++) state.retryCounts.delete(keys[i]);
+  }
+  if (state.injectCounts.size > MAX_INJECT_KEYS) {
+    const keys = [...state.injectCounts.keys()];
+    for (let i = 0; i < keys.length - MAX_INJECT_KEYS; i++) state.injectCounts.delete(keys[i]);
+  }
+  // 清理过期授权（顺便释放内存）
+  for (const s of state.sessions.values()) {
+    s.authorizations = s.authorizations.filter((a) => !a.expiresAt || a.expiresAt > now);
+  }
+  if (Array.isArray(state.globalAuthorizations)) {
+    state.globalAuthorizations = state.globalAuthorizations.filter((a) => !a.expiresAt || a.expiresAt > now);
+  }
+}
+
+export function getSessionState(state, sessionId) {
+  const key = sessionId || "global";
+  let s = state.sessions.get(key);
+  if (!s) {
+    s = {
+      id: key,
+      manualReadSeen: false,
+      lastUserText: "",
+      selfCertCount: new Map(),
+      authorizations: [],
+      backups: [],
+      mountAuditRevision: 0,
+      mountAuditSignature: "",
+      lastCommandOutput: "",
+      lastSeen: Date.now(),
+      turn: freshTurn()
+    };
+    state.sessions.set(key, s);
+  }
+  s.lastSeen = Date.now();
+  return s;
+}
+
+/** 记录一条授权证据（结构化：type/pathPrefix/at/source/expiresAt）。同时写入全局池，便于子代理/跨会话工具调用复用。 */
+export function recordAuthorization(state, sessionId, auth) {
+  const record = {
+    at: Date.now(),
+    source: "ask",
+    expiresAt: Date.now() + AUTH_TTL_MS,
+    ...auth
+  };
+  const s = getSessionState(state, sessionId);
+  s.authorizations.push(record);
+  state.globalAuthorizations.push(record);
+  return s.authorizations;
+}
+
+/** 记录一条备份证据（目标路径 → 备份路径） */
+export function recordBackup(state, sessionId, targetPath, backupPath) {
+  const s = getSessionState(state, sessionId);
+  s.backups.push({
+    targetPath: normalizeBackupPath(targetPath),
+    backupPath: normalizeBackupPath(backupPath),
+    at: Date.now()
+  });
+  return s.backups;
+}
+
+function normalizeBackupPath(p) {
+  return String(p || "").replace(/\\/g, "/").toLowerCase();
+}
+
+/** 查找目标路径是否已有对应备份 */
+export function findBackupForPath(state, sessionId, targetPath) {
+  const s = getSessionState(state, sessionId);
+  const t = normalizeBackupPath(targetPath);
+  return s.backups.find((b) => b.targetPath === t) || null;
+}
+
+export function freshTurn() {
+  return {
+    number: 0,
+    userText: "",
+    askSeen: false,
+    questionOnly: false,
+    pendingAsk: null,
+    pendingToolCalls: new Map(),
+    getDateSeen: false,
+    backupSeen: false,
+    toolCount: 0,
+    firstToolName: "",
+    skillNames: [],
+    toolNames: [],
+    commands: [],
+    reasoningText: ""
+  };
+}
+
+export function resetTurn(state, sessionId, turnNumber) {
+  const s = getSessionState(state, sessionId);
+  s.turn = freshTurn();
+  s.turn.number = typeof turnNumber === "number" ? turnNumber : 0;
+  s.turn.userText = s.lastUserText || "";
+  return s.turn;
+}
+
+/** 重新加载并理解 AGENTS.md */
+export function reloadRules(state) {
+  const parsed = loadRules();
+  state.rules = parsed.ok ? parsed.rules : [];
+  state.configs = understandAll(state.rules);
+  state.configOk = parsed.ok;
+  state.configError = parsed.error || null;
+  state.mtimeMs = parsed.mtimeMs || 0;
+  state.loadedAt = Date.now();
+  state.lastMtimeCheck = Date.now();
+  state.reloadCount++;
+  return state;
+}
+
+/** 获取某条理解配置 */
+export function findConfig(state, ruleId) {
+  return state.configs.find((c) => String(c.ruleId) === String(ruleId));
+}

package/lib/core/text-detect.js

@@ -0,0 +1,185 @@
+// text-detect.js - 输出文本检测（B 级纠察 + 部分 D 级自证触发）。
+// 官方架构下 assistant/message 无法拦下不发，因此这里做「必发现、必记账、可注入纠正」。
+import {
+  CJK_RE,
+  PROMISE_WORDS,
+  SOURCE_MARK,
+  TIME_WORDS,
+  URL_RE
+} from "./patterns.js";
+
+/** 从 assistant message 内容中提取纯文本 */
+export function extractAssistantText(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((b) => (b && typeof b === "object" && b.type === "text" ? b.text : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+const SELF_CERT_HINTS = {
+  "14": { re: /总结|汇报|完成/, reason: "请按规则 14 一次性完整汇报，区分事实与推断" },
+  "22": { re: /我记下了|记住了|收到，我记下了|放心，我记住了/i, reason: "检测到「我记下了」类空话；正确动作是落盘执行并汇报" },
+  "23": { re: /完成|交付/, reason: "交付/完成声明未附运行时验证证据" },
+  "6": { re: /(?:API|JSON|正则|异步|依赖注入|回调|schema|DI)/i, reason: "请按规则 6 用零基础用户能懂的语言解释" },
+  "16": { re: /建议|优化|更优方案/, reason: "请按规则 16 用五要素格式提建议，避免频繁打断" },
+  "20": { re: /推理档位|off|high|max/, reason: "请按规则 20 给出档位建议并说明理由" },
+  "12E": { re: /重启|GUI|登录|界面|窗口/, reason: "请按规则 12E 先确认界面真实存在并声明能力边界" },
+  "26": { re: /(?=发布|Release|附件)(?!(?:Attach binaries|正式 Asset|release\.assets))/i, reason: "请按规则 26 确认正式 Release Asset（release.assets）并附 tgz/zip" },
+  "10": { re: /新会话|旧会话|旧项目|上下文恢复/, reason: "请按规则 10 自证：如实说明默认不自动继承，按优先级恢复并标注来源" },
+  "12C": { re: /下载|网络|curl|Clash|被墙/, reason: "请按规则 12C 自证：需代理先告知、失败即停、下载后校验、排查先测连通性" },
+  "13B": { re: /会话文件|会话修复|fromRestore|Inbox 回放|孤儿扫描/, reason: "请按规则 13B 自证：会话替换前用户完全退出、三层验证一次跑完、mtime 判断" },
+  "15": { re: /文件版本|文件用途|新旧|版本.*处置|保留文件/, reason: "请按规则 15 自证：不凭 mtime/文件名判断新旧，无法确定版本/用途时保留并询问" },
+  "19": { re: /学到新.*DSH|踩到新坑|踩坑.*沉淀|手册有误|知识必沉淀/, reason: "请按规则 19 自证：按①-⑦沉淀并当次汇报正文同步位置" }
+};
+
+/** 简单判断一段文本是否以英文为主 */
+function isMostlyEnglish(text) {
+  if (!text) return false;
+  const letters = (text.match(/[A-Za-z]/g) || []).length;
+  const cjk = (text.match(CJK_RE) || []).length;
+  return letters > 30 && cjk === 0;
+}
+
+/**
+ * 检测一次 assistant/message 的 B/D 级违规。
+ * @param {object} options
+ * @param {Array} options.configs 理解配置
+ * @param {object} options.session 会话状态（getSessionState 返回）
+ * @param {string} options.text assistant 纯文本
+ * @returns {Array<{ruleId:string,title:string,kind:string,reason:string}>}
+ */
+export function detectViolations({ configs, session, text, reasoningText = "", mountRevision = 0 }) {
+  const hits = [];
+  const byId = new Map(configs.filter((c) => c.confidence !== "low").map((c) => [String(c.ruleId), c]));
+
+  const timeCfg = byId.get("2");
+  if (timeCfg && TIME_WORDS.test(text) && !session.turn.getDateSeen) {
+    hits.push({
+      ruleId: "2",
+      title: timeCfg.title,
+      kind: "correct",
+      reason: "回答出现时间词/日期，但本回合未先调用 Get-Date 核对"
+    });
+  }
+
+  const promiseCfg = byId.get("7");
+  if (promiseCfg && PROMISE_WORDS.test(text)) {
+    hits.push({
+      ruleId: "7",
+      title: promiseCfg.title,
+      kind: "correct",
+      reason: "检测到绝对化承诺词，请改为保守表述"
+    });
+  }
+
+  const sourceCfg = byId.get("5");
+  if (sourceCfg && URL_RE.test(text) && !SOURCE_MARK.test(text)) {
+    hits.push({
+      ruleId: "5",
+      title: sourceCfg.title,
+      kind: "correct",
+      reason: "回答包含 URL 但未标注出处/来源"
+    });
+  }
+
+  const langCfg = byId.get("11");
+  const visibleEnglish = isMostlyEnglish(text);
+  const reasoningEnglish = isMostlyEnglish(reasoningText);
+  if (langCfg && session.lastUserText && CJK_RE.test(session.lastUserText) && (visibleEnglish || reasoningEnglish)) {
+    hits.push({
+      ruleId: "11",
+      title: langCfg.title,
+      kind: "correct",
+      reason: visibleEnglish
+        ? "用户中文提问，回答几乎全英文"
+        : "用户中文提问，思维链（reasoning）几乎全英文"
+    });
+  }
+
+  const directCfg = byId.get("22");
+  if (directCfg && /我记下了|记住了|收到，我记下了|放心，我记住了/i.test(text)) {
+    hits.push({
+      ruleId: "22",
+      title: directCfg.title,
+      kind: "self-certify",
+      reason: "检测到「我记下了」类空话；正确动作是落盘执行并汇报"
+    });
+  }
+
+  const verifyCfg = byId.get("23");
+  if (verifyCfg && /完成|交付/.test(text) && !/运行时验证|mock|启动|实测|测试|验证/.test(text)) {
+    hits.push({
+      ruleId: "23",
+      title: verifyCfg.title,
+      kind: "self-certify",
+      reason: "交付/完成声明未附运行时验证证据"
+    });
+  }
+
+  const mountCfg = byId.get("27");
+  if (mountCfg && mountRevision > (session.mountAuditRevision || 0) && /重启|装配|挂载/.test(text) && !/审计通过|全量审计|MOUNT CONSISTENT|DUPLICATES FOUND|audit-mount-consistency/.test(text)) {
+    hits.push({
+      ruleId: "27",
+      title: mountCfg.title,
+      kind: "self-certify",
+      reason: `规则 27：插件装配已变更（mountRevision=${mountRevision}）且本会话未通过全量审计，重启/继续前请先运行 audit-mount-consistency.mjs`
+    });
+  }
+
+  // 规则 21：选项即边界——检测“补充/增加”类越界表述，未声明仅按勾选时触发自证
+  const scopeCfg = byId.get("21");
+  if (scopeCfg && /(?:我补充|顺便补充|额外补充|我增加|顺便加|额外加|多加|自行纳入)/.test(text) && !/仅按勾选|只实现被选项|未选项|单独确认|再次征求/.test(text)) {
+    hits.push({
+      ruleId: "21",
+      title: scopeCfg.title,
+      kind: "self-certify",
+      reason: "规则 21：检测到越界补充表述，请自证是否超出用户勾选范围；未选项需单独确认"
+    });
+  }
+
+  // 规则 22：被指出错误后需主动给出原因/改正/防再犯，不能只道歉
+  const errorCfg = byId.get("22");
+  if (errorCfg && /(?:抱歉|对不起|我错了|这是我的错|失误)/.test(text) && !/(?:原因|改正|防再犯|避免|机制|解法|修正)/.test(text)) {
+    hits.push({
+      ruleId: "22",
+      title: errorCfg.title,
+      kind: "self-certify",
+      reason: "规则 22：被指出错误后需主动给出原因、改正、防再犯解法，不要只道歉"
+    });
+  }
+
+  // 规则 19⑥：版本记录≠完成——只报版本记录未列正文同步时触发自证
+  const rule19Cfg = byId.get("19");
+  if (rule19Cfg && /版本记录|v\d+\.\d+/.test(text) && /已记入版本记录|版本记录已|只加了版本记录|只加版本记录/.test(text) && !/正文|同步|无需同步|无需改正文/.test(text)) {
+    hits.push({
+      ruleId: "19",
+      title: rule19Cfg.title,
+      kind: "self-certify",
+      reason: "规则 19⑥：检测到只报版本记录未列正文同步；请列出同步的正文位置，或说明“无需同步正文”及理由"
+    });
+  }
+
+  // D 级自证泛化：按规则特征触发，每规则每会话上限由 maybeInject 控制
+  for (const cfg of configs) {
+    if (cfg.confidence === "low") continue;
+    if (!(cfg.actions || []).includes("self-certify")) continue;
+    const hint = SELF_CERT_HINTS[String(cfg.ruleId)];
+    if (!hint) continue;
+    if (hint.re.test(text)) {
+      hits.push({
+        ruleId: String(cfg.ruleId),
+        title: cfg.title,
+        kind: "self-certify",
+        reason: hint.reason
+      });
+    }
+  }
+
+  return hits;
+}

package/lib/core/understander.js

@@ -0,0 +1,127 @@
+// understander.js - 规则理解器（模式库兜底版）。
+// 输入 parser 解析出的规则，输出结构化执行配置。
+// LLM 理解器可在后续版本接入 ctx.llm，当前先保证确定性与可测试性。
+import { extractElements } from "./parser.js";
+import {
+  BOM_WRITE,
+  DESTRUCTIVE_CMD,
+  DSH_KEYWORDS_RE,
+  INLINE_CMD,
+  SENSITIVE_CMD,
+  TIME_WORDS,
+  PROMISE_WORDS,
+  URL_RE,
+  SOURCE_MARK
+} from "./patterns.js";
+
+const HANDLER_BY_RULE = {
+  1: "rule1-retry",
+  2: "rule2-time",
+  5: "rule5-source",
+  7: "rule7-promise",
+  9: "rule9-inline-bom",
+  11: "rule11-language",
+  12: "rule12-approval",
+  "12A": "rule12a-approval",
+  "12B": "rule12b-skill",
+  "12C": "rule12c-network",
+  "12D": "rule12d-sensitive",
+  13: "rule13-backup",
+  "13A": "rule13a-backup",
+  "13B": "rule13b-session",
+  14: "rule14-report",
+  18: "rule18-manual-first",
+  21: "rule21-meta",
+  22: "rule22-direct",
+  23: "rule23-runtime-verify",
+  24: "rule24-assembly-type",
+  25: "rule25-tool-coverage",
+  26: "rule26-release-asset",
+  27: "rule27-mount-audit"
+};
+
+/** 根据执行等级推导动作 */
+export function actionsForLevel(level) {
+  const s = String(level || "").toUpperCase();
+  const actions = [];
+  if (s.includes("A")) actions.push("deny");
+  if (s.includes("B")) actions.push("correct");
+  if (s.includes("C")) actions.push("ask");
+  if (s.includes("D")) actions.push("self-certify");
+  if (s.includes("M")) actions.push("meta");
+  if (actions.length === 0) actions.push("self-certify");
+  return [...new Set(actions)];
+}
+
+function splitKeywords(text) {
+  if (!text) return [];
+  return text
+    .split(/[，。；、,\n；:：/\\()（）]+/)
+    .map((s) => s.trim())
+    .filter((s) => s.length >= 2 && s.length <= 20);
+}
+
+/** 从检查文本提取机器可用的提示词 */
+function hintPatterns(checkText) {
+  const hints = [];
+  if (/node\s+-e|node\s+-p|pwsh\s+-c|--eval|--print|-Command\b/i.test(checkText)) hints.push("inline-command");
+  if (/set-content|out-file|add-content|writealltext|utf8/i.test(checkText)) hints.push("bom-write");
+  if (/ask_user_question|授权|弹框/i.test(checkText)) hints.push("ask");
+  if (/get-date|时间词|昨天|今天/i.test(checkText)) hints.push("time");
+  if (/skill|技能/i.test(checkText)) hints.push("skill");
+  if (/git\s+(push|commit)|敏感操作|授权/i.test(checkText)) hints.push("sensitive");
+  if (/删除|覆盖|备份|验证/i.test(checkText)) hints.push("backup");
+  if (/手册/i.test(checkText)) hints.push("manual");
+  if (/重试|连续失败|第\s*3\s*次/i.test(checkText)) hints.push("retry");
+  if (/运行时验证|mock|启动|实测/i.test(checkText)) hints.push("runtime-verify");
+  if (/URL|来源|出处|引用/i.test(checkText)) hints.push("source");
+  if (/中文|英文|语言/i.test(checkText)) hints.push("language");
+  return [...new Set(hints)];
+}
+
+/**
+ * 理解一条规则。
+ * @param {object} rule parser 输出
+ * @returns {object} 执行配置
+ */
+export function understandRule(rule) {
+  const elems = extractElements(rule.body || "");
+  const level = rule.level || "";
+  const actions = actionsForLevel(level);
+  const hints = hintPatterns(elems.check);
+  const triggerKeywords = splitKeywords(elems.trigger);
+  const confidence = level && elems.trigger && elems.check && (elems.action || level.toUpperCase().includes("D")) ? "high" : level ? "medium" : "low";
+  const handler = HANDLER_BY_RULE[rule.index] || "";
+  const config = {
+    ruleId: rule.index,
+    title: rule.title,
+    section: rule.section,
+    level,
+    actions,
+    confidence,
+    handler,
+    triggerKeywords,
+    hints,
+    elements: elems,
+    disabled: false
+  };
+  return config;
+}
+
+/** 批量理解 */
+export function understandAll(rules) {
+  return rules.map(understandRule);
+}
+
+/** 导出常用正则供测试/调试 */
+export const REGEX = {
+  INLINE_CMD,
+  BOM_WRITE,
+  DESTRUCTIVE_CMD,
+  SENSITIVE_CMD,
+  TIME_WORDS,
+  PROMISE_WORDS,
+  URL_RE,
+  SOURCE_MARK,
+  DSH_KEYWORDS_RE
+};

package/lib/core/understanding-store.js

@@ -0,0 +1,27 @@
+// understanding-store.js - 理解产物读写。
+// rule-understanding.json 对模型只读（由守卫保护），unlock 后可改。
+import { readFileSync, writeFileSync } from "node:fs";
+import { understandingFilePath } from "./paths.js";
+
+export function writeUnderstanding(configs) {
+  try {
+    const payload = {
+      generatedAt: new Date().toISOString(),
+      engine: "pattern-v1",
+      rules: configs
+    };
+    writeFileSync(understandingFilePath(), JSON.stringify(payload, null, 2), "utf8");
+    return { ok: true, path: understandingFilePath() };
+  } catch (error) {
+    return { ok: false, error: String(error) };
+  }
+}
+
+export function readUnderstanding() {
+  try {
+    const raw = readFileSync(understandingFilePath(), "utf8");
+    return { ok: true, data: JSON.parse(raw) };
+  } catch (error) {
+    return { ok: false, error: String(error) };
+  }
+}

package/lib/core/version-guard.js

@@ -0,0 +1,117 @@
+// version-guard.js - 手册/版本记录类文件写后自检（P1）
+// 纯函数，可独立测试。
+import { basename } from "node:path";
+
+const VERSIONED_NAMES = new Set(["skill.md", "agents.md", "changelog.md", "readme.md"]);
+
+export function isVersionedFile(p) {
+  if (typeof p !== "string") return false;
+  const name = basename(p).toLowerCase();
+  if (VERSIONED_NAMES.has(name)) return true;
+  return /版本|version|changelog/i.test(p);
+}
+
+/** 从文本中提取版本号列表，只匹配版本记录表行（如 | v3.32 |），不扫全文 */
+export function extractVersions(text) {
+  if (typeof text !== "string") return [];
+  const out = [];
+  const lines = text.split("\n");
+  const re = /^\s*\| v(\d+)\.(\d+) \|/;
+  for (const line of lines) {
+    const m = line.match(re);
+    if (m) out.push({ major: Number(m[1]), minor: Number(m[2]) });
+  }
+  return out;
+}
+
+/** 校验版本号连续无重复：同一 major 下 minor 从 min 到 max 无缺失、无重复 */
+export function validateVersionContinuity(text) {
+  const versions = extractVersions(text);
+  if (versions.length === 0) return { ok: true, errors: [] };
+  const byMajor = new Map();
+  for (const v of versions) {
+    if (!byMajor.has(v.major)) byMajor.set(v.major, new Set());
+    byMajor.get(v.major).add(v.minor);
+  }
+  const errors = [];
+  for (const [major, minors] of byMajor) {
+    const arr = [...minors].sort((a, b) => a - b);
+    const min = arr[0];
+    const max = arr[arr.length - 1];
+    for (let i = min; i <= max; i++) {
+      if (!minors.has(i)) {
+        errors.push(`v${major}.${i} 缺失`);
+      }
+    }
+    if (arr.length !== max - min + 1) {
+      errors.push(`v${major} 版本号不连续`);
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+/** 判断是否为“版本记录行内仅版本号变更”（如 v3.41 → v3.42，重编号场景） */
+function isVersionRenumber(oldString, newString) {
+  if (typeof oldString !== "string" || typeof newString !== "string") return false;
+  const re = /^(\s*\| )v\d+\.\d+( \|[\s\S]*)$/;
+  const m1 = oldString.match(re);
+  const m2 = newString.match(re);
+  if (!m1 || !m2) return false;
+  return m1[1] === m2[1] && m1[2] === m2[2];
+}
+
+/** 判断是否单行文本（不含换行） */
+function isSingleLine(s) {
+  return !s.includes("\n") && !s.includes("\r");
+}
+
+/** 判断是否 Markdown 表格行 */
+function isTableRow(s) {
+  return /^\s*\|/.test(s);
+}
+
+/** 提取单行文本的“行锚点”：规则编号 > 标题前缀+首词 > 列表符号+首段标签 > 首词 */
+function lineAnchor(s) {
+  const rule = s.match(/\[规则\s+([^\]]+)\]/);
+  if (rule) return "rule:" + rule[1].trim();
+  const h = s.match(/^(#{1,6})\s+(.+)$/);
+  if (h) return "h" + h[1].length + ":" + h[2].trim().split(/\s+/)[0];
+  const li = s.match(/^(\s*(?:[-*+]|\d+[.)])\s+)(.*)$/);
+  if (li) {
+    const token = li[2].trim().split(/[：:\s]/)[0];
+    return "li:" + token;
+  }
+  const m = s.match(/^(\S+)/);
+  return "txt:" + (m ? m[1] : "");
+}
+
+/** 非表格单行替换：行锚点一致即放行（同列表项/同标题/同规则编号的正文修正） */
+function isSameLineReplacement(oldString, newString) {
+  if (!isSingleLine(oldString) || !isSingleLine(newString)) return false;
+  if (isTableRow(oldString) || isTableRow(newString)) return false;
+  return lineAnchor(oldString) === lineAnchor(newString);
+}
+
+/** 校验 append/删除式编辑：新增需包含 old_string；删除/缩短时 new_string 可为 old_string 的子串；版本行重编号放行；非表格单行修改放行 */
+export function validateEditAppend(oldString, newString) {
+  if (typeof oldString !== "string" || typeof newString !== "string") return { ok: true, errors: [] };
+  if (oldString.length === 0) return { ok: true, errors: [] };
+  if (isVersionRenumber(oldString, newString)) return { ok: true, errors: [] };
+  if (newString.includes(oldString)) return { ok: true, errors: [] };
+  if (oldString.includes(newString)) return { ok: true, errors: [] };
+  if (isSameLineReplacement(oldString, newString)) return { ok: true, errors: [] };
+  return {
+    ok: false,
+    errors: ["new_string 未包含 old_string，疑似覆盖上一行"]
+  };
+}
+
+/** 综合校验一次编辑后的文件 */
+export function validateEditedFile(originalText, currentText, oldString, newString) {
+  const errors = [];
+  const continuity = validateVersionContinuity(currentText);
+  if (!continuity.ok) errors.push(...continuity.errors);
+  const append = validateEditAppend(oldString, newString);
+  if (!append.ok) errors.push(...append.errors);
+  return { ok: errors.length === 0, errors };
+}