@jayyuen66/dsh-lesson-loop 0.0.0-stage → 0.1.0

package/host.js

@@ -0,0 +1,2687 @@
+// GENERATED by build-host.mjs — edit host.ts / lib/*.ts, then run `node build-host.mjs`.
+import { randomUUID } from "node:crypto";
+import Schema from "@deepseek-ai/schemastery";
+import { dshCachePath } from "@deepseek-ai/dsh-home-paths";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { guardBody, queryParam, sendJson } from "@jayyuen66/dsh-plugin-shared/lib/http";
+import { guardTrust } from "@jayyuen66/dsh-plugin-shared/lib/trust";
+import { errorText } from "@jayyuen66/dsh-plugin-shared/lib/errors";
+import { deriveProjectKey } from "@jayyuen66/dsh-plugin-shared/lib/project-key";
+import { fieldOf, isRecord } from "@jayyuen66/dsh-plugin-shared/lib/record";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { shrinkJsonlTail } from "@jayyuen66/dsh-plugin-shared/lib/jsonl";
+import { LOCALE_SETTINGS_NAMESPACE, messagesFor, resolveLocalePreference } from "@jayyuen66/dsh-plugin-shared/lib/locale";
+//#region lib/jsonl-fuse.ts
+/** 超限时按行对半收缩（判据在 shared/lib/jsonl.ts，与 ctx-observe 同源；单行超限保末行兜底）。
+*  错误出口留在这里吞掉：本包的承诺是"落库失败只日志、不抛穿宿主热路径"。 */
+function trimJsonl(file, maxBytes) {
+	try {
+		if (statSync(file).size <= maxBytes) return;
+		const text = readFileSync(file, "utf8");
+		const shrunk = shrinkJsonlTail(text, maxBytes);
+		if (shrunk !== text) writeFileSync(file, shrunk);
+	} catch {}
+}
+//#endregion
+//#region lib/lesson-jsonl.ts
+/** JSONL 单行容错解析：坏行/非对象 → null（供 readJsonl 计 bad）。 */
+function parseJsonLine(line) {
+	try {
+		const parsed = JSON.parse(line);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+/** JSONL 追加（容错：路径/建目录/截断/追加任一失败只日志不抛——热路径不许炸宿主）。 */
+function appendJsonl(file, row, maxBytes) {
+	try {
+		const dir = path.dirname(file);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		if (maxBytes > 0) trimJsonl(file, maxBytes);
+		appendFileSync(file, `${JSON.stringify(row)}\n`);
+	} catch (error) {
+		console.error(`[lesson-loop] lesson append failed: ${errorText(error)}`);
+	}
+}
+/** 读整个 JSONL（容错；坏行跳过并 warn 一次计数）。 */
+function readJsonl(file) {
+	try {
+		if (!existsSync(file)) return [];
+		const text = readFileSync(file, "utf8");
+		const out = [];
+		let bad = 0;
+		for (const line of text.split("\n")) {
+			const trimmed = line.trim();
+			if (trimmed.length > 0) {
+				const parsed = parseJsonLine(trimmed);
+				if (parsed === null) bad += 1;
+				else out.push(parsed);
+			}
+		}
+		if (bad > 0) console.warn(`[lesson-loop] ${bad} malformed lesson line(s) skipped in ${file}`);
+		return out;
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region lib/rule-signature.ts
+/** 规则归并键。签名归一：trim + 内部空白折叠（大小写保留——路径/命令大小写有意）。 */
+function normalizeSignature(signature) {
+	if (typeof signature !== "string") return "";
+	return signature.trim().replaceAll(/\s+/gu, " ");
+}
+const CATEGORY_SIGNATURES = {
+	"factgate-deny": "edit-before-factgate",
+	"secret-path": "edit-before-secret-path"
+};
+/** 查表用 Map：Object 字面量的索引会带出原型链上的同名成员（`toString`/
+*  `constructor` 当 category 时拿到的是函数），Map 没有这个洞。 */
+const STABLE_SIGNATURES = new Map(Object.entries(CATEGORY_SIGNATURES));
+/**
+* 签名归一（写入侧唯一入口）：登记表内的类别一律折叠到类别级稳定签名，表外类别
+* 保留自身签名（行为与折叠前逐字节相同）。幂等——稳定签名再查一次仍是自身，
+* 所以存量卡与新建卡走同一个键。report()/pass()/addCandidate() 与卡片查找必须
+* 全部经这里，任何一处漏调都会造成"写得进、查不到"的键漂移。
+*/
+function stableSignatureFor(category, signature) {
+	const normalized = normalizeSignature(signature);
+	return STABLE_SIGNATURES.get(category) ?? normalized;
+}
+/** 路径/文件名形态签名判定（迁移归并的识别器）。 */
+function looksLikePathSignature(signature) {
+	return signature.includes("/") || signature.includes("\\") || /^\.{1,2}[/\\]/u.test(signature) || /\.(?:tsx?|jsx?|mjs|cjs|rs|py|go|java|kt|swift|vue|svelte|json|ya?ml|css|scss|html|md|sh|sql|toml|c|cpp|h|hpp|lock)$/iu.test(signature);
+}
+function ruleKey(project, category, signature) {
+	return `${project}\u0000${category}\u0000${normalizeSignature(signature)}`;
+}
+//#endregion
+//#region lib/messages.ts
+/**
+* host 半的整行模板插值：`{name}` 取参数，取不到的占位符**原样留着**
+* （少传一个参数是编程错误，不该让文案里凭空多出空白；官方 client locale 同语义）。
+* @param template - 字典里的整行模板。
+* @param params - 占位符对应的值。
+* @returns 插值完成的文本。
+*/
+function fill(template, params) {
+	return template.replaceAll(/\{(?<name>\w+)\}/gu, (matched, name) => {
+		const value = params[name];
+		return value === void 0 ? matched : String(value);
+	});
+}
+const MESSAGES = {
+	zh: {
+		sectionText: [
+			"## lesson-loop 自进化环",
+			"本环境运行教训闭环：危险操作拦截、门禁失败、异常续跑、人工差评等事件会自动沉淀为项目教训，达到阈值的教训蒸馏为候选规则，经用户在设置卡确认后成为经验规则（armed），并在会话开始注入。",
+			"- 被守卫拒绝时：按拒绝信息补齐证据后重试，不要换措辞绕过；拒绝本身是可学习信号。",
+			"- 会话开始若注入了\"经验规则\"，视为高优先级约束，执行中主动遵守。",
+			"- 用户可用 /lessons-digest 把本会话人工差评即时蒸馏为教训。"
+		].join("\n"),
+		digestHeading: "[lesson-loop] 本项目经验规则（人工确认生效；执行中请主动遵守，违反会被度量统计）：",
+		digestRuleLine: "{index}. {statement}（{day} 生效{metrics}）",
+		armedMetrics: "，armed 后复发 {violation} 次 / 被遵守 {suppressed} 次 / 暴露 {samples} 次",
+		armedNoTrigger: "，armed 后在场 {samples} 次会话但未触发（尚无可判定证据）",
+		statusCandidate: "待确认",
+		statusArmed: "生效中",
+		statusDemoted: "已降级待人审",
+		statusRejected: "已拒绝",
+		statusArchived: "已归档",
+		ruleSummary: "[{label}]{statement}（{category} · {signature} · 观察 {occurrences} 次{metrics}）",
+		ruleSummaryArmed: " · 复发 {violation} / 被遵守 {suppressed} / 暴露 {samples}",
+		statementFactgateStable: "编辑文件之前，必须先成功 read 该文件，并做项目级引用检索（grep/glob/zg_search 覆盖引用面）确认改动波及面（调用方/依赖方/测试），再动手。",
+		statementFactgateRejected: "已拒绝的历史路径碎片归档汇总（{signature}）：编辑文件前先取证的要求由上方生效规则承载；本条仅保留拒绝记录与证据，不注入、不度量。",
+		statementFactgatePath: "编辑 {signature} 之前，必须先成功 read 该文件，并做项目级引用检索（grep/glob/zg_search 覆盖引用面），按证据档位补齐 test/e2e/docs 层探查后再动手。",
+		statementDangerousBash: "避免使用危险 shell 形态（{signature}）。需要同类操作时先向用户说明风险或改用安全替代（如去掉 --no-verify、先确认再删除、用包管理器替代 curl|sh）。",
+		statementSecretPathStable: "不要编辑密钥/凭据类文件（.env、*.key、token 配置等）；确需变更时先征得用户明确同意，并最小化接触面。",
+		statementSecretPathTarget: "不要编辑密钥/凭据类文件（{signature}）；确需变更时先征得用户明确同意，并最小化接触面。",
+		statementGateFailure: "结束回合前先本地运行 {signature} 自检并修完再收口；该门禁在此项目已多次失败，不要假设\"应该能过\"。",
+		statementTransientFailure: "{signature} 出现过瞬时失败（限流/服务端/超时）。遇到同类失败保持冷静等待自动续跑，不要丢弃已有进度重做。",
+		statementMaxTokens: "长输出任务主动分段交付，避免单回合输出撞 max-tokens 上限被截断。",
+		statementUnfinishedTurn: "回合结束前把任务清单收口：完成一项勾一项，不要带着未闭合的待办结束回合。",
+		statementGeneric: "避免重复以下问题：{signature}（详见证据）。",
+		digestSystemRole: "你是工程质量教练。输入是一次会话的人工差评与该项目的历史教训，请把差评归纳为可执行的候选规则。",
+		digestSystemShape: "输出严格为 JSON 数组，不要输出任何其他文字。数组每项形如：",
+		digestSystemShapeSignature: "同类问题的稳定短键，如命令/路径/场景名",
+		digestSystemShapeStatement: "规则正文：具体、可执行、可判定，说明该怎么做而不是只说不要做",
+		digestSystemRules: "要求：每条规则必须是\"下次怎么避免\"的可执行指令；差评之间同因合并；没有差评信号时输出 []；不编造差评里没有的事实。",
+		digestSectionFeedback: "## 本会话人工差评",
+		digestSectionBackground: "## 该项目历史教训（背景，防止重复提出已存在的规则）",
+		digestSectionExtra: "## 用户附加说明",
+		digestNoFeedback: "（无）",
+		digestScopeMessage: "【消息差评】",
+		digestScopeSession: "【会话备注】",
+		digestCategorySuffix: "（分类 {category}）",
+		lessonsNoHistory: "（本项目暂无历史教训记录）",
+		digestCommandDescription: "把本会话人工差评与近期教训蒸馏为候选规则（lesson-loop，人工触发）",
+		digestInputHint: "[附加说明]",
+		digestRejectedDisabled: "lesson-loop 的总开关或上报开关处于关闭状态，未执行蒸馏。",
+		digestRejectedNoSession: "/lessons-digest 需要在会话内执行（找不到当前会话）。",
+		digestRejectedNoLlm: "llm 服务不可用，无法蒸馏。",
+		digestNoNewRules: "差评 {count} 条已分析，未归纳出新规则（可能已存在或信号不足）。",
+		digestCreated: "已蒸馏 {count} 条候选规则（待你在设置卡确认后生效）：\n{lines}",
+		digestCreatedLine: "{index}. [{category}] {statement}",
+		digestFailed: "蒸馏失败：{reason}",
+		errNoModelSelection: "当前无可用模型选择（agentDefaultModel）",
+		errMissingFinishChunk: "模型返回流缺少 finish 块",
+		errIncompleteFinish: "模型整理未正常完成（{kind}{failure}）",
+		errEmptyDigest: "模型整理结果为空",
+		errInvalidJsonBody: "请求体不是合法 JSON",
+		errIdAndActionRequired: "缺少 id 或 action",
+		errUnknownAction: "未知操作：{action}",
+		errRuleNotFound: "找不到该规则",
+		errRuleActionFailed: "规则操作失败"
+	},
+	en: {
+		sectionText: [
+			"## lesson-loop self-evolution loop",
+			"This environment runs a lesson loop: guard denials, gate failures, abnormal resumptions and human negative feedback are recorded as project lessons, lessons reaching the threshold are distilled into candidate rules, and a rule becomes an armed rule only after the user confirms it in the settings card — armed rules are injected at the start of each session.",
+			"- When a guard denies you: supply the missing evidence as the denial says, then retry. Do not rephrase your way around it; the denial itself is a learnable signal.",
+			"- If a session starts with injected experience rules, treat them as high-priority constraints and follow them while working.",
+			"- The user can run /lessons-digest to distill this session's negative feedback into lessons."
+		].join("\n"),
+		digestHeading: "[lesson-loop] Experience rules for this project (human-confirmed; follow them while working — violations are measured):",
+		digestRuleLine: "{index}. {statement} (armed on {day}{metrics})",
+		armedMetrics: ", {violation} violations / {suppressed} followed / {samples} exposed since arming",
+		armedNoTrigger: ", present in {samples} sessions since arming but never triggered (no evidence to judge yet)",
+		statusCandidate: "pending review",
+		statusArmed: "armed",
+		statusDemoted: "demoted, needs review",
+		statusRejected: "rejected",
+		statusArchived: "archived",
+		ruleSummary: "[{label}]{statement} ({category} · {signature} · {occurrences} observations{metrics})",
+		ruleSummaryArmed: " · {violation} violations / {suppressed} followed / {samples} exposed",
+		statementFactgateStable: "Before editing a file, read it successfully first and run a project-wide reference search (grep/glob/zg_search over the referencing surface) to confirm the blast radius — call sites, dependents, tests — before touching anything.",
+		statementFactgateRejected: "Archived summary of the rejected historical path fragments ({signature}): the requirement to gather evidence before editing is carried by the armed rule above; this entry only keeps the rejection record and the evidence — it is never injected and never measured.",
+		statementFactgatePath: "Before editing {signature}, read that file successfully first and run a project-wide reference search (grep/glob/zg_search over the referencing surface); close the test/e2e/docs evidence tiers before making the change.",
+		statementDangerousBash: "Avoid dangerous shell shapes ({signature}). When the same operation is really needed, explain the risk to the user first or switch to a safe alternative (drop --no-verify, confirm before deleting, use a package manager instead of curl|sh).",
+		statementSecretPathStable: "Do not edit secret/credential files (.env, *.key, token configs and the like); when a change is genuinely required, get the user's explicit consent first and keep the touched surface minimal.",
+		statementSecretPathTarget: "Do not edit secret/credential files ({signature}); when a change is genuinely required, get the user's explicit consent first and keep the touched surface minimal.",
+		statementGateFailure: "Before ending the turn, run {signature} locally and fix everything it reports; this gate has failed repeatedly in this project, so never assume \"it should pass\".",
+		statementTransientFailure: "{signature} has failed transiently before (rate limit / server side / timeout). When the same kind of failure shows up, stay calm and wait for the automatic resumption — do not discard the progress you already have.",
+		statementMaxTokens: "Deliver long output tasks in segments on purpose, so a single turn never hits the max-tokens ceiling and gets truncated.",
+		statementUnfinishedTurn: "Close out the task list before ending the turn: tick an item as soon as it is done, and never end a turn with unresolved to-dos.",
+		statementGeneric: "Do not repeat the following problem: {signature} (see the evidence).",
+		digestSystemRole: "You are an engineering-quality coach. The input is the human negative feedback from one session plus this project's historical lessons; distil the feedback into actionable candidate rules.",
+		digestSystemShape: "Output strictly a JSON array and nothing else. Each item has this shape:",
+		digestSystemShapeSignature: "a stable short key for the same kind of problem, e.g. command/path/scenario name",
+		digestSystemShapeStatement: "the rule statement: concrete, actionable, decidable — say what to do, not merely what not to do",
+		digestSystemRules: "Requirements: every rule must be an actionable instruction on how to avoid the problem next time; merge feedback sharing one cause; output [] when there is no negative-feedback signal; never invent facts absent from the feedback.",
+		digestSectionFeedback: "## Human negative feedback in this session",
+		digestSectionBackground: "## Historical lessons of this project (background, do not re-propose existing rules)",
+		digestSectionExtra: "## User's additional note",
+		digestNoFeedback: "(none)",
+		digestScopeMessage: "[message feedback]",
+		digestScopeSession: "[session note]",
+		digestCategorySuffix: " (category {category})",
+		lessonsNoHistory: "(no lesson records for this project yet)",
+		digestCommandDescription: "Distil this session's human negative feedback and recent lessons into candidate rules (lesson-loop, manually triggered)",
+		digestInputHint: "[additional note]",
+		digestRejectedDisabled: "lesson-loop's master switch or report switch is off — distillation was not run.",
+		digestRejectedNoSession: "/lessons-digest must run inside a session (no current session found).",
+		digestRejectedNoLlm: "The llm service is unavailable — distillation is impossible.",
+		digestNoNewRules: "{count} negative feedback item(s) analysed; no new rule was distilled (it may already exist or the signal is too weak).",
+		digestCreated: "{count} candidate rule(s) distilled (they take effect once you confirm them in the settings card):\n{lines}",
+		digestCreatedLine: "{index}. [{category}] {statement}",
+		digestFailed: "Distillation failed: {reason}",
+		errNoModelSelection: "No model selection is available (agentDefaultModel)",
+		errMissingFinishChunk: "The model stream is missing its finish chunk",
+		errIncompleteFinish: "The model digest did not finish normally ({kind}{failure})",
+		errEmptyDigest: "The model digest result is empty",
+		errInvalidJsonBody: "invalid json body",
+		errIdAndActionRequired: "id and action required",
+		errUnknownAction: "unknown action: {action}",
+		errRuleNotFound: "rule not found",
+		errRuleActionFailed: "rule action failed"
+	}
+};
+//#endregion
+//#region lib/statement-draft.ts
+/**
+* 候选规则 statement 模板：按分类起草，signature 原文嵌入（可读性优先）。
+* @param category - 教训分类（决定模板选型）。
+* @param signature - 归一后的签名（嵌进模板，或作为 feedback-digest 的正文）。
+* @param messages - 当前语言的消息表。
+* @returns 起草出的规则正文。
+*/
+function draftStatement(category, signature, messages) {
+	switch (category) {
+		case "factgate-deny":
+			if (signature === CATEGORY_SIGNATURES["factgate-deny"]) return messages.statementFactgateStable;
+			if (signature.endsWith(":rejected")) return fill(messages.statementFactgateRejected, { signature });
+			return fill(messages.statementFactgatePath, { signature });
+		case "dangerous-bash": return fill(messages.statementDangerousBash, { signature });
+		case "secret-path":
+			if (signature === CATEGORY_SIGNATURES["secret-path"]) return messages.statementSecretPathStable;
+			return fill(messages.statementSecretPathTarget, { signature });
+		case "gate-failure": return fill(messages.statementGateFailure, { signature });
+		case "transient-failure": return fill(messages.statementTransientFailure, { signature });
+		case "max-tokens": return messages.statementMaxTokens;
+		case "unfinished-turn": return messages.statementUnfinishedTurn;
+		case "feedback-digest": return signature;
+		default: return fill(messages.statementGeneric, { signature });
+	}
+}
+//#endregion
+//#region lib/decay-policy.ts
+const DEFAULT_DECAY = {
+	demoteThreshold: 3,
+	demoteMinSamples: 5,
+	demoteRatio: .5,
+	decayDays: 30
+};
+/** 单条 armed 规则的衰减裁决：'demote'（有真实证据的高复发率）| 'undeterminable'
+*  （armed 够久却既无复发也无一次干净命中，机器无从裁定）| 'keep'。 */
+function decayVerdict(rule, policy, now) {
+	if (rule.status !== "armed") return "keep";
+	const evidence = rule.violation + rule.suppressed;
+	const matured = now - (rule.lastViolationAt ?? rule.lastSuppressedAt ?? rule.armedAt ?? rule.createdAt) > policy.decayDays * 864e5;
+	if (rule.suppressed === 0 && (matured || rule.violation >= policy.demoteThreshold)) return "undeterminable";
+	if (rule.suppressed > 0 && rule.violation >= policy.demoteThreshold && evidence >= policy.demoteMinSamples && rule.violation / evidence >= policy.demoteRatio) return "demote";
+	return "keep";
+}
+//#endregion
+//#region lib/lesson-store.ts
+const RULE_STATUSES = /* @__PURE__ */ new Set([
+	"candidate",
+	"armed",
+	"demoted",
+	"rejected",
+	"archived"
+]);
+function isRuleStatus(value) {
+	return typeof value === "string" && RULE_STATUSES.has(value);
+}
+/**
+* `/lessons-digest` 蒸馏生产者的来源名——**同一个串在两处枚举面出现**：既是内置来源
+* `KnownLessonSource` 的一员（`digest.ts` 上报时带它），也是蒸馏建卡的 `RuleOrigin`
+* （`addCandidate` 的默认 source 与 origin）。字面量写四遍就改四处，故收成这一枚。
+*/
+const LESSONS_DIGEST_SOURCE = "lessons-digest";
+/** 内置五个之外的兜底来源名。 */
+const FALLBACK_LESSON_SOURCE = "manual";
+/** 来源名长度上限：防把整段错误文本塞进来源字段（枚举面失控、卡片无法归因）。 */
+const MAX_LESSON_SOURCE_LENGTH = 64;
+/**
+* 来源归一（开放集）：trim 后非空且不过长 → 原样保留（第三方插件得以自报家门，
+* 其教训与内置来源一样可入库、可统计）；空/非字符串/超限 → manual。
+*
+* 为什么退 manual 而不是拒收：manual 是"有人记了这条、但说不出是谁"的最保守归属，
+* 不因此把它当成某个内置生产者的机器上报（内置来源的归因语义不许被稀释）。
+*/
+function normalizeLessonSource(value) {
+	if (typeof value !== "string") return FALLBACK_LESSON_SOURCE;
+	const trimmed = value.trim();
+	if (trimmed.length === 0 || trimmed.length > MAX_LESSON_SOURCE_LENGTH) return FALLBACK_LESSON_SOURCE;
+	return trimmed;
+}
+/** 归一后落回 manual 的"本来说了别的"情形：必须留日志，否则第三方接入只表现为静默降级。 */
+function noteSourceFallback(raw, source) {
+	if (source === FALLBACK_LESSON_SOURCE && typeof raw === "string" && raw.trim().length > 0) console.warn(`[lesson-loop] lesson source "${raw.trim().slice(0, 72)}" 不可用（非空但超 ${String(MAX_LESSON_SOURCE_LENGTH)} 字符），按 manual 记账`);
+	return source;
+}
+const RULE_ORIGINS = /* @__PURE__ */ new Set([
+	"threshold",
+	LESSONS_DIGEST_SOURCE,
+	"manual"
+]);
+function isRuleOrigin(value) {
+	return typeof value === "string" && RULE_ORIGINS.has(value);
+}
+/** origin 归一：字段缺失的存量卡都出自阈值归并（digest 建卡更晚），故退 threshold。 */
+function originOf(value) {
+	return isRuleOrigin(value) ? value : "threshold";
+}
+/** status 归一：漂移状态退 archived（不注入、不度量的最保守态），人工可 revive。 */
+function statusOf(value) {
+	return isRuleStatus(value) ? value : "archived";
+}
+/** 字符串字段归一：非字符串（缺字段/类型漂移）退兜底，绝不整条丢弃。 */
+function strField(value, fallback) {
+	return typeof value === "string" ? value : fallback;
+}
+/** 数值字段读取：只认 number 与数字字符串两种存量形态；NaN/null/布尔/对象一律视为漂移。 */
+function numericOf(value) {
+	let result;
+	if (typeof value === "number" || typeof value === "string") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) result = parsed;
+	}
+	return result;
+}
+/** 必填数值字段归一：漂移退兜底（计数与时间戳缺了就没法渲染、排序、衰减）。 */
+function numField(value, fallback) {
+	return numericOf(value) ?? fallback;
+}
+/** 未知数组：非数组退空表（不经 any 扩散，逐元素仍是 unknown）。 */
+function unknownArray$1(value) {
+	return Array.isArray(value) ? value : [];
+}
+/**
+* 落盘失败回执的 reason（与 not-found 区分：前者是"没存住、可重试"，后者是 id 错了）。
+*
+* 一次写不出两类失败，全部收成这一个值，因为它对调用方只有一层含义：**这一次改动没
+* 有进到规则库**。为什么不再是旧契约那句"内存已改、只是没落盘"——本文件已没有跨调用
+* 存活的内存数组（每笔改动都从端口重读、在"这一刻"的数组上重放，见 LessonStore.commit），
+* "没落盘"因此就等于"没生效"：
+*   (a) 端口明确拒绝（rejected，含 usable:false 的不可写面）：连别人的最新状态都没读到
+*       可信值，这一次改动既不许写出去、也不留在任何地方——留着就是替坏数据背书。
+*   (b) CAS 冲突耗尽（conflict 用满 RULES_CAS_RETRY_LIMIT）：对方确实在推进 revision，
+*       这一次改动同样不外推、不缓存，重试权交回拿着回执的调用方；下一笔仍旧先重读端口，
+*       于是永远不可能拿陈旧内存覆掉别人写好的卡。
+* 两类共用一个回执值：调用方的处置动作（提示重试）完全一致，差别只落在端口回执与
+* commit 的重试行为上（(a) 不重试、(b) 重读到上限）。
+*/
+const PERSIST_FAILED = "rules-not-persisted";
+/**
+* CAS 冲突后的"重读 + 重放"上限。
+*
+* 3 次足够：冲突只会来自"另一个进程/另一条写队列在我读之后推进了 revision"，
+* 每轮重试都会拿到含对方改动的新数组，重放的是本进程这一次改动。超过上限仍冲突
+* 说明写队列被卡住：按 PERSIST_FAILED 注释里的 (b) 类回执，不外抛，也不把这一次改动
+* 缓存下来等下一笔顺手写走。
+* ⚠ 上限值只在 commit() 用；测试侧要钉的是"读 N 次、写 N 次"这个数本身，故那边写死字面量
+* （引常量就成了自证），这里不再开 export 面。
+*/
+const RULES_CAS_RETRY_LIMIT = 3;
+/** cwd → 项目桶。派生本体在 shared/lib/project-key.ts（与 quality-gate 的
+*  deriveAgentId 同源）；此处只留本包的既有导出名，别再长第二份实现。 */
+function deriveProject(cwd) {
+	return deriveProjectKey(cwd);
+}
+/** 可选字符串字段：非空字符串才认（缺失/空串/类型漂移一律视为"没有这个字段"，
+*  读写两侧都不写 undefined 键——exactOptionalPropertyTypes 下键存在与否有语义）。 */
+function nonEmptyString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function observeLesson(rec, now) {
+	const rawSignature = normalizeSignature(rec.signature);
+	const cwd = nonEmptyString(rec.cwd);
+	return {
+		rec,
+		now,
+		rawSignature,
+		signature: stableSignatureFor(rec.category, rawSignature),
+		...cwd === void 0 ? {} : { cwd }
+	};
+}
+/** 证据行组装：发生折叠时把原始签名（路径/命令行）随证据落下，键只管汇聚。 */
+function evidenceRow(ts, source, detail, raw, folded) {
+	return {
+		ts,
+		source,
+		detail,
+		...raw === folded ? {} : { signature: raw }
+	};
+}
+/** 状态权威序（同键撞卡时谁当主卡）：人工决定 > 机器状态，与 migrateFragmentRules
+*  "人工升格/拒绝不被机器改写"的同一条红线；同级再看观察次数。 */
+const STATUS_AUTHORITY = {
+	candidate: 0,
+	demoted: 0,
+	archived: 1,
+	rejected: 2,
+	armed: 3
+};
+/**
+* 挑主卡：返回 [主卡, 被并卡]。人工状态优先（armed > rejected > archived > 候选/
+* 降级），同级取 occurrences 多者（保持入参顺序优先，结果与卡片在列表里的位置无关）。
+* 因为 armed 一定胜出，被丢掉的那张不可能带着未迁移的 violation/suppressed ——
+* 不需要 migrateProjectFragments 里那步 inheritArmed。
+*/
+function pickMergePair(left, right) {
+	const leftAuthority = STATUS_AUTHORITY[left.status];
+	const rightAuthority = STATUS_AUTHORITY[right.status];
+	if (leftAuthority > rightAuthority) return [left, right];
+	if (rightAuthority > leftAuthority) return [right, left];
+	return left.occurrences >= right.occurrences ? [left, right] : [right, left];
+}
+/** 证据行归一：逐字段补默认（非对象的证据元素在 unknownArray 之后仍可能为 null）。 */
+function normalizeEvidenceRow(value) {
+	const row = {
+		ts: numField(fieldOf(value, "ts"), 0),
+		source: normalizeLessonSource(fieldOf(value, "source")),
+		detail: strField(fieldOf(value, "detail"), "")
+	};
+	const original = nonEmptyString(fieldOf(value, "signature"));
+	if (original !== void 0) row.signature = original;
+	return row;
+}
+/**
+* 规则卡逐字段归一（存量文件漂移容错）。
+*
+* 旧实现只查 id/category/status 就断言整张 RuleCard，缺 evidence/sources 的存量卡
+* 会在 report() 的 rule.evidence.push 处 TypeError——一条坏记录让总线**永久**抛错，
+* 而总线在守卫热路径上（danger-guard 每次拒绝都调它），等于整个自进化环瘫掉。
+* 现在只有 id 是硬要求（人工动作与度量都按 id 定位，缺 id 的记录无处安放），
+* 其余字段一律补默认值；status 漂移退 archived（不注入、不度量），见 statusOf。
+*/
+function normalizeRuleCardRow(value) {
+	const id = fieldOf(value, "id");
+	if (typeof id !== "string" || id === "") return null;
+	const armedAt = numericOf(fieldOf(value, "armedAt"));
+	const lastSeenAt = numericOf(fieldOf(value, "lastSeenAt"));
+	const lastViolationAt = numericOf(fieldOf(value, "lastViolationAt"));
+	const lastSuppressedAt = numericOf(fieldOf(value, "lastSuppressedAt"));
+	const cardCwd = nonEmptyString(fieldOf(value, "cwd"));
+	const row = {
+		id,
+		project: strField(fieldOf(value, "project"), "default"),
+		category: strField(fieldOf(value, "category"), "unknown"),
+		signature: normalizeSignature(fieldOf(value, "signature")),
+		statement: strField(fieldOf(value, "statement"), ""),
+		status: statusOf(fieldOf(value, "status")),
+		createdAt: numField(fieldOf(value, "createdAt"), 0),
+		updatedAt: numField(fieldOf(value, "updatedAt"), 0),
+		occurrences: numField(fieldOf(value, "occurrences"), 0),
+		sources: unknownArray$1(fieldOf(value, "sources")).map((entry) => normalizeLessonSource(entry)),
+		violation: numField(fieldOf(value, "violation"), 0),
+		suppressed: numField(fieldOf(value, "suppressed"), 0),
+		samples: numField(fieldOf(value, "samples"), 0),
+		recurrences: numField(fieldOf(value, "recurrences"), 0),
+		evidence: unknownArray$1(fieldOf(value, "evidence")).filter((entry) => isRecord(entry)).map((entry) => normalizeEvidenceRow(entry)),
+		origin: originOf(fieldOf(value, "origin"))
+	};
+	if (armedAt !== void 0) row.armedAt = armedAt;
+	if (cardCwd !== void 0) row.cwd = cardCwd;
+	if (lastSeenAt !== void 0) row.lastSeenAt = lastSeenAt;
+	if (lastViolationAt !== void 0) row.lastViolationAt = lastViolationAt;
+	if (lastSuppressedAt !== void 0) row.lastSuppressedAt = lastSuppressedAt;
+	return row;
+}
+/**
+* 教训行逐字段归一（JSONL 存量漂移容错）。与规则卡同一取向：category/signature
+* 之外的字段漂移不再整行丢弃，否则一次版本升级就把历史教训从管理面与蒸馏背景
+* 里抹掉（丢掉的正是要拿去归纳规则的材料）。
+*/
+function normalizeLessonRow(value) {
+	const category = fieldOf(value, "category");
+	const signature = fieldOf(value, "signature");
+	if (typeof category !== "string" || typeof signature !== "string") return null;
+	const cwd = fieldOf(value, "cwd");
+	const sessionId = fieldOf(value, "sessionId");
+	const turn = numericOf(fieldOf(value, "turn"));
+	const evidence = fieldOf(value, "evidence");
+	const row = {
+		ts: numField(fieldOf(value, "ts"), 0),
+		source: normalizeLessonSource(fieldOf(value, "source")),
+		category,
+		project: strField(fieldOf(value, "project"), "default"),
+		signature,
+		detail: strField(fieldOf(value, "detail"), "")
+	};
+	if (typeof cwd === "string") row.cwd = cwd;
+	if (typeof sessionId === "string") row.sessionId = sessionId;
+	if (turn !== void 0) row.turn = turn;
+	if (isRecord(evidence)) row.evidence = evidence;
+	return row;
+}
+/** 数字阈值归一：非法/越界用默认值（供 policy() 共用，无父级捕获）。 */
+function num(value, fallback, min = 0) {
+	return Number.isFinite(Number(value)) && Number(value) >= min ? Number(value) : fallback;
+}
+/**
+* 规则卡骨架：两条建卡路径必须长出同一形状的卡（状态一律 candidate、计数一律从 1/0
+* 起步），否则其中一条路会造出"缺字段靠读取侧补默认"的卡——度量语义就漂了。
+*/
+function newRuleCard(args) {
+	const { project, category, signature, statement, origin, source, evidence, lastSeenAt, now } = args;
+	return {
+		id: `rule-${randomUUID()}`,
+		project,
+		category,
+		signature,
+		statement,
+		status: "candidate",
+		createdAt: now,
+		updatedAt: now,
+		occurrences: 1,
+		sources: [source],
+		violation: 0,
+		suppressed: 0,
+		samples: 0,
+		recurrences: 0,
+		lastSeenAt,
+		evidence: [evidence],
+		origin,
+		...args.cwd === void 0 ? {} : { cwd: args.cwd }
+	};
+}
+/** 人工改写的正文：非空 trim 才认（空/缺省 = 保留卡片原文）。 */
+function trimmedStatement(statement) {
+	const trimmed = typeof statement === "string" ? statement.trim() : "";
+	return trimmed === "" ? void 0 : trimmed;
+}
+/**
+* 人工动作落地。arm 会清零历史度量：复发/干净/暴露三项计数属于**那一次升格**的
+* 生命周期，带着旧值进新一轮会让降级裁决读到混合证据。
+*/
+function applyRuleAction$1(rule, action, statement, now) {
+	const nextStatement = trimmedStatement(statement);
+	switch (action) {
+		case "arm":
+			if (nextStatement !== void 0) rule.statement = nextStatement;
+			rule.status = "armed";
+			rule.armedAt = now;
+			rule.violation = 0;
+			rule.suppressed = 0;
+			rule.samples = 0;
+			rule.recurrences = 0;
+			delete rule.lastViolationAt;
+			delete rule.lastSuppressedAt;
+			break;
+		case "reject":
+			rule.status = "rejected";
+			rule.recurrences = 0;
+			break;
+		case "demote":
+			rule.status = "demoted";
+			break;
+		case "archive":
+			rule.status = "archived";
+			break;
+		case "revive":
+			rule.status = "candidate";
+			rule.recurrences = 0;
+			break;
+		case "edit": if (nextStatement !== void 0) rule.statement = nextStatement;
+	}
+	rule.updatedAt = now;
+}
+/** 就地剔出一批卡（commit 的工作数组是本次读取的副本，剔除只影响这份待写内容）。 */
+function dropCards(cards, doomed) {
+	for (let cursor = cards.length - 1; cursor >= 0; cursor -= 1) {
+		const row = cards[cursor];
+		if (row !== void 0 && doomed.has(row.id)) cards.splice(cursor, 1);
+	}
+}
+/** 同 (project, category, signature) 键命中。 */
+function findByKey(cards, key) {
+	return cards.find((row) => ruleKey(row.project, row.category, row.signature) === key);
+}
+/** 归并目标卡挑选用的排序：观察次数多者在前（toSorted 不改入参，工作数组要保序）。 */
+function byOccurrences(left, right) {
+	return right.occurrences - left.occurrences;
+}
+/** 零归并（该 project 这一组无卡可并）。 */
+const CLEAN_PASS = {
+	merged: 0,
+	dirty: false
+};
+var LessonStore = class LessonStore {
+	opts;
+	repo;
+	now;
+	constructor(opts) {
+		this.opts = opts;
+		this.repo = opts.rules;
+		this.now = opts.now ?? Date.now;
+	}
+	/** 磁盘保险丝（settings 运行时可调；0 = 不设上限）。**这个字段唯一的写入归一口**：
+	*  非有限值与负数一律落 0——appendJsonl 判的是 `maxBytes > 0`，退 0 与留着负数是同
+	*  一件事，但只有归一过一次，读侧才不必再猜"库里那个数是不是半截的"。 */
+	setMaxLessonsBytes(bytes) {
+		this.opts.maxLessonsBytes = Number.isFinite(bytes) && bytes >= 0 ? bytes : 0;
+	}
+	/** settings 拉模型：宿主每次 report/decay 前把运行时阈值同步进来（pull，无需订阅）。 */
+	configure(partial) {
+		for (const [key, val] of Object.entries(partial)) if (typeof val === "number" && Number.isFinite(val)) switch (key) {
+			case "promoteThreshold":
+				this.opts.promoteThreshold = val;
+				break;
+			case "demoteThreshold":
+				this.opts.demoteThreshold = val;
+				break;
+			case "demoteMinSamples":
+				this.opts.demoteMinSamples = val;
+				break;
+			case "demoteRatio":
+				this.opts.demoteRatio = val;
+				break;
+			case "decayDays":
+				this.opts.decayDays = val;
+				break;
+			case "maxLessonsBytes":
+				this.setMaxLessonsBytes(val);
+				break;
+			case "reviveThreshold": this.opts.reviveThreshold = val;
+		}
+	}
+	/**
+	* 一次规则库改动：读 → 在**这一刻读到的数组**上重放改动 → 带 revision 的 CAS 写。
+	*
+	* 为什么必须"写前重读 + 带 revision"：本进程不是规则库的唯一作者——常驻 web 实例
+	* 与一次性 headless 进程交替写同一段设置，而 provider 对 `rules` 这个数组键是
+	* **整片覆盖**（mergeLayers 不合并数组）。写回的数组若来自陈旧读，就会把别的进程
+	* 刚写进来的卡整片抹掉（此前实测到的丢卡缺陷）。revision 被别处推进过时 provider
+	* 抛 SettingsConflictError：重读合并后的值、在新数组上重放本次改动再写，最多
+	* RULES_CAS_RETRY_LIMIT 次；仍失败按 persist-failed 语义回执，绝不外抛——总线挂在
+	* 守卫热路径上（danger-guard 每次拒绝都调它），抛穿等于整个自进化环瘫掉。
+	*
+	* 失败分两类收手（同一回执 PERSIST_FAILED，理由见 PERSIST_FAILED 的注释）：
+	*   (a) 不可信读 / 端口明确拒绝 → **一次都不写、也不重放**：usable:false 时连"别人
+	*       此刻有什么"都读不懂，写回去就是替坏数据背书；rejected 是端口自身写不进去，
+	*       重放只会重复撞同一堵墙。本文件不留任何跨调用存活的数组，所以"不落内存"这条
+	*       在结构上是自动成立的——计划改的是本次读取的副本，副本随本函数返回即丢弃。
+	*   (b) CAS 冲突（对方在推进 revision）→ 值得重放：每轮都拿含对方改动的新数组，
+	*       重放的是本进程这一次改动；用满上限仍冲突说明写队列被卡住，就此收手回执
+	*       失败，改动留在调用方手里的回执对象上（不缓存、不回滚端口）。
+	* 两类的共同底线：任何一次写都只可能带上"重读后那一刻"的他人卡，绝不整体回滚成
+	* 陈旧内存覆掉别人写好的卡。
+	*/
+	async commit(plan) {
+		const attempt = async (retryLeft) => {
+			const current = this.repo.load();
+			const trustworthy = current.usable;
+			const cards = trustworthy ? [...current.cards] : [];
+			const planned = plan(cards);
+			if (!planned.write) return {
+				ok: true,
+				value: planned.value,
+				trustworthy
+			};
+			if (!trustworthy) return {
+				ok: false,
+				value: planned.value,
+				trustworthy
+			};
+			const outcome = await this.repo.save(cards, current.revision);
+			if (outcome === "persisted") return {
+				ok: true,
+				value: planned.value,
+				trustworthy
+			};
+			if (outcome === "rejected" || retryLeft <= 0) return {
+				ok: false,
+				value: planned.value,
+				trustworthy
+			};
+			return attempt(retryLeft - 1);
+		};
+		return await attempt(RULES_CAS_RETRY_LIMIT);
+	}
+	threshold() {
+		const value = Number(this.opts.promoteThreshold);
+		return Number.isFinite(value) && value >= 1 ? Math.floor(value) : 3;
+	}
+	/** 起草用的消息表：每次现取（见 StoreOptions.messages），本文件不读 settings。 */
+	messages() {
+		return this.opts.messages();
+	}
+	policy() {
+		const { opts } = this;
+		return {
+			demoteThreshold: num(opts.demoteThreshold, DEFAULT_DECAY.demoteThreshold, 1),
+			demoteMinSamples: num(opts.demoteMinSamples, DEFAULT_DECAY.demoteMinSamples, 1),
+			demoteRatio: num(opts.demoteRatio, DEFAULT_DECAY.demoteRatio, .01),
+			decayDays: num(opts.decayDays, DEFAULT_DECAY.decayDays, 1)
+		};
+	}
+	/**
+	* 记一条教训：全量落事件流水 → 归并规则卡（armed 命中计复发；候选累积）。
+	*
+	* 键里的签名走 stableSignatureFor()：登记表内的类别一律汇聚到类别级稳定签名，
+	* 原始路径/命令行改落 evidence.signature。碎片因此**不再产生**（旧数据由
+	* migrateFragmentRules 一次性收拢）。
+	*/
+	async report(record) {
+		const now = this.now();
+		const source = noteSourceFallback(record.source, normalizeLessonSource(record.source));
+		const rec = {
+			...record,
+			source,
+			ts: Number.isFinite(record.ts) ? record.ts : now
+		};
+		appendJsonl(this.opts.lessonsFile, rec, this.opts.maxLessonsBytes ?? 0);
+		const obs = observeLesson(rec, now);
+		const key = ruleKey(rec.project, rec.category, obs.signature);
+		const outcome = await this.commit((cards) => this.planReport(cards, obs, key));
+		return this.receiptFor(outcome);
+	}
+	/** 未命中任何键 → 按类别级稳定签名开一张新候选卡；命中 → 补证据 + 按状态计度量。 */
+	planReport(cards, obs, key) {
+		const rule = findByKey(cards, key);
+		return rule === void 0 ? {
+			value: {
+				kind: "created",
+				card: LessonStore.openCandidate(cards, obs, this.messages())
+			},
+			write: true
+		} : this.accumulate(rule, obs);
+	}
+	/** 首报：开一张新候选卡并放进待写数组（静态：只吃 obs 与递来的消息表，不读实例状态）。 */
+	static openCandidate(cards, obs, messages) {
+		const { rec, now, rawSignature, signature } = obs;
+		const card = newRuleCard({
+			project: rec.project,
+			category: rec.category,
+			signature,
+			statement: draftStatement(rec.category, signature, messages),
+			origin: "threshold",
+			source: rec.source,
+			lastSeenAt: rec.ts,
+			evidence: evidenceRow(rec.ts, rec.source, rec.detail, rawSignature, signature),
+			now,
+			...obs.cwd === void 0 ? {} : { cwd: obs.cwd }
+		});
+		cards.push(card);
+		return card;
+	}
+	/** 命中已有卡：补证据 + 按状态计复发/累积/复活。 */
+	accumulate(rule, obs) {
+		const { rec, now, rawSignature, signature } = obs;
+		rule.lastSeenAt = rec.ts;
+		rule.updatedAt = now;
+		rule.evidence.push(evidenceRow(rec.ts, rec.source, rec.detail, rawSignature, signature));
+		if (!rule.sources.includes(rec.source)) rule.sources.push(rec.source);
+		if (rule.cwd === void 0 && obs.cwd !== void 0) rule.cwd = obs.cwd;
+		if (rule.status === "armed") {
+			rule.violation += 1;
+			rule.lastViolationAt = rec.ts;
+			if (decayVerdict(rule, this.policy(), now) === "demote") {
+				rule.status = "demoted";
+				rule.updatedAt = now;
+			}
+			return {
+				value: {
+					kind: "violation",
+					card: rule
+				},
+				write: true
+			};
+		}
+		if (rule.status === "candidate") {
+			rule.occurrences += 1;
+			return {
+				value: {
+					kind: "candidate",
+					card: rule
+				},
+				write: true
+			};
+		}
+		if (rule.status === "rejected" && this.noteRecurrence(rule, now)) return {
+			value: {
+				kind: "candidate",
+				card: rule
+			},
+			write: true
+		};
+		return {
+			value: {
+				kind: "settled",
+				card: rule
+			},
+			write: true
+		};
+	}
+	/** rejected 卡的复发计数：达阈值则转回候选（返回是否转回）。
+	*  转回的落点是 candidate（待人重审），不是 armed，也不清证据——机器不替人升格。 */
+	noteRecurrence(rule, now) {
+		rule.recurrences += 1;
+		if (rule.recurrences < this.reviveThreshold()) return false;
+		rule.status = "candidate";
+		rule.occurrences = rule.recurrences;
+		rule.recurrences = 0;
+		rule.updatedAt = now;
+		return true;
+	}
+	/** 组装 report() 回执：ready 只在确实落盘后才报（磁盘没存住就催人工审 = 点空）。 */
+	receiptFor(outcome) {
+		const { ok, value } = outcome;
+		const { kind, card } = value;
+		const threshold = this.threshold();
+		const ready = ok && (kind === "created" ? threshold <= 1 : card.occurrences >= threshold);
+		return {
+			ok,
+			...ok ? {} : { reason: PERSIST_FAILED },
+			...kind === "violation" ? { violationOf: card } : {},
+			...kind === "created" || kind === "candidate" ? {
+				candidate: card,
+				ready
+			} : {}
+		};
+	}
+	/** revival 阈值（StoreOptions.reviveThreshold，归一 1-20，默认 3）。 */
+	reviveThreshold() {
+		const value = Number(this.opts.reviveThreshold);
+		return Number.isFinite(value) && value >= 1 ? Math.min(20, Math.floor(value)) : 3;
+	}
+	/** pass 信号：规则场景被触发且被遵守。会话收尾清算时只有被
+	*  pass 过的 armed 规则才计 suppressed——无关会话不再灌水。
+	*  键与 report() 同源（stableSignatureFor），调用方继续传自己那条细签名。 */
+	pass(project, category, signature) {
+		const key = ruleKey(project, category, stableSignatureFor(category, signature));
+		return this.workingCards().find((row) => ruleKey(row.project, row.category, row.signature) === key && row.status === "armed");
+	}
+	/**
+	* 会话收尾清算：对本项目内每条「armed 且本会话未违规」的规则记一次暴露 samples
+	* （测没测过这条规则的判据，与 pass 无关）；其中被 pass 过的（规则场景触发且被
+	* 遵守）再计一次 suppressed=observed。被本会话违反的规则既不记 samples 也不记
+	* observed（violation 已由 report() 计）。samples 只增暴露度，绝不进复发率分母。
+	*/
+	async sessionEnded(project, violatedRuleIds, passedRuleIds, sessionId) {
+		const now = this.now();
+		if ((await this.commit((cards) => {
+			let dirty = false;
+			for (const rule of cards) if (rule.status === "armed" && rule.project === project && !violatedRuleIds.has(rule.id)) {
+				rule.samples += 1;
+				rule.updatedAt = now;
+				dirty = true;
+				if (passedRuleIds.has(rule.id)) {
+					rule.suppressed += 1;
+					rule.lastSuppressedAt = now;
+				}
+			}
+			return {
+				value: dirty,
+				write: dirty
+			};
+		})).value && sessionId !== void 0) console.info(`[lesson-loop] ${sessionId}: session settled for project ${project} (${String(passedRuleIds.size)} passed rule(s))`);
+	}
+	/** 读这一刻的规则数组（每次都是新对象：改动只作用于本次的待写副本）。
+	*  usable:false 时一律读空——"读不懂"不许当成"真的没有"，也不许当成"还有这些卡"
+	*  拿去注入/评审（那是把坏数据洗成界面事实）。 */
+	workingCards() {
+		const current = this.repo.load();
+		return current.usable ? [...current.cards] : [];
+	}
+	rules() {
+		return this.workingCards();
+	}
+	/** 人工动作：arm（可携改写后的 statement）/ reject / demote / archive / edit / revive。
+	*  返回 not-found = 可信读面上确实无此卡（id 错了，重试也没用）；persist-failed = 这一次
+	*  没存住（含端口读不懂的那种），调用方提示重试，绝不当成"规则不存在"。 */
+	async ruleAction(id, action, statement) {
+		const outcome = await this.commit((cards) => {
+			const rule = cards.find((row) => row.id === id);
+			if (rule === void 0) return {
+				value: false,
+				write: false
+			};
+			applyRuleAction$1(rule, action, statement, this.now());
+			return {
+				value: true,
+				write: true
+			};
+		});
+		if (!outcome.value) return outcome.trustworthy ? "not-found" : "persist-failed";
+		return outcome.ok ? "persisted" : "persist-failed";
+	}
+	/** /lessons-digest 与卡片手工补录直接建候选（origin 标记来源）。
+	*  键与 report() 同源：蒸馏出来的路径型签名同样折叠，否则机器建卡又会开一批碎片。 */
+	async addCandidate(input) {
+		const now = this.now();
+		const rawSignature = normalizeSignature(input.signature);
+		const signature = stableSignatureFor(input.category, rawSignature);
+		const raw = input.source ?? LESSONS_DIGEST_SOURCE;
+		const source = noteSourceFallback(raw, normalizeLessonSource(raw));
+		const key = ruleKey(input.project, input.category, signature);
+		return (await this.commit((cards) => {
+			const existing = findByKey(cards, key);
+			if (existing !== void 0) {
+				existing.updatedAt = now;
+				existing.evidence.push(evidenceRow(now, source, input.detail, rawSignature, signature));
+				if (existing.status === "candidate") existing.occurrences += 1;
+				return {
+					value: existing,
+					write: true
+				};
+			}
+			const card = newRuleCard({
+				project: input.project,
+				category: input.category,
+				signature,
+				statement: input.statement,
+				origin: LESSONS_DIGEST_SOURCE,
+				source,
+				lastSeenAt: now,
+				evidence: evidenceRow(now, source, input.detail, rawSignature, signature),
+				now
+			});
+			cards.push(card);
+			return {
+				value: card,
+				write: true
+			};
+		})).value;
+	}
+	/** 把 source 碎片并入 primary（occurrences/evidence/sources/lastSeenAt 累加；
+	*  更晚 armed 的碎片覆盖 primary 的 statement 与生效时间）。 */
+	static mergeFragment(primary, source) {
+		if (source.status === "armed" && typeof source.armedAt === "number" && source.armedAt > (primary.armedAt ?? 0)) {
+			primary.statement = source.statement;
+			primary.armedAt = source.armedAt;
+		}
+		primary.occurrences += source.occurrences;
+		primary.evidence.push(...source.evidence);
+		primary.sources = [.../* @__PURE__ */ new Set([...primary.sources, ...source.sources])];
+		if (source.lastSeenAt !== void 0 && (primary.lastSeenAt === void 0 || source.lastSeenAt > primary.lastSeenAt)) primary.lastSeenAt = source.lastSeenAt;
+	}
+	/**
+	* 存量碎片迁移（碎片化修复）：把 category 对应类别级稳定签名出现
+	* 之前的「路径型签名」候选/armed/rejected 规则归并。合并规则：
+	*   - 候选/armed 碎片并入稳定签名卡（若已存在直接并入；否则取最权威一张——
+	*     armed 优先、其次 occurrences 最多——改写为稳定签名，statement 保留人工
+	*     改写，其余并入并移除）；
+	*   - rejected 碎片并入 `${stableSig}:rejected` 汇总卡（人工拒绝语义保留：
+	*     状态 rejected、不复活、不注入；碎片卡从规则列表收敛，避免 20 条同内容
+	*     重复占据列表）；
+	*   - archived/demoted 碎片不参与（一律人工动作决定）。
+	* 按 project 分组，跨项目绝不合并。
+	* 返回并入的碎片数。
+	*/
+	async migrateFragmentRules() {
+		return (await this.commit((cards) => {
+			const pass = this.mergeFragmentsIn(cards);
+			return {
+				value: pass.merged,
+				write: pass.dirty
+			};
+		})).value;
+	}
+	/** 在待写数组上跑一遍全类别的碎片归并（数组就地收敛；产出见 MergePass）。 */
+	mergeFragmentsIn(cards) {
+		let merged = 0;
+		let dirty = false;
+		for (const [category, stableSig] of Object.entries(CATEGORY_SIGNATURES)) {
+			const candidates = cards.filter((card) => card.category === category && card.signature !== stableSig && (card.status === "candidate" || card.status === "armed" || card.status === "rejected") && looksLikePathSignature(card.signature));
+			const projects = [...new Set(candidates.map((card) => card.project))];
+			for (const project of projects) {
+				const live = candidates.filter((card) => card.project === project && card.status !== "rejected");
+				const rejected = candidates.filter((card) => card.project === project && card.status === "rejected");
+				const livePass = this.migrateProjectFragments(cards, live, category, stableSig, project);
+				const rejectedPass = this.migrateRejectedFragments(cards, rejected, category, stableSig, project);
+				merged += livePass.merged + rejectedPass.merged;
+				dirty ||= livePass.dirty || rejectedPass.dirty;
+			}
+		}
+		return {
+			merged,
+			dirty
+		};
+	}
+	/** rejected 路径碎片的归并汇总：并入该 project 一条签名 `${stableSig}:rejected`
+	*  的汇总卡（人工拒绝语义保留：状态 rejected、不复活、不注入），避免碎片卡
+	*  占据规则列表。与 armed/candidate 稳定卡不冲突（签名不同）。 */
+	migrateRejectedFragments(cards, fragments, category, stableSig, project) {
+		const summarySig = `${stableSig}:rejected`;
+		const summary = cards.find((card) => card.category === category && card.signature === summarySig && card.project === project);
+		const [busiest] = fragments.toSorted(byOccurrences);
+		const primary = summary ?? busiest;
+		if (primary === void 0) return CLEAN_PASS;
+		let merged = 0;
+		const doomed = /* @__PURE__ */ new Set();
+		for (const card of fragments) if (card.id !== primary.id) {
+			LessonStore.mergeFragment(primary, card);
+			doomed.add(card.id);
+			merged += 1;
+		}
+		let rewritten = false;
+		if (primary.signature !== summarySig) {
+			primary.signature = summarySig;
+			primary.statement = draftStatement(category, summarySig, this.messages());
+			primary.status = "rejected";
+			rewritten = true;
+		}
+		if (merged > 0 || rewritten) primary.updatedAt = this.now();
+		dropCards(cards, doomed);
+		return {
+			merged,
+			dirty: merged > 0 || rewritten
+		};
+	}
+	/** 单个 project 的候选/armed 碎片归并（产出见 MergePass）。 */
+	migrateProjectFragments(cards, fragments, category, stableSig, project) {
+		const existing = cards.find((card) => card.category === category && card.signature === stableSig && card.project === project);
+		const armedFirst = fragments.find((card) => card.status === "armed");
+		const [busiest] = fragments.toSorted(byOccurrences);
+		const primary = existing ?? armedFirst ?? busiest;
+		if (primary === void 0) return CLEAN_PASS;
+		let merged = 0;
+		let armedSource;
+		const doomed = /* @__PURE__ */ new Set();
+		for (const card of fragments) if (card.id !== primary.id) {
+			if (card.status === "armed" && armedSource === void 0) armedSource = card;
+			LessonStore.mergeFragment(primary, card);
+			doomed.add(card.id);
+			merged += 1;
+		}
+		let rewritten = false;
+		if (primary.signature !== stableSig) {
+			primary.signature = stableSig;
+			rewritten = true;
+		}
+		if (primary.status !== "armed" && armedSource !== void 0) LessonStore.inheritArmed(primary, armedSource);
+		if (merged > 0 || rewritten) primary.updatedAt = this.now();
+		dropCards(cards, doomed);
+		return {
+			merged,
+			dirty: merged > 0 || rewritten
+		};
+	}
+	/** 把 armed 碎片的生命周期度量搬到主卡（arm 期计数属于那次升格，不能留空）。
+	*  三个时间戳按静态键逐个处理：源卡缺值时必须真的删键（留 undefined 与删键在
+	*  JSON 往返后语义不同，decayVerdict 的锚点回退链会被 undefined 干扰）。 */
+	static inheritArmed(primary, armedSource) {
+		primary.status = "armed";
+		primary.violation = armedSource.violation;
+		primary.suppressed = armedSource.suppressed;
+		primary.samples = armedSource.samples;
+		if (armedSource.armedAt === void 0) delete primary.armedAt;
+		else primary.armedAt = armedSource.armedAt;
+		if (armedSource.lastViolationAt === void 0) delete primary.lastViolationAt;
+		else primary.lastViolationAt = armedSource.lastViolationAt;
+		if (armedSource.lastSuppressedAt === void 0) delete primary.lastSuppressedAt;
+		else primary.lastSuppressedAt = armedSource.lastSuppressedAt;
+	}
+	/**
+	* 一次性 project 键归一迁移：桶键派生已收敛到 shared/lib/project-key.ts（补
+	* path.resolve + realpath）。旧键是"纯字符串归一"的产物——cwd 写成相对路径、含
+	* `..` 冗余段、或经过软链（macOS /tmp ↔ /private/tmp）时，同一个项目会被切成
+	* 两个桶：教训与 armed 规则注入各看到一半。
+	*
+	* 迁移只按卡片**自己存的 cwd** 重算：
+	*   - 没存 cwd 的存量卡原样留下。project 是跨系统（记忆网关 agent_id）的桶名，
+	*     猜错一次就把别的项目的规则注进当前会话，宁可不迁；
+	*   - 重算后与别的卡撞同 (project, category, signature) 键 → 归并，主卡由人工
+	*     状态决定（见 pickMergePair），证据/观察次数按 mergeFragment 折叠；
+	*   - 幂等：第二次跑每张卡的 project 都已等于 deriveProjectKey(cwd) → 零改动、
+	*     零落盘（不会与 migrateFragmentRules 互相回退）。
+	* 已规范绝对路径的输入产出的键与旧实现逐字节相同，所以"正常机器"上这里是 no-op。
+	*/
+	async migrateProjectKeys() {
+		return (await this.commit((cards) => {
+			let rewrites = 0;
+			for (const card of cards) {
+				const cwd = nonEmptyString(card.cwd);
+				if (cwd !== void 0) {
+					const target = deriveProjectKey(cwd);
+					if (target !== card.project) {
+						card.project = target;
+						rewrites += 1;
+					}
+				}
+			}
+			if (rewrites === 0) return {
+				value: {
+					rewrites: 0,
+					merged: 0
+				},
+				write: false
+			};
+			return {
+				value: {
+					rewrites,
+					merged: this.mergeProjectKeyCollisions(cards)
+				},
+				write: true
+			};
+		})).value;
+	}
+	/** project 重算后按 (project, category, signature) 键归并撞车的卡，返回被并掉的张数。
+	*  顺带守住"一键一卡"不变式：report()/addCandidate() 都按这个键查找，库里同键留两张
+	*  等于第二张永远查不到（观测堆在没人看的卡上）。 */
+	mergeProjectKeyCollisions(cards) {
+		const survivors = /* @__PURE__ */ new Map();
+		const doomed = /* @__PURE__ */ new Set();
+		const now = this.now();
+		let merged = 0;
+		for (const card of cards) {
+			const key = ruleKey(card.project, card.category, card.signature);
+			const kept = survivors.get(key);
+			if (kept === void 0) survivors.set(key, card);
+			else {
+				const [primary, extra] = pickMergePair(kept, card);
+				LessonStore.mergeFragment(primary, extra);
+				primary.updatedAt = now;
+				survivors.set(key, primary);
+				doomed.add(primary === kept ? extra.id : kept.id);
+				merged += 1;
+			}
+		}
+		dropCards(cards, doomed);
+		return merged;
+	}
+	/** 该规则当前是否"不可判定"（armed 够久却 violation+suppressed 双零）。派生态，
+	*  每次按当前 policy/now 现算，不落库——规则重新被触发（violation 或 pass 计数）
+	*  即自然退出该态。 */
+	isUndeterminable(rule) {
+		return decayVerdict(rule, this.policy(), this.now()) === "undeterminable";
+	}
+	/** 全部"不可判定"的 armed 规则（供 /stats 汇总与卡片提示；人工可停用/归档）。 */
+	undeterminableRules() {
+		return this.rules().filter((rule) => this.isUndeterminable(rule));
+	}
+	/** 周期衰减：对全部 armed 规则执行裁决。降级会改状态并落盘；"不可判定"只是派生
+	*  提示态（状态仍 armed，等人处理），不改盘。auto-archive 已被不可判定取代。 */
+	async runDecay() {
+		const now = this.now();
+		const policy = this.policy();
+		const outcome = await this.commit((cards) => {
+			let demoted = 0;
+			let undeterminable = 0;
+			for (const rule of cards) {
+				const verdict = decayVerdict(rule, policy, now);
+				if (verdict === "demote") {
+					rule.status = "demoted";
+					rule.updatedAt = now;
+					demoted += 1;
+				} else if (verdict === "undeterminable") undeterminable += 1;
+			}
+			return {
+				value: {
+					demoted,
+					undeterminable
+				},
+				write: demoted > 0
+			};
+		});
+		const { demoted, undeterminable } = outcome.value;
+		if (demoted + undeterminable > 0) console.info(`[lesson-loop] decay: ${demoted} demoted, ${undeterminable} undeterminable`);
+		return outcome.value;
+	}
+	/** 近期教训（project 过滤可选；limit ≤ 0 = 全量——内容零截断）。 */
+	recentLessons(project, limit = 0) {
+		const out = [];
+		for (const row of readJsonl(this.opts.lessonsFile)) {
+			const lesson = normalizeLessonRow(row);
+			if (lesson !== null && (project === void 0 || lesson.project === project)) out.push(lesson);
+		}
+		return limit > 0 ? out.slice(-limit) : out;
+	}
+	lessonsCount() {
+		return readJsonl(this.opts.lessonsFile).length;
+	}
+};
+//#endregion
+//#region lib/prompt.ts
+/** systemPrompt 常驻段（order 1560：zvec-grep routing 1550 之后，紧贴工具规则面）。 */
+const SECTION_NAME = "lesson-loop";
+const SECTION_ORDER = 1560;
+/**
+* 本插件的身份串——**全包唯一定义**：host.ts 从这里导入（服务名 / 开关命名空间
+* `lesson-loop` / cache 子目录 / 注入消息 id 前缀都用它），不再自带第二份。
+* 上方 SECTION_NAME 是同一插件的另一面（systemPrompt 段的命名），值相同但语义
+* 独立，两条各有测试钉住（test/prompt.test.ts、test/host.test.ts）。
+* client 半的 `src/client-entry.ts` 另有一份 `NS`：那是独立打包的另一半，吃不到 host lib。
+*/
+const PLUGIN_NAME = "lesson-loop";
+/**
+* 本插件注入消息的 producer-owned source.kind——**全包唯一定义**：host 的 armed
+* 规则摘要注入（agent.inject）与 lib/digest.ts 的蒸馏请求帧都从这里导入。此前两侧
+* 各写一遍同值常量（同一生产者两份身份声明），改一处漏一处就会让"注入时写的 kind"
+* 与"读回时比的 kind"分家。
+*
+* 0.1.7 的 V4 准入拒收退役包装 `{ kind: 'plugin', plugin }`（session-format-v3-to-v4
+* 的 message-sources.ts 对每个声明的持久消息位抛 "format v4 message requires a
+* producer-owned source kind"；agent.inject 经 inbox 落 `agent/inbox/spliced`，正是
+* 被拒的持久位），而迁移表给未知插件名统一加 `plugin:` 前缀（sources.ts
+* producerKind），故本插件已迁移的历史行读回也是这个串。`form` 属于本插件自己的
+* 元数据，迁移只改写身份字段，它原样保留。
+*/
+const LESSON_SOURCE_KIND = `plugin:${PLUGIN_NAME}`;
+/** 常驻段正文（取自消息表；关闭时段文本由 host 侧返空串）。 */
+function renderSectionText(messages) {
+	return messages.sectionText;
+}
+/**
+* 不可信正文的引用标记：每行行前置一个帧本身永不使用的字符。
+*
+* 定界的可证性就来自这一点——帧的结构符（`[lesson-loop]` 抬头、`1.` 编号行、
+* `##` 分节、`-` 背景条目）都在行首，而经 fenceUntrusted 的正文行一律以引用标记
+* 开头，故「行首结构符」只能由帧自己产生；正文再夹带结构符会连同其自带的引用
+* 一起被改写（见 STRUCTURAL_LEAD），最坏是双标记行，永远撞不上单标记的帧行。
+*/
+const QUOTE_MARK = "│ ";
+/** 行首结构符：编号（1. / 1）/ 1、）、分隔线、标题、标签、列表与引用符。 */
+const STRUCTURAL_LEAD = /^[│\s]*(?:\d{1,9}[.)、]|-{3,}|\*{3,}|_{3,}|={3,}|#{1,6}|\[lesson-loop\]|[-*+>](?=[ \t]))/iu;
+/** 改写行首结构符：整段用全角方括号包住（只增不减，绝不截断正文）。 */
+function defuseLead(line) {
+	return line.replace(STRUCTURAL_LEAD, (matched) => `【${matched}】`);
+}
+/**
+* 把不可信文本嵌入注入帧/蒸馏提示前的定界改写（零截断：只做前缀与包括号，
+* 原文字符一个不丢）。逐行加引用标记 + 改写行首结构符，双向保证嵌入内容
+* 伪造不出新的编号条目、分节标题或分隔线。
+*/
+function fenceUntrusted(text) {
+	return text.split("\n").map((line) => `${QUOTE_MARK}${defuseLead(line)}`).join("\n");
+}
+/**
+* armed 规则的度量尾巴：三个计数器语义不同——复发/被遵守是"测到过"的真实证据，
+* 暴露只是"在场"。从没被测到（复发与被遵守皆零）时明说"尚无证据"，而不是伪造百分比。
+* 双零（连暴露都没有）不拼任何尾巴。无 armed 摘要以外的调用者，故不导出。
+*/
+function armedMetric(messages, rule) {
+	if (rule.violation + rule.suppressed > 0) return fill(messages.armedMetrics, {
+		violation: rule.violation,
+		suppressed: rule.suppressed,
+		samples: rule.samples
+	});
+	if (rule.samples > 0) return fill(messages.armedNoTrigger, { samples: rule.samples });
+	return "";
+}
+/** 会话开始注入的 armed 规则摘要。无 armed 规则返回 null（零噪音，不注入空块）。 */
+function renderRulesDigest(rules, project, messages) {
+	const armed = rules.filter((rule) => rule.status === "armed" && rule.project === project).toSorted((left, right) => (left.armedAt ?? 0) - (right.armedAt ?? 0));
+	if (armed.length === 0) return null;
+	const lines = [messages.digestHeading];
+	for (const [index, rule] of armed.entries()) {
+		const armedDay = rule.armedAt === void 0 ? "?" : new Date(rule.armedAt).toISOString().slice(0, 10);
+		lines.push(fill(messages.digestRuleLine, {
+			index: index + 1,
+			statement: fenceUntrusted(rule.statement),
+			day: armedDay,
+			metrics: armedMetric(messages, rule)
+		}));
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region lib/rules-layout.ts
+/**
+* 规则库存身的设置命名空间 = 本包 profile **条目 id**（`lesson-loop`，见 cordis.patch.yml
+* 的裸 `- id:`）。0.1.7 的注册是隐式的：宿主按条目导出的 `Config` 反推命名空间与可编辑
+* 字段，插件侧不再登记任何段。与 lib/prompt.ts 的 PLUGIN_NAME 同源，防"卡片绑的段 /
+* 端点前缀 / 这里读的段"三处字面量漂移。
+* 类型标注不是装饰：它把"段名就是插件名那一枚字面量"钉成类型，PLUGIN_NAME 若从
+* `"lesson-loop"` 变成 `string`，这里当场编译不过（段名散成宽类型正是漂移的开始）。
+*/
+const SETTINGS_NAMESPACE = PLUGIN_NAME;
+/** 规则数组在 `Config` 里的字段名（读写 `describe()` 的 value/user 都以它为键）。 */
+const RULES_FIELD = "rules";
+/** 解析后的命名空间值 → 规则卡数组（逐行归一；非数组一律空库）。 */
+function cardsOfValue(value) {
+	const out = [];
+	for (const row of unknownArray$1(fieldOf(value, RULES_FIELD))) {
+		const card = normalizeRuleCardRow(row);
+		if (card !== null) out.push(card);
+	}
+	return out;
+}
+//#endregion
+//#region lib/rules-namespace.ts
+/**
+* 单字段声明：类型判定**不在这里**发生。
+*
+* 收窄由 lib/lesson-store.ts 的 normalizeRuleCardRow 逐字段负责（既有口径：一条
+* 漂移记录不许拖垮整条总线）。schema 若把字段声明成强类型，用户手改一个
+* `occurrences: "3"` 就会让整片规则库读不出来——比旧实现更差的退化，故这里只
+* 声明"有哪些字段"（给配置面与 describe().schema 看），判定留给读取侧。
+*/
+const cardField = Schema.any();
+/** 规则卡的形状声明（与 lib/lesson-store.ts 的 RuleCard 字段一一对应）。 */
+const RuleCardSchema = Schema.object({
+	id: cardField,
+	project: cardField,
+	cwd: cardField,
+	category: cardField,
+	signature: cardField,
+	statement: cardField,
+	status: cardField,
+	createdAt: cardField,
+	updatedAt: cardField,
+	armedAt: cardField,
+	occurrences: cardField,
+	sources: cardField,
+	violation: cardField,
+	suppressed: cardField,
+	samples: cardField,
+	recurrences: cardField,
+	lastSeenAt: cardField,
+	lastViolationAt: cardField,
+	lastSuppressedAt: cardField,
+	evidence: cardField,
+	origin: cardField
+});
+/**
+* 规则库字段：本条目 `Config` 里的一个 volatile 数组（空库 = `[]`）。
+*
+* 三段各有理由，改之前逐段读：
+*   - `.volatile()`：0.1.7 只有标了 volatile 的字段会被宿主投影成设置表单并允许写入
+*     （packages/settings/settings/src/schema.ts:37-47 + index.ts:308-309/386）。规则库
+*     要活读写，这一层不能省；也因此**没有**"注册被打回"这条路了——条目 Config 的校验
+*     发生在 cordis 装载期（vendor/cordis/src/fiber.ts:50-61 resolveConfig 抛
+*     ValidationError → :645-668 整个条目不执行），插件侧无处 catch。
+*   - `.loose()`：正是为了接住上一条。用户把 `rules` 手改成非数组（`rules: 乱码`）时，
+*     数组类型判定会抛——**同段**的开关连同整条总线会跟着这个条目一起不加载。`.loose()`
+*     让子树判定失败退到该字段的默认值（vendor/schemastery/src/index.ts:551），条目照常
+*     装载，坏值只影响规则库自己。"读不懂"另有判定，见 load()。
+*   - `.default([])`：0.1.7 没有 base 层，原 RULES_BASE 的 `{ rules: [] }` 就落在这里。
+*     数组是**整片覆盖**（mergeLayers 不数组合并），所以默认值必须是完整值——空库的完整
+*     值就是 `[]`。schemastery 给 array 预置的 meta.default 本来就是 `[]`，显式写出是为了
+*     让"底座 → 默认"这条映射在 schema 上看得见。
+*/
+const RulesFieldSchema = Schema.array(Schema.union([RuleCardSchema, cardField])).loose().default([]).volatile();
+/**
+* SettingsConflictError 的判定：不值导入 @deepseek-ai/*（本插件只 type-only 用它），
+* 按官方类的两个稳定成员认（`code === 'SETTINGS_CONFLICT'` 是给人映射的机器码，
+* `name` 是类名兜底）。认出来才谈重试——其它错误重试也不会变好。
+*/
+function isSettingsConflict(error) {
+	return fieldOf(error, "code") === "SETTINGS_CONFLICT" || fieldOf(error, "name") === "SettingsConflictError";
+}
+/**
+* user 层里的 `rules` 键是不是"人改坏的形状"（存在、但不是数组）。
+*
+* 这就是 0.1.7 版的"注册被存量坏数据打回"判定：`.loose()` 让 cordis 把坏值解析成 `[]`，
+* 于是 value 层看着完全合法——只盯 value 就会把"我读不懂"当成"别人确实没写过"，下一次
+* 提交顺手把整段（连人还没修好的那部分一起）覆掉。`describe().user` 是文档原文那一层
+* （宿主用 projectForm(form, override) 投出来，只丢 undefined、不做类型修正），坏值在
+* 那里现形。修好之后这条判定自然放行，不必重启（热加载）。
+*/
+function rulesCorrupted(user) {
+	const raw = fieldOf(user, RULES_FIELD);
+	return raw !== void 0 && !Array.isArray(raw);
+}
+/** 不可用回执：读返回空、写一律拒绝（调用方按 persist-failed 语义处理）。 */
+const UNUSABLE_READ = {
+	revision: 0,
+	cards: [],
+	usable: false
+};
+/** 没有可用 CAS 面（provider 缺位 / 该段读不出可信值）时的规则库端口。 */
+function unavailableRulesRepository() {
+	return {
+		load: () => UNUSABLE_READ,
+		save: () => Promise.resolve("rejected")
+	};
+}
+/**
+* 建规则库端口。
+* @param surface provider 面；null = 该命名空间不可用（宿主没有 CAS 面）。
+*/
+function createRulesRepository(surface) {
+	if (surface === null) return unavailableRulesRepository();
+	const findDescriptor = () => {
+		const found = surface.describe().find((item) => fieldOf(item, "ns") === SETTINGS_NAMESPACE);
+		if (found === void 0) return null;
+		const revision = fieldOf(found, "revision");
+		return {
+			value: fieldOf(found, "value"),
+			user: fieldOf(found, "user"),
+			revision: typeof revision === "number" ? revision : 0
+		};
+	};
+	let corruptReported = false;
+	const reportCorruption = (corrupt) => {
+		if (corrupt && !corruptReported) {
+			corruptReported = true;
+			console.error(`[lesson-loop] rules namespace rejected: "${SETTINGS_NAMESPACE}.rules" is not an array — rule library reads empty and refuses writes (switches still work)`);
+		} else if (!corrupt) corruptReported = false;
+	};
+	return {
+		load() {
+			try {
+				const found = findDescriptor();
+				const corrupt = found !== null && rulesCorrupted(found.user);
+				reportCorruption(corrupt);
+				return found === null || corrupt ? UNUSABLE_READ : {
+					revision: found.revision,
+					cards: cardsOfValue(found.value),
+					usable: true
+				};
+			} catch (error) {
+				console.error(`[lesson-loop] rules read failed: ${errorText(error)}`);
+				return UNUSABLE_READ;
+			}
+		},
+		async save(cards, revision) {
+			try {
+				await surface.update(SETTINGS_NAMESPACE, { [RULES_FIELD]: [...cards] }, revision);
+				return "persisted";
+			} catch (error) {
+				if (isSettingsConflict(error)) return "conflict";
+				console.error(`[lesson-loop] rules write failed: ${errorText(error)}`);
+				return "rejected";
+			}
+		}
+	};
+}
+//#endregion
+//#region lib/negative-feedback.ts
+/** 消息差评投影：put 载荷即改后的完整当前值，字段漂移按空串/缺省归一。 */
+function messageFeedback(item) {
+	const messageId = fieldOf(item, "messageId");
+	const note = fieldOf(item, "note");
+	const category = fieldOf(item, "category");
+	return {
+		...typeof messageId === "string" ? { messageId } : {},
+		note: typeof note === "string" ? note : "",
+		...typeof category === "string" ? { category } : {},
+		kind: "message"
+	};
+}
+/** 占用（或复用）某条消息的槽位；新槽位按出现顺序追加。 */
+function slotFor(ledger, messageId) {
+	const existing = ledger.keyed.get(messageId);
+	if (existing !== void 0) return existing;
+	const slot = { feedback: void 0 };
+	ledger.keyed.set(messageId, slot);
+	ledger.ordered.push(slot);
+	return slot;
+}
+/** feedback/message-put：create-or-edit，按 messageId 折叠到当前态。 */
+function applyMessagePut(data, ledger, negative) {
+	const item = fieldOf(data, "item");
+	const messageId = fieldOf(item, "messageId");
+	if (typeof messageId !== "string") {
+		if (negative) ledger.ordered.push({ feedback: messageFeedback(item) });
+		return;
+	}
+	const slot = slotFor(ledger, messageId);
+	slot.feedback = negative ? messageFeedback(item) : void 0;
+}
+/** feedback/message-delete：撤回一条差评（未记账过的 messageId 与无 id 都无害）。 */
+function applyMessageDelete(data, ledger) {
+	const messageId = fieldOf(data, "messageId");
+	if (typeof messageId !== "string") return;
+	const slot = ledger.keyed.get(messageId);
+	if (slot !== void 0) slot.feedback = void 0;
+}
+/** feedback/record：会话级备注（无 rating 语义也无撤回面，人工提交原文全量纳入）。 */
+function appendSessionRecord(data, ledger) {
+	const text = fieldOf(data, "text");
+	const category = fieldOf(data, "category");
+	const textStr = typeof text === "string" ? text : "";
+	const catStr = typeof category === "string" ? category : void 0;
+	if (textStr.trim().length === 0 && catStr === void 0) return;
+	ledger.ordered.push({ feedback: {
+		note: textStr,
+		...catStr === void 0 ? {} : { category: catStr },
+		kind: "session"
+	} });
+}
+/** 单个事件对槽位台账的作用（非对象事件与未知类型都无副作用）。 */
+function applyFeedbackEvent(event, ledger) {
+	const evType = fieldOf(event, "type");
+	const evData = fieldOf(event, "data");
+	if (evType === "feedback/message-put") {
+		applyMessagePut(evData, ledger, fieldOf(fieldOf(evData, "item"), "rating") === "negative");
+		return;
+	}
+	if (evType === "feedback/message-delete") {
+		applyMessageDelete(evData, ledger);
+		return;
+	}
+	if (evType === "feedback/record") appendSessionRecord(evData, ledger);
+}
+/**
+* 从会话事件流收集人工差评（negative 评级 + 会话级备注）。全量保留 note 原文。
+*
+* `feedback/message-put` 是 create-or-edit（载荷即改后的完整当前值），
+* `feedback/message-delete` 是撤回（harness message-feedback/types.ts）。故必须按
+* messageId 折叠到当前态：只追加会把「差评改成好评」「差评已删除」继续当作负面
+* 信号喂给蒸馏模型，蒸馏结果再进规则卡注入到后续每个会话。
+*/
+function collectNegativeFeedback(events) {
+	const ledger = {
+		ordered: [],
+		keyed: /* @__PURE__ */ new Map()
+	};
+	for (const event of events) applyFeedbackEvent(event, ledger);
+	const out = [];
+	for (const slot of ledger.ordered) {
+		const { feedback } = slot;
+		if (feedback !== void 0) out.push(feedback);
+	}
+	return out;
+}
+//#endregion
+//#region lib/digest-prompt.ts
+/** 近期教训去重压背景（同 signature 只留最新一条 detail；全量文本）。 */
+function lessonsBackground(store, project, messages, limit = 40) {
+	const rows = store.recentLessons(project, limit);
+	if (rows.length === 0) return messages.lessonsNoHistory;
+	const bySig = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const sig = row.signature;
+		const prev = bySig.get(sig);
+		if (prev === void 0 || row.ts > prev.ts) bySig.set(sig, {
+			category: row.category,
+			signature: sig,
+			detail: row.detail,
+			ts: row.ts,
+			source: row.source
+		});
+	}
+	return [...bySig.values()].toSorted((left, right) => right.ts - left.ts).map((row) => `- [${fenceUntrusted(row.source)}/${fenceUntrusted(row.category)}] ${fenceUntrusted(row.signature)}\n  ${fenceUntrusted(row.detail)}`).join("\n");
+}
+/**
+* 蒸馏 system 提示里的输出契约行：JSON 键名与 category 取值域是**机器读的数据**
+* （取值域就是 `lesson-loop` 段 rules 里的归类键，翻译它等于改存储契约），故留在这里；
+* 只有两处 `<>` 里的说明走消息表。整行的两语骨架逐字节一致，见 digest.test.ts 的钉。
+*/
+const DIGEST_OUTPUT_SHAPE = "{\"category\":\"<factgate-deny|dangerous-bash|secret-path|gate-failure|transient-failure|max-tokens|unfinished-turn|feedback-digest>\",\"signature\":\"<{signature}>\",\"statement\":\"<{statement}>\"}";
+/** 输出契约行（数据骨架 + 消息表的两段说明）。 */
+function digestOutputShape(messages) {
+	return fill(DIGEST_OUTPUT_SHAPE, {
+		signature: messages.digestSystemShapeSignature,
+		statement: messages.digestSystemShapeStatement
+	});
+}
+/** 蒸馏 system 提示全文（三段来自消息表 → 输出契约行 → 一段来自消息表）。 */
+function digestSystemPrompt(messages) {
+	return [
+		messages.digestSystemRole,
+		messages.digestSystemShape,
+		digestOutputShape(messages),
+		messages.digestSystemRules
+	].join("\n");
+}
+function buildDigestPrompt(feedbacks, background, messages, extra) {
+	const fb = feedbacks.map((entry, index) => {
+		const cat = entry.category === void 0 ? "" : fill(messages.digestCategorySuffix, { category: fenceUntrusted(entry.category) });
+		const scope = entry.kind === "session" ? messages.digestScopeSession : messages.digestScopeMessage;
+		return `${index + 1}. ${scope}${cat} ${fenceUntrusted(entry.note)}`;
+	}).join("\n");
+	return [
+		messages.digestSectionFeedback,
+		fb.length > 0 ? fb : messages.digestNoFeedback,
+		"",
+		messages.digestSectionBackground,
+		background,
+		...extra !== void 0 && extra.trim().length > 0 ? [
+			"",
+			messages.digestSectionExtra,
+			fenceUntrusted(extra.trim())
+		] : []
+	].join("\n");
+}
+/** 容错解析：取首个 JSON 数组块，逐项校验字段。 */
+function parseDigestOutput(text) {
+	const start = text.indexOf("[");
+	const end = text.lastIndexOf("]");
+	if (start === -1 || end <= start) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(text.slice(start, end + 1));
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const item of unknownArray$1(parsed)) if (isRecord(item)) {
+		const category = fieldOf(item, "category");
+		const statement = fieldOf(item, "statement");
+		const signature = fieldOf(item, "signature");
+		if (typeof category === "string" && typeof statement === "string") out.push({
+			category,
+			signature: typeof signature === "string" && signature.trim().length > 0 ? signature : statement.slice(0, 60),
+			statement
+		});
+	}
+	return out;
+}
+//#endregion
+//#region lib/digest.ts
+/** 未知数组：非数组退空表（不经 any 扩散，逐元素仍是 unknown）。 */
+function unknownArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+/**
+* /lessons-digest 回执里的单条候选规则行：category 与 statement 都是模型产出
+* （不可信），逐字段定界后才进给人看的编号行。
+*/
+function digestCreatedLine(rule, index, messages) {
+	return fill(messages.digestCreatedLine, {
+		index,
+		category: fenceUntrusted(rule.category),
+		statement: fenceUntrusted(rule.statement)
+	});
+}
+/** 蒸馏墙钟的**默认值**（真值由 host 的 entry config `digestTimeoutMs` 交进来，
+*  这里只剩 schema `.default()` 的单一来源）。 */
+const DEFAULT_DIGEST_TIMEOUT_MS = 12e4;
+/**
+* drain llm.stream → 全文。流块与终态就此是**官方判别联合**（installed
+* @deepseek-ai/dsh-llm/lib/types/index.d.ts 的 `StreamChunk` 与 `FinishReason`，
+* dir-prep-organize 同批绑定）：`switch/===` 比 `chunk.type` 即收窄载荷，块换名或换字段
+* 在本文件当场编译不过——旧镜像把三块形状手抄成 `{ type?: string; text?: unknown;
+* reason?: {...} }`，那份抄本既不允许编译器认识真实的块集合，也 let 本包把"缺 text"
+* 这种事写成合法形状。
+* 交付侧的宽容保留：`typeof chunk.text === "string"` 与 `typeof failed?.message === "string"`
+* 都不删。`kind` 的兜底走 kindLabel()：官方形状说的是适配器的**契约**，
+* 而 test/digest.test.ts 钉的是**实际吐出来的块**缺字段 / kind 非字符串那几档 ——
+* 声明里有没有，和运行时读不读得懂，是两件事，缺了后者就会把 `{kind}` 印给用户。
+*/
+/**
+* 从终态块里取"结束原因"的**可打印标签**。
+*
+* 参数刻意是 `unknown` 而不是 `FinishReason`：官方判别联合声明每档必带 `kind`，
+* 那说的是适配器**承诺**的形状；跨界载荷实际会漂移（test/digest.test.ts 的 weirdReason
+* 就钉"连 kind 都缺"这一档）。若照声明类型把这里的兜底当成死代码删掉，
+* `{kind}` 会原样留在用户看得见的文案里 —— 此前就是这么改红过一条断言。
+* 按 `unknown` 建模，守卫与类型面才是同一件事，类型感知规则也不会反过来把守卫判成冗余。
+*/
+function kindLabel(reason) {
+	const kind = typeof reason === "object" && reason !== null ? Reflect.get(reason, "kind") : void 0;
+	return typeof kind === "string" && kind !== "" ? kind : "unknown";
+}
+async function drainStreamToText(stream, messages) {
+	let text = "";
+	let finish;
+	for await (const chunk of stream) if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
+	else if (chunk.type === "finish") finish = chunk.reason;
+	if (finish === void 0) throw new Error(messages.errMissingFinishChunk);
+	if (finish.kind !== "stop") {
+		const failed = finish.kind === "aborted" || finish.kind === "error" ? finish.failure : void 0;
+		const detail = typeof failed?.message === "string" ? `: ${failed.message}` : "";
+		throw new Error(fill(messages.errIncompleteFinish, {
+			kind: kindLabel(finish),
+			failure: detail
+		}));
+	}
+	return text.trim();
+}
+/**
+* 执行一次蒸馏：差评收集 → LLM 归纳 → 建候选规则（origin 'lessons-digest'）。
+* 任何一步失败都抛错由调用方呈现（命令 handler / 端点）。
+*/
+async function runDigest(store, session, llm, selection, options) {
+	const { messages, extra, events } = options;
+	if (selection?.provider === void 0 || selection.model === void 0) throw new Error(messages.errNoModelSelection);
+	const feedbacks = collectNegativeFeedback(unknownArray(events));
+	const project = deriveProject(session.header?.cwd);
+	const prompt = buildDigestPrompt(feedbacks, lessonsBackground(store, project, messages), messages, extra);
+	const controller = new AbortController();
+	const timer = setTimeout(() => {
+		controller.abort();
+	}, options.timeoutMs);
+	try {
+		const raw = await drainStreamToText(llm.stream({
+			provider: selection.provider,
+			model: selection.model,
+			messages: [{
+				id: brandString(`lesson-loop-digest-${randomUUID()}`),
+				role: "user",
+				content: [{
+					type: "text",
+					text: prompt
+				}],
+				source: {
+					kind: LESSON_SOURCE_KIND,
+					form: "instructions"
+				}
+			}],
+			system: digestSystemPrompt(messages),
+			signal: controller.signal
+		}), messages);
+		if (raw.length === 0) throw new Error(messages.errEmptyDigest);
+		const parsed = parseDigestOutput(raw);
+		const addInOrder = async (index) => {
+			const entry = parsed[index];
+			if (entry === void 0) return [];
+			const card = await store.addCandidate({
+				project,
+				category: entry.category,
+				signature: entry.signature,
+				statement: entry.statement,
+				detail: prompt,
+				source: "lessons-digest"
+			});
+			const rest = await addInOrder(index + 1);
+			return [{
+				category: card.category,
+				signature: card.signature,
+				statement: card.statement
+			}, ...rest];
+		};
+		const created = await addInOrder(0);
+		return {
+			project,
+			feedbackCount: feedbacks.length,
+			created,
+			raw
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+//#region host.ts
+/** 无可回收资源的空清理（consistent-return：effect 各分支统一返回值）。 */
+const noDisposer = () => {};
+const ALLOWED_ACTIONS = /* @__PURE__ */ new Set([
+	"arm",
+	"reject",
+	"demote",
+	"archive",
+	"edit",
+	"revive"
+]);
+function isRuleAction(value) {
+	return typeof value === "string" && ALLOWED_ACTIONS.has(value);
+}
+/**
+* `webServer` 与 `commands` 两枚可选服务**共用**的运行时判据：值是 record，且 `register`
+* 那一位可调用。两枚投影（{@link WebServerService} / {@link CommandsService}）的
+* `register` **签名**来自两份不同的官方类（`WebRoute` vs `CommandDefinition`），`Pick<>`
+* 出来是两台名义类型，收窄只能各留一枚；但结构检查只有一份，故收敛到这个函数，
+* 由两枚守卫各自一行委托（此前是两份逐字相同的六行抄本）。
+*/
+function hasCallableRegister(value) {
+	if (!isRecord(value)) return false;
+	const { register } = value;
+	return typeof register === "function";
+}
+function isWebServer(value) {
+	return hasCallableRegister(value);
+}
+function isCommandsService(value) {
+	return hasCallableRegister(value);
+}
+function isSystemPromptService(value) {
+	if (!isRecord(value)) return false;
+	const { section } = value;
+	return typeof section === "function";
+}
+function isTimerService(value) {
+	if (!isRecord(value)) return false;
+	const { timeout } = value;
+	return typeof timeout === "function";
+}
+function isSessionQueryService(value) {
+	if (!isRecord(value)) return false;
+	const { observeSession } = value;
+	return typeof observeSession === "function";
+}
+function isLlmService(value) {
+	if (!isRecord(value)) return false;
+	const { stream } = value;
+	return typeof stream === "function";
+}
+function isAgentDefaultModel(value) {
+	if (!isRecord(value)) return false;
+	const { currentSelection } = value;
+	return typeof currentSelection === "function";
+}
+/** 会话最小投影（/lessons-digest 命令入参的 agent.session）。 */
+function isSessionLike(value) {
+	return isRecord(value);
+}
+/**
+* 宿主 ctx 结构契约守卫（apply 把 Context 收窄为 HostCtx，不写断言）。
+* 核验的是 0.1.7 的实际调用面：`effect`/`on` 接线、`inject` + `fiber` 挂页面策略、
+* `settings.describe` 做跨命名空间读与规则库读。缺任一项一律急停——带着半截服务面
+* 在首个回合才崩，会被折叠成 turn kind:error 直接甩给用户。
+*/
+function isHostCtx(value) {
+	if (!isRecord(value)) return false;
+	const { effect, fiber, inject, on, settings } = value;
+	return typeof effect === "function" && typeof on === "function" && typeof inject === "function" && fiber !== void 0 && typeof fieldOf(settings, "describe") === "function";
+}
+/** stats/rules/lessons GET 端点（下发 csrf）。 */
+const STATS_PATH = "/_dsh/lesson-loop/stats";
+const RULES_PATH = "/_dsh/lesson-loop/rules";
+const LESSONS_PATH = "/_dsh/lesson-loop/lessons";
+/** 写端点（POST，csrf + 同源校验）。 */
+const RULE_ACTION_PATH = "/_dsh/lesson-loop/rule-action";
+/**
+* provider 是否具备规则库需要的 CAS 面（describe + update）；缺位即规则面不可用。
+* ⚠ 不能再探 `register`：0.1.7 已把它连同 get/installSection 一起移除，拿它当硬前置会让
+* 每一条真宿主都判成"没有 CAS 面"，规则库于是结构性失效。
+* 导出仅供单测：非记录对象这条分支在 apply 里到不了（更早就用了 svc.settings.describe），
+* 但守卫本身要对它负责，故直验而不是伪造一条走不到的装载路径。
+*/
+function isSettingsProvider(value) {
+	if (!isRecord(value)) return false;
+	const { describe, update } = value;
+	return typeof describe === "function" && typeof update === "function";
+}
+const configSchema = Schema.object({
+	enabled: Schema.boolean().default(true).volatile(),
+	reportEnabled: Schema.boolean().default(true).volatile(),
+	injectEnabled: Schema.boolean().default(true).volatile(),
+	sectionEnabled: Schema.boolean().default(true).volatile(),
+	promoteThreshold: Schema.natural().min(1).max(20).default(3).volatile(),
+	demoteThreshold: Schema.natural().min(1).max(50).default(3).volatile(),
+	demoteMinSamples: Schema.natural().min(1).max(100).default(5).volatile(),
+	demoteRatio: Schema.number().min(.05).max(1).step(.05).default(.5).volatile(),
+	decayDays: Schema.natural().min(1).max(365).default(30).volatile(),
+	reviveThreshold: Schema.natural().min(1).max(20).default(3).volatile(),
+	maxLessonsBytes: Schema.natural().max(1073741824).default(0).volatile(),
+	rules: RulesFieldSchema,
+	digestTimeoutMs: Schema.natural().min(1e3).default(DEFAULT_DIGEST_TIMEOUT_MS),
+	decayIntervalMs: Schema.natural().min(1e3).default(864e5)
+});
+/**
+* 派生数据的落盘位置：官方 cache 目录（`dshCachePath` = `$DSH_HOME/cache`，
+* DSH_HOME 未设时由 home-paths 自己按 `~/.dsh` 解析）。
+*
+* 为什么是 cache：dsh 承认的用户数据目录只有 settings 文档与 sessions/storages/
+* cache/logs，插件自开 `metrics/` 属越界（用户的手工编辑、备份、清理都不在官方面上）。
+* 事件流水正是 cache 定位的"可丢弃派生数据"——丢了能由会话与规则库重建，不该占用
+* 用户唯一那份 settings.yaml。自制 `DSH_HOME → HOME/.dsh → throw` 三态回退一并删掉：
+* 解析规则由官方包单源提供，插件不再第二份实现（也不再有"两个环境变量都没有就炸"
+* 这种热路径抛错）。
+*/
+function cacheFile(name) {
+	return dshCachePath(PLUGIN_NAME, name);
+}
+/**
+* 建规则库端口（交给 LessonStore）。0.1.7 起这里**不注册任何东西**：命名空间与 `rules`
+* 字段都是宿主从条目导出的 Config 反推的（`settings.register` 已移除）。
+*
+* 两条降级路径：
+*   - provider 没有 CAS 面（describe/update 缺位）→ 这里当场点破并让规则面读空写拒，
+*     设置卡开关照改照生效；这条判据与装载次序无关，所以留在装载期。
+*   - 那一段读不出可信值（用户把 `rules` 手改成非数组）→ 由端口自己在**第一次真读到那一行
+*     时**报（`lib/rules-namespace.ts` 的 load）。装载期报不了：apply 跑在自己那条 fiber
+*     变 ACTIVE 之前，那一刻 describe() 里没有本条目的行（真实宿主隔离实测），在这一点上
+*     判"坏"是错的、判"还没到"则每次正常开机都多一条噪声。
+*     旧实现靠 try/catch 接住"register 被打回"，现在没有可 catch 的注册：同段之后，坏
+*     `rules` 若走到类型判定就会让整条条目不加载（cordis resolveConfig 抛 → 插件根本不
+*     执行，开关与服务一起没）。所以那一步由 schema 上的 `.loose()` 在解析期吸收，坏形状
+*     只在读写侧点名——不点名就会被当成"库里真的没有卡"。
+*/
+function createRulesFacet(settings) {
+	if (!isSettingsProvider(settings)) {
+		console.error("[lesson-loop] settings provider has no CAS surface — rule library unavailable (switches still work)");
+		return createRulesRepository(null);
+	}
+	return createRulesRepository(settings);
+}
+/** CSRF header 名（各插件历史上不同名，收敛时保持各自语义）。 */
+const LESSON_CSRF_HEADER = "x-lesson-csrf";
+/** rule-action 请求体上限（UTF-8 字节）：合法载荷只有 id/action/statement 三个短串。 */
+const RULE_ACTION_BODY_MAX_BYTES = 1048576;
+/** 会话台账容量上限（ctx-observe 同款纪律：防长驻进程无界）。 */
+const WATCH_MAX_SESSIONS = 200;
+/** 规则卡的 HTTP 投影：去掉 evidence[]，并补上派生态 undeterminable。
+*  证据是全文（一条教训的 detail 可含整段工具输出），而卡片只渲染状态与计数——
+*  原样序列化等于每次轮询把整份证据库传给浏览器再丢掉。不可判定是"该不该由人处理"
+*  的判据（既不自动降级也不自动归档），必须在投影里带出去让人看到。
+*/
+function ruleViewOf(store, rule) {
+	const { evidence: _evidence, ...rest } = rule;
+	return {
+		...rest,
+		undeterminable: store.isUndeterminable(rule)
+	};
+}
+/** GET stats：全量规则投影 + csrf（卡片轮询的入口，也是 csrf 的唯一来源）。 */
+function handleStatsRoute(req, res, { csrf, servingNonLoopback, stats, store }) {
+	if (!guardTrust(req, res, { servingNonLoopback })) return;
+	if (req.method !== "GET") {
+		res.setHeader("Allow", "GET");
+		sendJson(res, 405, {
+			ok: false,
+			error: "GET only"
+		});
+		return;
+	}
+	sendJson(res, 200, {
+		ok: true,
+		csrf,
+		...stats(),
+		rules: store.rules().map((rule) => ruleViewOf(store, rule))
+	});
+}
+/** GET rules：project 缺省给全量，给定即按卡片自存的 project 过滤。 */
+function handleRulesRoute(req, res, { csrf, servingNonLoopback, store }) {
+	if (!guardTrust(req, res, { servingNonLoopback })) return;
+	if (req.method !== "GET") {
+		res.setHeader("Allow", "GET");
+		sendJson(res, 405, {
+			ok: false,
+			error: "GET only"
+		});
+		return;
+	}
+	const project = queryParam(req, "project");
+	const all = store.rules();
+	const rules = (project === null ? all : all.filter((rule) => rule.project === project)).map((rule) => ruleViewOf(store, rule));
+	sendJson(res, 200, {
+		ok: true,
+		csrf,
+		rules
+	});
+}
+/** GET lessons：事件流水只读投影，零写面。 */
+function handleLessonsRoute(req, res, { servingNonLoopback, store }) {
+	if (!guardTrust(req, res, { servingNonLoopback })) return;
+	if (req.method !== "GET") {
+		res.setHeader("Allow", "GET");
+		sendJson(res, 405, {
+			ok: false,
+			error: "GET only"
+		});
+		return;
+	}
+	const project = queryParam(req, "project");
+	const limitRaw = Number(queryParam(req, "limit") ?? "0");
+	const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? Math.floor(limitRaw) : 0;
+	const lessons = store.recentLessons(project ?? void 0, limit);
+	sendJson(res, 200, {
+		ok: true,
+		count: lessons.length,
+		lessons
+	});
+}
+/** POST rule-action 的体：csrf 令牌校验 → 入参白名单 → 落库并按结果定状态码。 */
+async function applyRuleAction(req, res, { csrf, messagesOf, store }) {
+	if (req.method !== "POST") {
+		res.setHeader("Allow", "POST");
+		sendJson(res, 405, {
+			ok: false,
+			error: "POST only"
+		});
+		return;
+	}
+	const raw = await guardBody(req, res, {
+		maxBytes: RULE_ACTION_BODY_MAX_BYTES,
+		csrf: {
+			token: csrf,
+			headerName: LESSON_CSRF_HEADER
+		}
+	});
+	if (raw === null) return;
+	const messages = messagesOf();
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		sendJson(res, 400, {
+			ok: false,
+			error: messages.errInvalidJsonBody
+		});
+		return;
+	}
+	const idVal = fieldOf(parsed, "id");
+	const id = typeof idVal === "string" ? idVal : "";
+	const actionVal = fieldOf(parsed, "action");
+	const action = typeof actionVal === "string" ? actionVal : "";
+	const statementVal = fieldOf(parsed, "statement");
+	const statement = typeof statementVal === "string" ? statementVal : void 0;
+	if (id === "" || action === "") {
+		sendJson(res, 400, {
+			ok: false,
+			error: messages.errIdAndActionRequired
+		});
+		return;
+	}
+	if (!isRuleAction(action)) {
+		sendJson(res, 400, {
+			ok: false,
+			error: fill(messages.errUnknownAction, { action })
+		});
+		return;
+	}
+	const outcome = await store.ruleAction(id, action, statement);
+	if (outcome === "not-found") {
+		sendJson(res, 404, {
+			ok: false,
+			error: messages.errRuleNotFound
+		});
+		return;
+	}
+	if (outcome === "persist-failed") {
+		sendJson(res, 500, {
+			ok: false,
+			error: PERSIST_FAILED
+		});
+		return;
+	}
+	sendJson(res, 200, {
+		ok: true,
+		id,
+		action
+	});
+}
+/** POST rule-action 的壳：闸门 + 兜底 catch（体本身失败一律 500，不许漏成 unhandled rejection）。 */
+async function handleRuleActionRoute(req, res, routes) {
+	if (!guardTrust(req, res, { servingNonLoopback: routes.servingNonLoopback })) return;
+	try {
+		await applyRuleAction(req, res, routes);
+	} catch (error) {
+		console.error(`[lesson-loop] rule-action handler failed: ${errorText(error)}`);
+		sendJson(res, 500, {
+			ok: false,
+			error: routes.messagesOf().errRuleActionFailed
+		});
+	}
+}
+/** 端点装载体：读服务 → 取权威信号与 csrf → 四条路由逐个注册 → 交回合并 disposer。
+*  服务缺席（TUI 宿主没有 webServer）时只交回空清理，装载不许中断。 */
+function installLessonRoutes(svc, store, stats, messagesOf) {
+	const webServerRaw = svc.get?.("webServer");
+	if (!isWebServer(webServerRaw)) return noDisposer;
+	const webServer = webServerRaw;
+	const servingNonLoopback = webServer.host === "0.0.0.0";
+	const routes = {
+		store,
+		stats,
+		messagesOf,
+		csrf: randomUUID(),
+		servingNonLoopback
+	};
+	const disposeStats = webServer.register({
+		kind: "exact",
+		path: STATS_PATH,
+		handler: (req, res) => {
+			handleStatsRoute(req, res, routes);
+		}
+	});
+	const disposeRules = webServer.register({
+		kind: "exact",
+		path: RULES_PATH,
+		handler: (req, res) => {
+			handleRulesRoute(req, res, routes);
+		}
+	});
+	const disposeLessons = webServer.register({
+		kind: "exact",
+		path: LESSONS_PATH,
+		handler: (req, res) => {
+			handleLessonsRoute(req, res, routes);
+		}
+	});
+	const disposeAction = webServer.register({
+		kind: "exact",
+		path: RULE_ACTION_PATH,
+		handler: (req, res) => handleRuleActionRoute(req, res, routes)
+	});
+	return () => {
+		disposeStats();
+		disposeRules();
+		disposeLessons();
+		disposeAction();
+	};
+}
+/** 注册 webServer 端点：GET stats/rules/lessons（下发 csrf）+ POST rule-action（csrf 校验）。
+*  端点回显给卡片的 error 文案随语言偏好走（卡片把它们直接显示进 .llc-err）。
+*  ⚠ `owner` 必须是 apply 末尾那个 `svc.inject(["webServer"], …)` 交回的子上下文：效应挂在
+*  子 fiber 上才跟着依赖"后到即注册、换实例先卸后装"。挂在父 ctx 上会变成"父 fiber 卸载时
+*  才清"，依赖每次变化都多留一组路由。
+*  类型取本包对子上下文的投影（`InjectedCtx` 的 effect 位），不取官方 `Context["effect"]`：
+*  本包那份是比官方宽一格的本地镜像（官方两条重载的返回域是 Disposable/AsyncDisposable），
+*  混用会当场对不上——收窄到"这里只用到 effect"这一位即可。 */
+function registerRoutes(svc, owner, store, stats, messagesOf) {
+	owner.effect(() => installLessonRoutes(svc, store, stats, messagesOf), "lesson-loop: webServer routes");
+}
+/** commands 服务缺失只 warn 一次（模块级：一次进程内多次装载不刷屏）。
+*  位装在 const 盒子里而不是裸 `let`：模块级可变声明正是"谁都能改"的那种面，
+*  盒子只暴露这一位，改的对象仍是同一份进程内状态。 */
+const commandsWarnState = { warned: false };
+/** 数组性判据（**不是** type predicate，故不产生收窄；理由见 digestEvents 内注释）。 */
+function isArrayDelivery(value) {
+	return Array.isArray(value);
+}
+/**
+* 取一次蒸馏要用的会话事件流：官方 `ctx.sessionQuery.observeSession(sessionId)` 的
+* `observation.events`。
+* 三条降级路径一律回**空表**（宁可少背景，不可炸命令，语义与迁移前的 `readSessionEvents`
+* 逐条对齐）：
+*  1. `sessionQuery` 未装配（非该 profile / 精简 bundle）——`get` 交回 undefined，
+*     官方语义即"or `undefined` when not (yet) provided"（installed
+*     @deepseek-ai/cordis/lib/types/reflect.d.ts:12）。
+*  2. 拿不到 `SessionId`：本包的 {@link SessionLike} 只借官方键名、值域按边界收窄
+*     （`id?: Session["id"]`），递来的对象完全可能没有 id 或不是字符串。旧写法不需要这一步
+*     （它直接读对象上的方法），换成按 sessionId 查询后，这道理所应当是一道守卫。
+*  3. `observeSession` 抛错/拒绝（会话已卸载、存储读不出、取消信号命中）。
+*
+* `brandString<SessionId>` 是官方品牌的唯一合法构造口（幻影品牌无 type-only 构造方式，
+* `as` 又被 typescript/no-unsafe-type-assertion 禁掉），见文件头列出的 dsh-brand 值导入。
+*/
+async function digestEvents(svc, session) {
+	const queryRaw = svc.get?.("sessionQuery");
+	if (!isSessionQueryService(queryRaw)) return [];
+	const sessionId = typeof session.id === "string" && session.id.length > 0 ? session.id : void 0;
+	if (sessionId === void 0) return [];
+	try {
+		const observation = await queryRaw.observeSession(brandString(sessionId));
+		if (!isArrayDelivery(observation.events)) return [];
+		return observation.events;
+	} catch {
+		return [];
+	}
+}
+/** 注册 /lessons-digest 命令（人工触发蒸馏；commands 服务可选读——缺失只 warn 一次）。
+*  与 report 同一闸门：插件关闭期间既不烧 LLM 也不写候选卡。命令回显与进模型的蒸馏
+*  提示都随语言偏好走；蒸馏出来的规则条目是用户数据，原样透传。 */
+function registerDigestCommand(svc, store, settingsOf, messagesOf) {
+	svc.effect(() => {
+		const commandsRaw = svc.get?.("commands");
+		if (!isCommandsService(commandsRaw)) {
+			if (!commandsWarnState.warned) {
+				commandsWarnState.warned = true;
+				console.warn("[lesson-loop] commands service unavailable — /lessons-digest not registered");
+			}
+			return noDisposer;
+		}
+		const commands = commandsRaw;
+		const description = messagesOf().digestCommandDescription;
+		return commands.register({
+			name: "lessons-digest",
+			description,
+			input: { hint: messagesOf().digestInputHint },
+			recordInput: false,
+			handler: async (invocationRaw) => {
+				const messages = messagesOf();
+				const cfg = settingsOf();
+				if (!cfg.enabled || !cfg.reportEnabled) return {
+					kind: "error",
+					text: messages.digestRejectedDisabled
+				};
+				const agent = fieldOf(invocationRaw, "agent");
+				const sessionRaw = isRecord(agent) ? fieldOf(agent, "session") : void 0;
+				if (!isSessionLike(sessionRaw)) return {
+					kind: "error",
+					text: messages.digestRejectedNoSession
+				};
+				const session = sessionRaw;
+				const llmRaw = svc.get?.("llm");
+				if (!isLlmService(llmRaw)) return {
+					kind: "error",
+					text: messages.digestRejectedNoLlm
+				};
+				const llm = llmRaw;
+				const modelSvcRaw = svc.get?.("agentDefaultModel");
+				const selection = isAgentDefaultModel(modelSvcRaw) ? modelSvcRaw.currentSelection() : void 0;
+				const rawInput = fieldOf(invocationRaw, "rawInput");
+				const extra = typeof rawInput === "string" && rawInput.trim().length > 0 ? rawInput : void 0;
+				const events = await digestEvents(svc, session);
+				try {
+					const result = await runDigest(store, session, llm, selection, {
+						messages,
+						events,
+						timeoutMs: settingsOf().digestTimeoutMs,
+						...extra === void 0 ? {} : { extra }
+					});
+					if (result.created.length === 0) return {
+						kind: "success",
+						text: fill(messages.digestNoNewRules, { count: result.feedbackCount })
+					};
+					const lines = result.created.map((rule, index) => digestCreatedLine(rule, index + 1, messages));
+					return {
+						kind: "success",
+						text: fill(messages.digestCreated, {
+							count: result.created.length,
+							lines: lines.join("\n")
+						})
+					};
+				} catch (error) {
+					return {
+						kind: "error",
+						text: fill(messages.digestFailed, { reason: errorText(error) })
+					};
+				}
+			}
+		});
+	}, "lesson-loop: /lessons-digest command");
+}
+/** 启动时的存量碎片迁移：路径型签名的候选/armed 碎片并入类别级
+*  稳定签名卡。幂等——迁移后不再有匹配碎片，重复调用是 no-op。容错。 */
+async function runFragmentMigration(store) {
+	try {
+		const merged = await store.migrateFragmentRules();
+		if (merged > 0) console.info(`[lesson-loop] migrated ${merged} fragment rule(s) to stable signatures`);
+	} catch (error) {
+		console.error(`[lesson-loop] fragment migration failed: ${errorText(error)}`);
+	}
+}
+/** 启动时的 project 键归一迁移：桶键派生收进 shared/lib/project-key.ts（补
+*  path.resolve + realpath）后，按卡片自存的 cwd 重算 project 并归并撞车卡。
+*  幂等；与碎片迁移同一纪律——失败只记日志，装载不许被存量数据炸断。 */
+async function runProjectKeyMigration(store) {
+	try {
+		const { rewrites, merged } = await store.migrateProjectKeys();
+		if (rewrites > 0) console.info(`[lesson-loop] normalized ${rewrites} rule project key(s)${merged > 0 ? `, merged ${merged} collision(s)` : ""}`);
+	} catch (error) {
+		console.error(`[lesson-loop] project key migration failed: ${errorText(error)}`);
+	}
+}
+/**
+* `settleQuietly` 在三个收尾位（session/disposed 两支 + 卸载清算）共用同一句失败日志前缀：
+* 三处清算的都是 `store.sessionEnded`，措辞漂移会让同一条错误在日志里变成三种样子。
+*/
+const SESSION_ENDED_FAILURE_LABEL = "sessionEnded failed";
+/**
+* 收尾清算的异步兜底：sessionEnded 要 await provider 落盘。
+* **事件回调**位（agent/disposed、session/disposed）仍是同步契约 → 起链、失败只记日志
+* （单条会话炸了不许拖垮其余、更不许把事件派发带炸；未处理的 rejection 在 Node 默认
+* 配置下会直接退出进程）。**卸载**位不用这个函数：那里交回可 await 的 disposer，见
+* settleOpenSessionsOnDispose。
+*/
+async function settleQuietly(promise, label) {
+	try {
+		await promise;
+	} catch (error) {
+		console.error(`[lesson-loop] ${label}: ${errorText(error)}`);
+	}
+}
+/**
+* 卸载时清算仍未收到 session/disposed 的会话。
+*
+* 为什么需要：headless/CLI 进程只跑一个任务就退出，Cordis 拆树时插件 fiber 先于会话
+* 事件销毁——只挂在 session/disposed 上的收尾清算在这些进程里**永远不执行**，
+* samples/observed 因此恒为 0，armed 规则结构性落入"不可判定"，度量层等于没做。
+* 闸门与容错口径与事件版一致（关闭期间不清算、单条失败不拖垮其余），但**交回可 await 的
+* 异步 disposer**：官方明说异步 disposer 由拆纤 await（cordis fiber.d.ts:38-41），
+* 旧的 `void settleQuietly(...)` 是 fire-and-forget —— 在飞的 provider 写会被截断，
+* 违反 defensive-patterns.md:19-21「Dispose must reach quiescence」。
+*/
+function settleOpenSessionsOnDispose(args) {
+	const { store, sessionWatch, settingsOf } = args;
+	return async () => {
+		if (!settingsOf().enabled) return;
+		const pending = [];
+		for (const [sid, entry] of sessionWatch) {
+			sessionWatch.delete(sid);
+			pending.push(settleQuietly(store.sessionEnded(entry.project, entry.violated, entry.passed, sid), SESSION_ENDED_FAILURE_LABEL));
+		}
+		await Promise.all(pending);
+	};
+}
+/**
+* 会话开始：①预种会话台账（project 归因，供收尾清算 suppressed）；②注入 armed
+* 规则摘要（根会话；项目按 cwd 归因；全文不截断）。摘要帧的骨架行由消息表给，
+* 规则正文（statement）原样透传——那是规则库里的用户数据，不随界面语言改写。
+*/
+function onSessionStart(args) {
+	const { agent, settingsOf, store, sessionWatch, pruneWatch, messages } = args;
+	try {
+		const cfg = settingsOf();
+		if (!cfg.enabled) return;
+		const { session } = agent;
+		const sid = typeof session?.id === "string" ? session.id : void 0;
+		const project = deriveProject(session?.header?.cwd);
+		if (sid !== void 0) {
+			const seeded = sessionWatch.get(sid);
+			if (seeded === void 0) sessionWatch.set(sid, {
+				project,
+				violated: /* @__PURE__ */ new Set(),
+				passed: /* @__PURE__ */ new Set()
+			});
+			else seeded.project = project;
+			pruneWatch();
+		}
+		if (!cfg.injectEnabled) return;
+		if (session === void 0 || typeof agent.inject !== "function") return;
+		const { header } = session;
+		if (header && (typeof header.delegationDepth === "number" && header.delegationDepth > 0 || header.origin === "subagent")) return;
+		const digest = renderRulesDigest(store.rules(), project, messages);
+		if (digest === null) return;
+		agent.inject({
+			id: brandString(`${PLUGIN_NAME}-${randomUUID()}`),
+			role: "user",
+			content: [{
+				type: "text",
+				text: digest
+			}],
+			source: {
+				kind: LESSON_SOURCE_KIND,
+				form: "instructions"
+			}
+		});
+		console.info(`[lesson-loop] injected ${digest.split("\n").length - 1} armed rule(s) for project ${project}`);
+	} catch (error) {
+		console.error(`[lesson-loop] session-start inject failed: ${errorText(error)}`);
+	}
+}
+/** 页面策略声明：本包自带卡片，别让宿主再生成一份自动表单页。
+*  0.1.7 起注册是**隐式**的（命名空间 = profile 条目 id，见 cordis.patch.yml），可编辑
+*  字段由 schema 的 `.volatile()` 交出，插件侧不再有 `settings.register`；只剩这一位要
+*  声明。owner 必须显式传本插件 fiber（缺省是 settings 服务自己的 fiber，传错等于给别人的
+*  页面定策略），且经 child.effect 挂载以便随注入子上下文回收——宿主 dsh-client-locale
+*  与已迁移三包同款写法。 */
+function applySettingsPagePolicy(svc) {
+	svc.inject(["settings"], (child) => {
+		child.effect(() => child.settings.configure({ auto: false }, svc.fiber));
+	});
+}
+/** 现读一份解析后的设置（旧 `scope.get()` 的等价物）：每次都重新取引用的当前值，所以
+*  设置卡改完下一个事件/回合即生效，不必重挂载插件。 */
+function settingsSnapshot(config) {
+	return {
+		enabled: config.enabled.get(),
+		reportEnabled: config.reportEnabled.get(),
+		injectEnabled: config.injectEnabled.get(),
+		sectionEnabled: config.sectionEnabled.get(),
+		promoteThreshold: config.promoteThreshold.get(),
+		demoteThreshold: config.demoteThreshold.get(),
+		demoteMinSamples: config.demoteMinSamples.get(),
+		demoteRatio: config.demoteRatio.get(),
+		decayDays: config.decayDays.get(),
+		reviveThreshold: config.reviveThreshold.get(),
+		maxLessonsBytes: config.maxLessonsBytes.get(),
+		digestTimeoutMs: config.digestTimeoutMs,
+		decayIntervalMs: config.decayIntervalMs
+	};
+}
+/** 建总线与规则引擎：装载期一次性取阈值给构造器，之后每次 report/decay 前都会 syncStore
+*  现读，改动不必重启。 */
+function buildLessonStore(svc, settingsOf, localeMessages) {
+	const boot = settingsOf();
+	return new LessonStore({
+		lessonsFile: cacheFile("events.jsonl"),
+		rules: createRulesFacet(svc.settings),
+		messages: localeMessages,
+		maxLessonsBytes: boot.maxLessonsBytes,
+		promoteThreshold: boot.promoteThreshold,
+		demoteThreshold: boot.demoteThreshold,
+		demoteMinSamples: boot.demoteMinSamples,
+		demoteRatio: boot.demoteRatio,
+		decayDays: boot.decayDays,
+		reviveThreshold: boot.reviveThreshold
+	});
+}
+/** 装载期一次性迁移：provider 写是异步的，apply 是同步契约 → 起一条链按旧顺序跑
+*  （先收签名碎片、再重算 project 键），两个 helper 各自 catch，故链上不会 reject。 */
+function startBootMigrations(store) {
+	(async () => {
+		await runFragmentMigration(store);
+		await runProjectKeyMigration(store);
+	})();
+}
+/** 会话台账 + 它的容量修剪。
+*  sessionId → {project, violated}：会话内复发记账，session/disposed 时清算 suppressed。
+*  容量纪律同 ctx-observe（超 200 丢最旧，防长驻进程无界）。 */
+function createSessionWatch() {
+	const sessionWatch = /* @__PURE__ */ new Map();
+	/**
+	* 每次插入后调用：超出上限时按插入序把多出的几条丢掉。
+	*
+	* 不用「取最旧一条 + 跳过本会话」的写法：Map.set 对已存在的键保持原位，而每次
+	* 插入后都会立刻回到 ≤ 上限，故能走到这里的调用一定是"新键排在末位"——按插入序
+	* 丢的就是别的会话，永远丢不到刚被触碰的这条。留着那个 keepId 判断只会是一块
+	* 不可达、测不到的死分支（同下面不写 while 的理由）。
+	*/
+	const pruneWatch = () => {
+		const overflow = sessionWatch.size - WATCH_MAX_SESSIONS;
+		if (overflow <= 0) return;
+		for (const key of [...sessionWatch.keys()].slice(0, overflow)) sessionWatch.delete(key);
+	};
+	return {
+		sessionWatch,
+		pruneWatch
+	};
+}
+/** settings → store 的阈值同步（pull：每次 report/decay 前执行）。 */
+function syncStoreFrom(store, settingsOf) {
+	const cfg = settingsOf();
+	store.configure({
+		promoteThreshold: cfg.promoteThreshold,
+		demoteThreshold: cfg.demoteThreshold,
+		demoteMinSamples: cfg.demoteMinSamples,
+		demoteRatio: cfg.demoteRatio,
+		decayDays: cfg.decayDays,
+		reviveThreshold: cfg.reviveThreshold,
+		maxLessonsBytes: cfg.maxLessonsBytes
+	});
+	return cfg;
+}
+/** 记一条教训。全同步、容错：总线任何故障不外抛（报告方多在守卫热路径上）。 */
+async function reportLesson(runtime, input) {
+	const { store, sessionWatch, pruneWatch, syncStore } = runtime;
+	try {
+		const cfg = syncStore();
+		if (!cfg.enabled || !cfg.reportEnabled) return {
+			ok: false,
+			reason: "disabled"
+		};
+		const project = deriveProject(input.cwd);
+		const receipt = await store.report({
+			ts: Date.now(),
+			source: input.source,
+			category: input.category,
+			project,
+			...input.cwd !== void 0 && typeof input.cwd === "string" ? { cwd: input.cwd } : {},
+			...input.sessionId === void 0 ? {} : { sessionId: input.sessionId },
+			...input.turn === void 0 ? {} : { turn: input.turn },
+			signature: input.signature,
+			detail: input.detail,
+			...input.evidence === void 0 ? {} : { evidence: input.evidence }
+		});
+		if (input.sessionId !== void 0 && receipt.violationOf !== void 0) {
+			const watchEntry = sessionWatch.get(input.sessionId) ?? {
+				project,
+				violated: /* @__PURE__ */ new Set(),
+				passed: /* @__PURE__ */ new Set()
+			};
+			watchEntry.project = project;
+			watchEntry.violated.add(receipt.violationOf.id);
+			sessionWatch.set(input.sessionId, watchEntry);
+			pruneWatch();
+		}
+		if (receipt.violationOf !== void 0) console.warn(`[lesson-loop] armed rule violated: ${receipt.violationOf.statement.slice(0, 80)}（violation=${receipt.violationOf.violation}）`);
+		else if (receipt.candidate !== void 0 && receipt.ready === true) console.info(`[lesson-loop] candidate ready for review: ${receipt.candidate.category} / ${receipt.candidate.signature}`);
+		return receipt;
+	} catch (error) {
+		console.error(`[lesson-loop] report failed: ${errorText(error)}`);
+		return {
+			ok: false,
+			reason: "error"
+		};
+	}
+}
+/** pass 信号：规则场景被触发且被遵守（如 danger-guard fact-gate
+*  通过）。登记到会话台账，session/disposed 清算时该规则才计 suppressed——
+*  无关会话不再灌水。仅 armed 规则消费。 */
+function recordPass(runtime, input) {
+	const { store, sessionWatch, pruneWatch, syncStore } = runtime;
+	try {
+		if (!syncStore().enabled) return { ok: false };
+		const project = deriveProject(input.cwd);
+		const rule = store.pass(project, input.category, input.signature);
+		if (rule === void 0) return { ok: true };
+		if (input.sessionId !== void 0) {
+			const watchEntry = sessionWatch.get(input.sessionId) ?? {
+				project,
+				violated: /* @__PURE__ */ new Set(),
+				passed: /* @__PURE__ */ new Set()
+			};
+			watchEntry.project = project;
+			watchEntry.passed.add(rule.id);
+			sessionWatch.set(input.sessionId, watchEntry);
+			pruneWatch();
+		}
+		return { ok: true };
+	} catch (error) {
+		console.error(`[lesson-loop] pass failed: ${errorText(error)}`);
+		return { ok: false };
+	}
+}
+/** 管理面快照（/stats 的原样载荷 + 卡片副标题用的计数）。 */
+function statsSnapshot(runtime) {
+	const { store, settingsOf } = runtime;
+	const cfg = settingsOf();
+	return {
+		rules: store.rules(),
+		lessonsCount: store.lessonsCount(),
+		undeterminableCount: store.undeterminableRules().length,
+		config: {
+			enabled: cfg.enabled,
+			reportEnabled: cfg.reportEnabled,
+			injectEnabled: cfg.injectEnabled,
+			sectionEnabled: cfg.sectionEnabled,
+			promoteThreshold: cfg.promoteThreshold,
+			demoteThreshold: cfg.demoteThreshold,
+			decayDays: cfg.decayDays,
+			maxLessonsBytes: cfg.maxLessonsBytes
+		}
+	};
+}
+/** 装配对外服务面：六位里四位是 store 的直通，report/pass/stats 各走自己的 helper。 */
+function createLessonLoopService(runtime) {
+	const { store } = runtime;
+	return {
+		report: (input) => reportLesson(runtime, input),
+		pass: (input) => recordPass(runtime, input),
+		rules() {
+			return store.rules();
+		},
+		async ruleAction(id, action, statement) {
+			return await store.ruleAction(id, action, statement);
+		},
+		recentLessons(project, limit) {
+			return store.recentLessons(project, limit ?? 0);
+		},
+		stats: () => statsSnapshot(runtime)
+	};
+}
+/** 服务供给：inspector 同款（provide 返回 disposer 交 effect 托管）。
+*  provide 缺失 = 总线不可见，报告方全部静默丢报告 → 一条 error 日志点破。 */
+function provideLessonLoopService(svc, service) {
+	svc.effect(() => {
+		if (typeof svc.provide !== "function") {
+			console.error("[lesson-loop] ctx.provide unavailable — lessonLoop service invisible to reporters");
+			return noDisposer;
+		}
+		return svc.provide("lessonLoop", service);
+	}, "lesson-loop: provide lessonLoop service");
+}
+/** 会话开始：预种会话台账 + 注入 armed 规则摘要（见 onSessionStart）。
+*  事件接线修正：agent/session-start 无官方派发端，
+*  预种与 armed 规则注入从未执行过 → 改用官方 agent/created（载荷 {agent,source,signal}）。 */
+function onAgentCreated(runtime, payloadRaw) {
+	const { store, settingsOf, sessionWatch, pruneWatch, localeMessages } = runtime;
+	const { agent } = payloadRaw;
+	if (agent === void 0) return;
+	onSessionStart({
+		agent,
+		settingsOf,
+		store,
+		sessionWatch,
+		pruneWatch,
+		messages: localeMessages()
+	});
+}
+/** 会话收尾清算：只对本会话 pass 过且未违规的 armed 规则计 suppressed（pass 信号
+*  驱动）。与上报同受 enabled 闸门：插件关闭期间不清算。 */
+function onDisposedSession(runtime, sessionRaw) {
+	const { store, settingsOf, sessionWatch } = runtime;
+	if (!settingsOf().enabled) return;
+	const idVal = fieldOf(sessionRaw, "id");
+	const sid = typeof idVal === "string" ? idVal : void 0;
+	if (sid === void 0) return;
+	const watchEntry = sessionWatch.get(sid);
+	sessionWatch.delete(sid);
+	if (watchEntry !== void 0) {
+		settleQuietly(store.sessionEnded(watchEntry.project, watchEntry.violated, watchEntry.passed, sid), SESSION_ENDED_FAILURE_LABEL);
+		return;
+	}
+	const header = fieldOf(sessionRaw, "header");
+	const headerCwd = isRecord(header) ? fieldOf(header, "cwd") : void 0;
+	settleQuietly(store.sessionEnded(deriveProject(headerCwd), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), sid), SESSION_ENDED_FAILURE_LABEL);
+}
+/** 两枚会话事件的接线（顺序即注册顺序，与拆出前一致）。 */
+function wireSessionEvents(runtime) {
+	const { svc } = runtime;
+	svc.on("agent/created", (payloadRaw) => {
+		onAgentCreated(runtime, payloadRaw);
+	});
+	svc.on("session/disposed", (sessionRaw) => {
+		onDisposedSession(runtime, sessionRaw);
+	});
+}
+/** 常驻 systemPrompt 段（项目无关；webServer/timer/commands 皆可选读）。
+*  开关用动态 text 而不是「注册时读一次」：section 注册在 effect 里只跑一次，
+*  读一次的写法要让设置卡改动生效必须重启。renderPrompt 会丢掉空 text 段
+*  （core/system-prompt/src/index.ts:283），所以关闭时返回空串即完全不参与拼装。 */
+function registerPromptSection(runtime) {
+	const { svc, settingsOf, localeMessages } = runtime;
+	svc.effect(() => {
+		const spRaw = svc.get?.("systemPrompt");
+		if (!isSystemPromptService(spRaw)) return noDisposer;
+		return spRaw.section({
+			name: SECTION_NAME,
+			order: SECTION_ORDER,
+			text: () => settingsOf().sectionEnabled ? renderSectionText(localeMessages()) : ""
+		});
+	}, "lesson-loop: systemPrompt section");
+}
+/** 衰减一轮：阈值现读 + 跑 decay；失败只记日志（一轮炸了不许带走后面的轮次）。 */
+async function decayOnce(runtime) {
+	const { store, syncStore } = runtime;
+	try {
+		syncStore();
+		await store.runDecay();
+	} catch (error) {
+		console.error(`[lesson-loop] decay failed: ${errorText(error)}`);
+	}
+}
+/** 周期衰减：apply 时立即跑一次，此后每 `decayIntervalMs`（部署值，默认 24h）一轮
+*  （timer 可选读；缺失退化为主管人工）。 */
+function registerDecayTimer(runtime) {
+	const { svc, settingsOf } = runtime;
+	svc.effect(() => {
+		const timerRaw = svc.get?.("timer");
+		if (!isTimerService(timerRaw)) return noDisposer;
+		const timer = timerRaw;
+		const intervalMs = settingsOf().decayIntervalMs;
+		decayOnce(runtime);
+		let stopped = false;
+		let last;
+		const tick = () => {
+			if (stopped) return;
+			decayOnce(runtime);
+			last = timer.timeout(tick, intervalMs);
+		};
+		last = timer.timeout(tick, intervalMs);
+		return () => {
+			stopped = true;
+			last?.();
+		};
+	}, "lesson-loop: decay timer");
+}
+function apply(ctx, config) {
+	if (!isHostCtx(ctx)) throw new Error("[lesson-loop] host context contract violated");
+	const svc = ctx;
+	applySettingsPagePolicy(svc);
+	const settingsOf = () => settingsSnapshot(config);
+	let cachedPreference = void 0;
+	let hasCachedPreference = false;
+	svc.on("settings/document-updated", (ns) => {
+		if (ns === LOCALE_SETTINGS_NAMESPACE) hasCachedPreference = false;
+	});
+	const localeMessages = () => {
+		if (!hasCachedPreference) {
+			const row = svc.settings.describe().find((item) => fieldOf(item, "ns") === LOCALE_SETTINGS_NAMESPACE);
+			if (row !== void 0) {
+				cachedPreference = fieldOf(row, "value");
+				hasCachedPreference = true;
+			}
+		}
+		return messagesFor(MESSAGES, resolveLocalePreference(hasCachedPreference ? cachedPreference : void 0));
+	};
+	const store = buildLessonStore(svc, settingsOf, localeMessages);
+	startBootMigrations(store);
+	const { sessionWatch, pruneWatch } = createSessionWatch();
+	const syncStore = () => syncStoreFrom(store, settingsOf);
+	const runtime = {
+		svc,
+		store,
+		settingsOf,
+		localeMessages,
+		sessionWatch,
+		pruneWatch,
+		syncStore
+	};
+	/** 对外服务面（danger-guard / quality-gate / session-rescue 经 ctx.get 消费）。 */
+	const service = createLessonLoopService(runtime);
+	provideLessonLoopService(svc, service);
+	wireSessionEvents(runtime);
+	svc.effect(() => settleOpenSessionsOnDispose({
+		store,
+		sessionWatch,
+		settingsOf
+	}), "lesson-loop: 退出清算");
+	registerPromptSection(runtime);
+	registerDigestCommand(svc, store, settingsOf, localeMessages);
+	registerDecayTimer(runtime);
+	svc.inject(["webServer"], (child) => {
+		registerRoutes(svc, child, store, () => service.stats(), localeMessages);
+	});
+}
+var host_default = {
+	inject: ["settings"],
+	Config: configSchema,
+	apply
+};
+//#endregion
+export { configSchema as Config, apply, cacheFile, host_default as default, isSettingsProvider };