sage-mem 2.0.0 → 2.1.0

package/lib/client.js

@@ -2923,14 +2923,18 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			: null);
 
 		/**
-		 * 「注入调试」面板（1.7.0）。
+		 * 「注入调试」面板（1.7.0；2.0.1 起显示有效性抑制明细）。
 		 *
 		 * 只读：没有「清空 / 重跑」按钮 —— 账是注入链在 `SAGE_MEM_DEBUG=1` 时自动记的，
 		 * 人能做的是看，以及点「刷新」再取一次。入口只在开关打开时出现（宿主告诉我们）。
 		 *
-		 * 每一条记录的口径写在 `lib/recall/debug.js` 的 makeDebug 注释里；这里只负责把
+		 * 每一条记录的口径写在 `lib/recall/injector.js` 的 makeDebug 注释里；这里只负责把
 		 * 「为什么这一步没注入」翻译成人话 —— 那是这个面板存在的唯一理由。**尤其是
 		 * `empty + deduped`**：每轮多步里它占大多数，不解释就会被当成「插件坏了」。
+		 *
+		 * 2.0.0 让失效 / 未裁决矛盾的记忆不再进正文。2.0.1 把这两类的**文件名、理由与
+		 * 冲突 id** 单列一行：否则「这条记忆不见了」在面板上只能看到它不在 injected 里，
+		 * 分不清是没检索到还是被新规则挡住 —— 而那正是 2.0.0 之后最需要解释的一种消失。
 		 */
 		function RecallDebugPanel(props) {
 			const data = props.data || {};
@@ -2965,6 +2969,9 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				}));
 			}
 			const injected = latest && Array.isArray(latest.injected) ? latest.injected : [];
+			// 2.0.1：被有效性挡掉的条目。旧记录没有这个字段 → 空数组（面板显示「无」），
+			// 不因为多一个可选字段就把老账读崩。
+			const validitySuppressed = latest && Array.isArray(latest.validitySuppressed) ? latest.validitySuppressed : [];
 			const histogram = recs.slice(1).map(function (r, i) {
 				return h("div", { className: "smem-dbg-hist-row", key: "h" + i }, [
 					h("span", { className: "smem-dbg-time", key: "t" }, clock(r.at)),
@@ -3008,6 +3015,23 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 								"正文字节 " + String(latest.chars || 0) + "（本代累计 " + String(latest.sessionChars || 0) + "）" +
 								" · 状态卡 " + (latest.cardChars ? String(latest.cardChars) + " 字节" : "未发") +
 								" · 预算挡掉 " + String(latest.skippedByBudget || 0) + " 条"),
+							h("div", { className: "smem-dbg-row", key: "vs" }, [
+								h("span", { className: "smem-label", key: "l" }, "有效性抑制"),
+								validitySuppressed.length
+									? h("span", { className: "smem-dbg-scores", key: "v" }, validitySuppressed.map(function (x, i) {
+										const reason = String((x && x.label) || (x && x.reason) || "未知理由");
+										const cid = x && x.conflictId ? " · " + String(x.conflictId) : "";
+										return h("span", { className: "smem-dbg-score", key: String((x && x.file) || i) + "-" + i }, [
+											h("span", { className: "smem-dbg-file", key: "f" }, String((x && x.file) || "?")),
+											h("span", { className: "smem-dbg-num", key: "r" }, reason + cid),
+										]);
+									}))
+									: h("span", { className: "smem-muted", key: "v" }, "无"),
+							]),
+							validitySuppressed.length
+								? h("div", { className: "smem-ar-hint", key: "vshint" },
+									"被标失效或待裁决矛盾挡掉的记忆不会进正文 —— 这不是检索没命中，是 2.0.0 的有效性规则生效；去「冲突」页签可裁决。")
+								: null,
 							h("div", { className: "smem-ar-hint", key: "hint" },
 								"注入每走一步都会尝试一次；同题同命中集不会重复注入 —— 所以「空」多半是去重生效，不是坏了。"),
 							histogram.length
@@ -3855,6 +3879,220 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"notice.conflictDismissed": "已标记为已裁决 —— 没有改任何记忆文件",
 			"notice.conflictUndone": "已撤销 {file} 的失效标记 —— 它重新参与注入",
 			"notice.conflictRemoved": "已删除冲突记录（记忆文件没动）",
+
+			// ── 2.1.0: autodream tab (60-autodream-panel.js) ──
+			"ad.tab.run": "运行",
+			"ad.tab.settings": "设置",
+			"ad.tab.records": "记录",
+			"ad.title": "自动做梦",
+			"ad.switch.onTitle": "点击停用",
+			"ad.switch.offTitle": "点击启用",
+			"ad.switch.aria": "启用或停用自动做梦",
+			"ad.status.running": "运行中 · {phase}",
+			"ad.status.preparing": "准备中",
+			"ad.status.idle": "已启用 · 空闲",
+			"ad.status.off": "未启用",
+			"ad.note.what": "把记忆目录通读一遍：合并重复的、删掉被推翻的、修索引与断链、把相对日期换成绝对日期。",
+			"ad.row.trigger": "触发",
+			"ad.trigger.manual": "只手动",
+			"ad.trigger.auto": "满足条件自动跑",
+			"ad.row.apply": "改动方式",
+			"ad.apply.report": "只出报告",
+			"ad.apply.apply": "直接改写（先快照）",
+			"ad.row.source": "输入源",
+			"ad.source.memory": "仅记忆目录",
+			"ad.source.sessions": "记忆 + 会话记录",
+			"ad.note.sourceSessions": "会解压会话记录做定向搜索 —— 私密对话会进入模型上下文，token 成本也更高。",
+			"ad.note.sourceMemory": "只看记忆文件本身，不碰会话记录。",
+			"ad.note.applySnapshot": "改写前会自动把整个记忆目录快照一份（memory 上一层 .sage-mem/autodream/snapshots/），改坏可回退。",
+			"ad.note.reportOnly": "只读模式：这一趟连写工具都不会挂给模型，所以它不可能改到任何文件。",
+			"ad.row.model": "模型",
+			"ad.model.followDefault": "跟随当前会话默认模型",
+			"ad.model.defaultRoute": "（{provider} / {model}）",
+			"ad.model.currentOutOfCatalog": "（配置里指定，不在目录中）",
+			"ad.model.placeholder.provider": "provider（留空=跟随默认）",
+			"ad.model.placeholder.model": "model（留空=跟随默认）",
+			"ad.model.saved": "模型已保存",
+			"ad.action.save": "保存",
+			"ad.action.manualEntry": "手填",
+			"ad.loadingModels": "模型目录载入中…",
+			"ad.route.bad": "实际生效路线：拿不到 —— {error}",
+			"ad.route.badFallback": "宿主没能解析出 provider / model（配置留空且取不到会话默认模型）",
+			"ad.route.ok": "实际生效路线：{provider} / {model}",
+			"ad.route.fromDefault": "（跟随默认）",
+			"ad.route.fromConfig": "（配置指定）",
+			"ad.action.runningNow": "正在整理…",
+			"ad.action.runNow": "立即整理",
+			"ad.run.steps": "已跑 {count} 轮 · {phase}",
+			"ad.run.hoursSince": "距上次整理 {hours} 小时",
+			"ad.run.never": "从未整理过",
+			"ad.run.progress": "第 {step} 轮：{tools}",
+			"ad.run.stepDone": "结束",
+			"ad.toolSep": "、",
+			"ad.errSep": "；",
+			"ad.progressSep": "　·　",
+			"ad.last.prefix": "上次 {at} · {result}",
+			"ad.last.ok": "成功",
+			"ad.last.applied": "，改写了 {count} 个文件",
+			"ad.last.reportOnly": "（只出报告）",
+			"ad.last.problems": " · 结构问题 {before} → {after}",
+			"ad.last.tokens": " · token {in} / {out}",
+			"ad.last.failed": "失败：{error}",
+			"ad.unknown": "未知",
+			"ad.last.truncated": " · ⚠ 报告被截断（残篇）",
+			"ad.last.retried": " · 零正文重试 {count} 次后补齐",
+			"ad.last.continuations": " · 续写 {count} 轮",
+			"ad.last.report": " · 报告 {name}",
+			"ad.sidebar.title": "侧栏入口",
+			"ad.sidebar.on": "已开启",
+			"ad.sidebar.off": "已关闭",
+			"ad.sidebar.note": "在 DSH 侧栏显示「记忆管理」图标，点它把中央主区切到本页。默认开启；关闭后「设置 → 记忆管理」这个入口仍然保留。改动立即生效，不需要重启。",
+			"ad.sidebar.label": "在侧栏显示「记忆管理」入口",
+			"ad.limits.title": "记忆注入参数",
+			"ad.limits.pending": "有改动待生效",
+			"ad.limits.restartWarn": "⚠ 这些值在 DSH 启动时就固化了 —— 要重启 DSH 才生效。下面每行都写清「当前 → 重启后」。",
+			"ad.limits.restartNote": "这些值在 DSH 启动时固化：保存后要重启 DSH 才生效 —— 所以每行都会标出「当前生效」与「重启后」。",
+			"ad.limit.maxResults": "一次注入条数",
+			"ad.limit.maxChars": "单条字符上限",
+			"ad.limit.maxBaseline": "baseline 名额",
+			"ad.limit.maxSessionBytes": "单会话字节预算",
+			"ad.limit.staleDays": "新鲜度门槛",
+			"ad.unit.items": "条",
+			"ad.unit.chars": "字符",
+			"ad.unit.bytes": "字节",
+			"ad.unit.days": "天",
+			"ad.unit.copies": "份",
+			"ad.limit.labelTitle": "{unit} · 范围 {lo}–{hi}",
+			"ad.limit.inputTitle": "范围 {lo}–{hi} {unit}",
+			"ad.limit.diff": "当前 {current} → 重启后 {pending}",
+			"ad.limit.range": "范围 {lo}–{hi}",
+			"ad.limit.current": " · 当前生效 {current}",
+			"ad.action.saving": "保存中…",
+			"ad.action.saveLimits": "保存注入参数",
+			"ad.limits.saveHint": "保存后需重启 DSH 才生效",
+			"ad.reserved.title": "保留名保护名单",
+			"ad.reserved.subtitle": "名单里的文件不参与注入",
+			"ad.reserved.note": "内置的两个固定不可删；下面可以再加自己的（只写文件名，不要带路径）。改完需重启 DSH 才生效。",
+			"ad.reserved.fixedSuffix": " · 固定",
+			"ad.reserved.fixedTitle": "内置固定，不可删除",
+			"ad.reserved.removeTitle": "从名单里移除 {name}",
+			"ad.reserved.empty": "（还没有自己加的保留名）",
+			"ad.reserved.placeholder": "例如 project_notes.md（要 .md 文件名）",
+			"ad.action.addToList": "加入名单",
+			"ad.advanced": "高级设置",
+			"ad.adv.autoTrigger": "自动触发",
+			"ad.adv.since": "距上次 ≥",
+			"ad.adv.hoursAndSessions": "小时，且期间 ≥",
+			"ad.adv.sessionsUpdated": "个会话有更新",
+			"ad.adv.maxSteps": "最多轮数",
+			"ad.adv.stepNote": "一轮 = 一次模型调用 + 它要的工具调用",
+			"ad.adv.maxOutput": "单次输出上限",
+			"ad.adv.maxOutputNote": "token（思考与正文共用；报告残篇时先调它）",
+			"ad.adv.keepSnapshots": "保留快照",
+			"ad.adv.paths": "配置与状态：{path}",
+			"ad.records.snapshots": "回滚点",
+			"ad.records.countSnaps": "{count} 个",
+			"ad.action.refresh": "刷新",
+			"ad.row.rollbackScope": "回滚范围",
+			"ad.scope.files": "只恢复本次动过的文件",
+			"ad.scope.all": "整目录回到该时点",
+			"ad.note.rollback": "回滚前会自动把整个记忆目录再存一份保护快照 —— 所以回滚本身也能再退回来。多出来的文件只移进 archive/，不删除。",
+			"ad.snap.empty": "还没有回滚点 —— 用「直接改写」跑过一次就有了。",
+			"ad.snap.legacyLabel": "旧版快照",
+			"ad.snap.runLabel": "运行 {id}",
+			"ad.snap.protectionLabel": "回滚保护",
+			"ad.snap.meta": "{at} · {files} 个文件",
+			"ad.snap.legacyBadge": "旧版",
+			"ad.action.rollback": "回滚",
+			"ad.snap.confirmTitle": "确认回滚到 {at}？",
+			"ad.snap.confirmScope": "范围：{scope}",
+			"ad.snap.scopeAll": "整目录回到该时点 —— 快照里没有、当前目录里有的文件会被移进 archive/（不删除）",
+			"ad.snap.scopeFiles": "只恢复这次运行动过的文件 —— 该次新建的移进 archive/，该次归档的移回顶层",
+			"ad.snap.confirmSuffix": "。回滚前会先存一份保护快照，所以这一步本身也能退。",
+			"ad.action.rollingBack": "回滚中…",
+			"ad.action.confirmRollback": "确认回滚",
+			"ad.action.cancel": "取消",
+			"ad.rb.rolledBack": "已回滚到 {at}：恢复 {restored} 个文件，移走 {parked} 个",
+			"ad.rb.skipped": "，跳过 {count} 个（详见回滚报告）",
+			"ad.rb.protection": " · 保护快照 {id}",
+			"ad.rb.report": " · 报告 {name}",
+			"ad.records.runs": "整理记录",
+			"ad.records.countRuns": "{count} 条",
+			"ad.records.runsNote": "每一趟都留一份整理声明：改了什么、为什么改、哪些想法被拒了。点一条看全文。",
+			"ad.records.runsEmpty": "还没有整理记录 —— 跑一次就有了。",
+			"ad.badge.apply": "直接改写",
+			"ad.badge.report": "只出报告",
+			"ad.run.changes": "改 {count} 条",
+			"ad.run.reportName": "报告 {name}",
+			"ad.run.rolledBack": "已回滚",
+			"ad.run.rolledBackAt": "已回滚 · {at}",
+			"ad.action.collapse": "收起",
+			"ad.action.showDeclaration": "看声明",
+			"ad.records.reports": "历史报告",
+			"ad.records.countReports": "{count} 份",
+			"ad.records.reportsEmpty": "还没有报告 —— 跑一次就有了。报告写在 memory/autodream/ 下，不会混进记忆列表。",
+			"ad.action.view": "查看",
+			"ad.loading": "载入中…",
+			"ad.empty": "(空)",
+			"ad.emptyDeclaration": "(这一趟没有留下声明正文)",
+			"ad.err.readFailed": "读取失败：{error}",
+			"ad.err.rollbackFailed": "回滚失败：{error}",
+			"ad.unknownReason": "未知原因",
+			"ad.err.startFailed": "启动失败",
+			"ad.notice.started": "已开始整理 —— 进度每 2 秒刷新一次",
+			"ad.err.remoteUnavailable": "remote.autodream 不可用 —— 插件的 宿主侧可能没加载成功，看 DSH 启动日志",
+			"ad.err.noInterface": "宿主侧没有 {name} 接口（版本较旧？）",
+			"ad.err.noSetSettings": "宿主侧还没有 setSettings 接口（插件版本较旧）",
+			"ad.err.limitInteger": "{label}要整数",
+			"ad.err.limitRange": "{label} 要在 {lo}–{hi} 之间",
+			"ad.err.notSaved": "没保存 —— {detail}",
+			"ad.err.saveRejected": "保存被拒绝",
+			"ad.notice.limitsSaved": "已保存 —— 需重启 DSH 才生效",
+			"ad.notice.sidebarOn": "侧栏入口已开启（立即生效）",
+			"ad.notice.sidebarOff": "侧栏入口已关闭（设置页入口仍在）",
+			"ad.err.reservedRejected": "名单被拒绝",
+			"ad.notice.reservedSaved": "保留名名单已保存 —— 需重启 DSH 才生效",
+			"ad.err.reservedNeedName": "先写一个文件名，例如 project_notes.md",
+			"ad.err.reservedBadName": "保留名要是一个 .md 文件名（不能带路径）：{name}",
+			"ad.err.reservedDup": "名单里已经有 {name} 了",
+			"ad.note.modelCatalogUnavailable": "模型目录不可用（{error}）—— 请在下面手填 provider 与 model。",
+
+			// ── 2.1.0: auto-archive settings (62-archive-settings.js) ──
+			"archive.title": "自动归档做什么",
+			"archive.intro1": "闲置太久没被注入过的记忆，会被移进 archive/ —— 不删除，随时能恢复。这一页决定「多久算闲置」，以及要不要真的动手。",
+			"archive.intro2": "它不调模型：候选完全按访问台账的天数算，同一份输入每次算出来都一样。",
+			"archive.intro3": "想现在看看会被收走哪些：文件列表 →「工具 ▾」→ 归档候选。",
+			"archive.modeTitle": "自动归档",
+			"archive.mode.off": "关闭",
+			"archive.mode.report": "只出报告",
+			"archive.mode.auto": "满足条件自动跑",
+			"archive.cost.off": "关闭：一个文件都不动 —— 候选只列在清单里，等你手点。",
+			"archive.cost.report": "只出报告：候选写进整理报告，一个文件都不动。默认档，最保守。",
+			"archive.cost.auto": "满足条件自动跑：会真的把候选移进 archive/（只移不删，随时可恢复）；若「改动方式」是只出报告，这一档会自动降级成只出报告。",
+			"archive.degrade": "注意：「自动做梦 → 改动方式」现在是只出报告 —— 这一档会自动降级成只出报告，不会动文件。",
+			"archive.th.title": "闲置多少天算可以归档",
+			"archive.th.project": "项目",
+			"archive.th.reference": "参考",
+			"archive.th.user": "用户",
+			"archive.th.hintProject": "project_* 连续这么多天没被注入 → 进候选",
+			"archive.th.hintReference": "reference_* 同上（资料一般比项目留得久）",
+			"archive.th.hintUser": "user_* 同上（人设这类动它要格外谨慎）",
+			"archive.loadingConfig": "读配置中…",
+			"archive.action.save": "保存归档条件",
+			"archive.action.saving": "保存中…",
+			"archive.note.immediate": "保存即生效，不用重启 DSH",
+			"archive.note.thresholds": "天数按访问台账算（这条记忆上次被注入给模型是什么时候）。feedback_* 永不入选；锁定的记忆也不会被选中。",
+			"archive.err.noConfig": "宿主侧没有 autodream 配置接口（插件版本较旧）",
+			"archive.err.readConfig": "读不出自动做梦配置",
+			"archive.err.readFailed": "读配置失败：{error}",
+			"archive.err.saveFailed": "保存失败：{error}",
+			"archive.err.notApplied": "保存没生效：{error}。setConfig 对非法值会忽略并保留原值 —— 请重试，或看 DSH 启动日志。",
+			"archive.notice.modeSet": "自动归档已设为「{mode}」",
+			"archive.err.modeStill": "配置里仍是「{mode}」",
+			"archive.unknown": "读不出来",
+			"archive.err.thresholdBad": "{label}的阈值要是 1~3650 之间的天数（现在是「{value}」）",
+			"archive.notice.thresholdsSaved": "归档条件已保存",
+			"archive.err.thresholdStill": "{label} 仍是 {value}",
 		};
 
 		const EN = {
@@ -4119,6 +4357,220 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"notice.conflictDismissed": "Marked as decided — no memory file was changed",
 			"notice.conflictUndone": "Undid the invalidation of {file} — it takes part in injection again",
 			"notice.conflictRemoved": "Deleted the conflict record (no memory file was touched)",
+
+			// ── 2.1.0: autodream tab (60-autodream-panel.js) ──
+			"ad.tab.run": "Run",
+			"ad.tab.settings": "Settings",
+			"ad.tab.records": "Records",
+			"ad.title": "Autodream",
+			"ad.switch.onTitle": "Click to disable",
+			"ad.switch.offTitle": "Click to enable",
+			"ad.switch.aria": "Enable or disable Autodream",
+			"ad.status.running": "Running · {phase}",
+			"ad.status.preparing": "preparing",
+			"ad.status.idle": "Enabled · idle",
+			"ad.status.off": "Disabled",
+			"ad.note.what": "Read the whole memory directory: merge duplicates, drop what has been overruled, fix the index and broken links, and turn relative dates into absolute ones.",
+			"ad.row.trigger": "Trigger",
+			"ad.trigger.manual": "Manual only",
+			"ad.trigger.auto": "Run when conditions are met",
+			"ad.row.apply": "Changes",
+			"ad.apply.report": "Report only",
+			"ad.apply.apply": "Rewrite directly (snapshot first)",
+			"ad.row.source": "Input",
+			"ad.source.memory": "Memory directory only",
+			"ad.source.sessions": "Memory + session logs",
+			"ad.note.sourceSessions": "Session logs are unpacked for a targeted search — private conversations enter the model context, and token cost is higher.",
+			"ad.note.sourceMemory": "Only the memory files themselves; session logs are never touched.",
+			"ad.note.applySnapshot": "Before rewriting, the whole memory directory is snapshotted (under .sage-mem/autodream/snapshots/, one level above memory), so a bad run can be rolled back.",
+			"ad.note.reportOnly": "Read-only mode: this run does not even give the model write tools, so it cannot change any file.",
+			"ad.row.model": "Model",
+			"ad.model.followDefault": "Follow the current session's default model",
+			"ad.model.defaultRoute": " ({provider} / {model})",
+			"ad.model.currentOutOfCatalog": " (set in config, not in the catalog)",
+			"ad.model.placeholder.provider": "provider (blank = follow default)",
+			"ad.model.placeholder.model": "model (blank = follow default)",
+			"ad.model.saved": "Model saved",
+			"ad.action.save": "Save",
+			"ad.action.manualEntry": "Enter manually",
+			"ad.loadingModels": "Loading the model catalog…",
+			"ad.route.bad": "Effective route: unavailable — {error}",
+			"ad.route.badFallback": "the host could not resolve provider / model (config is blank and no session default is available)",
+			"ad.route.ok": "Effective route: {provider} / {model}",
+			"ad.route.fromDefault": " (following default)",
+			"ad.route.fromConfig": " (from config)",
+			"ad.action.runningNow": "Organizing…",
+			"ad.action.runNow": "Organize now",
+			"ad.run.steps": "Ran {count} rounds · {phase}",
+			"ad.run.hoursSince": "Last organized {hours} hours ago",
+			"ad.run.never": "Never organized",
+			"ad.run.progress": "Round {step}: {tools}",
+			"ad.run.stepDone": "done",
+			"ad.toolSep": ", ",
+			"ad.errSep": "; ",
+			"ad.progressSep": " · ",
+			"ad.last.prefix": "Last {at} · {result}",
+			"ad.last.ok": "succeeded",
+			"ad.last.applied": ", rewrote {count} files",
+			"ad.last.reportOnly": " (report only)",
+			"ad.last.problems": " · structural issues {before} → {after}",
+			"ad.last.tokens": " · tokens {in} / {out}",
+			"ad.last.failed": " failed: {error}",
+			"ad.unknown": "unknown",
+			"ad.last.truncated": " · ⚠ report was truncated",
+			"ad.last.retried": " · completed after {count} zero-body retries",
+			"ad.last.continuations": " · {count} continuation rounds",
+			"ad.last.report": " · report {name}",
+			"ad.sidebar.title": "Sidebar entry",
+			"ad.sidebar.on": "On",
+			"ad.sidebar.off": "Off",
+			"ad.sidebar.note": "Show the “Memory management” icon in the DSH sidebar; clicking it switches the main area to this page. On by default; turning it off keeps the Settings → Memory management entry. Changes take effect immediately, no restart needed.",
+			"ad.sidebar.label": "Show the “Memory management” entry in the sidebar",
+			"ad.limits.title": "Injection limits",
+			"ad.limits.pending": "changes pending",
+			"ad.limits.restartWarn": "⚠ These values are fixed at DSH startup — restart DSH for them to apply. Each row below shows “current → after restart”.",
+			"ad.limits.restartNote": "These values are fixed at DSH startup: saving requires a DSH restart to take effect — so each row shows both “currently effective” and “after restart”.",
+			"ad.limit.maxResults": "Memories per injection",
+			"ad.limit.maxChars": "Characters per memory",
+			"ad.limit.maxBaseline": "baseline slots",
+			"ad.limit.maxSessionBytes": "Bytes per session",
+			"ad.limit.staleDays": "Freshness threshold",
+			"ad.unit.items": "items",
+			"ad.unit.chars": "chars",
+			"ad.unit.bytes": "bytes",
+			"ad.unit.days": "days",
+			"ad.unit.copies": "copies",
+			"ad.limit.labelTitle": "{unit} · range {lo}–{hi}",
+			"ad.limit.inputTitle": "range {lo}–{hi} {unit}",
+			"ad.limit.diff": "current {current} → after restart {pending}",
+			"ad.limit.range": "range {lo}–{hi}",
+			"ad.limit.current": " · currently {current}",
+			"ad.action.saving": "Saving…",
+			"ad.action.saveLimits": "Save injection limits",
+			"ad.limits.saveHint": "Requires a DSH restart to take effect",
+			"ad.reserved.title": "Reserved-name protection",
+			"ad.reserved.subtitle": "Files in this list never take part in injection",
+			"ad.reserved.note": "The two built-in names are fixed and cannot be removed; you can add your own below (file name only, no path). Requires a DSH restart to take effect.",
+			"ad.reserved.fixedSuffix": " · fixed",
+			"ad.reserved.fixedTitle": "Built-in and fixed; cannot be removed",
+			"ad.reserved.removeTitle": "Remove {name} from the list",
+			"ad.reserved.empty": "(no reserved names of your own yet)",
+			"ad.reserved.placeholder": "e.g. project_notes.md (must be a .md file name)",
+			"ad.action.addToList": "Add to list",
+			"ad.advanced": "Advanced",
+			"ad.adv.autoTrigger": "Auto trigger",
+			"ad.adv.since": "At least",
+			"ad.adv.hoursAndSessions": "hours since last run, and at least",
+			"ad.adv.sessionsUpdated": "sessions with updates meanwhile",
+			"ad.adv.maxSteps": "Max rounds",
+			"ad.adv.stepNote": "one round = one model call plus the tool calls it makes",
+			"ad.adv.maxOutput": "Max output per call",
+			"ad.adv.maxOutputNote": "tokens (thinking and body share this budget; raise it first when reports get truncated)",
+			"ad.adv.keepSnapshots": "Keep snapshots",
+			"ad.adv.paths": "Config and state: {path}",
+			"ad.records.snapshots": "Rollback points",
+			"ad.records.countSnaps": "{count}",
+			"ad.action.refresh": "Refresh",
+			"ad.row.rollbackScope": "Rollback scope",
+			"ad.scope.files": "Restore only the files this run touched",
+			"ad.scope.all": "Return the whole directory to that moment",
+			"ad.note.rollback": "Before rolling back, the whole memory directory is snapshotted again as a protection copy — so the rollback itself can be undone. Extra files are only moved into archive/, never deleted.",
+			"ad.snap.empty": "No rollback points yet — run once with “Rewrite directly” and one appears.",
+			"ad.snap.legacyLabel": "Legacy snapshot",
+			"ad.snap.runLabel": "Run {id}",
+			"ad.snap.protectionLabel": "Rollback protection",
+			"ad.snap.meta": "{at} · {files} files",
+			"ad.snap.legacyBadge": "Legacy",
+			"ad.action.rollback": "Roll back",
+			"ad.snap.confirmTitle": "Roll back to {at}?",
+			"ad.snap.confirmScope": "Scope: {scope}",
+			"ad.snap.scopeAll": "Return the whole directory to that moment — files that exist now but not in the snapshot are moved into archive/ (not deleted)",
+			"ad.snap.scopeFiles": "Restore only the files that run touched — files created by it move into archive/, files it archived move back to the top level",
+			"ad.snap.confirmSuffix": ". A protection snapshot is taken first, so this step can itself be undone.",
+			"ad.action.rollingBack": "Rolling back…",
+			"ad.action.confirmRollback": "Confirm rollback",
+			"ad.action.cancel": "Cancel",
+			"ad.rb.rolledBack": "Rolled back to {at}: restored {restored} files, moved away {parked}",
+			"ad.rb.skipped": ", skipped {count} (see the rollback report)",
+			"ad.rb.protection": " · protection snapshot {id}",
+			"ad.rb.report": " · report {name}",
+			"ad.records.runs": "Organization records",
+			"ad.records.countRuns": "{count}",
+			"ad.records.runsNote": "Every run leaves a declaration: what changed, why, and which ideas were rejected. Click one to read the full text.",
+			"ad.records.runsEmpty": "No organization records yet — run once and one appears.",
+			"ad.badge.apply": "Rewritten",
+			"ad.badge.report": "Report only",
+			"ad.run.changes": "{count} changes",
+			"ad.run.reportName": "report {name}",
+			"ad.run.rolledBack": "Rolled back",
+			"ad.run.rolledBackAt": "Rolled back · {at}",
+			"ad.action.collapse": "Collapse",
+			"ad.action.showDeclaration": "Show declaration",
+			"ad.records.reports": "Past reports",
+			"ad.records.countReports": "{count}",
+			"ad.records.reportsEmpty": "No reports yet — run once and one appears. Reports live under memory/autodream/ and never mix into the memory list.",
+			"ad.action.view": "View",
+			"ad.loading": "Loading…",
+			"ad.empty": "(empty)",
+			"ad.emptyDeclaration": "(that run left no declaration body)",
+			"ad.err.readFailed": "Read failed: {error}",
+			"ad.err.rollbackFailed": "Rollback failed: {error}",
+			"ad.unknownReason": "unknown reason",
+			"ad.err.startFailed": "Failed to start",
+			"ad.notice.started": "Organization started — progress refreshes every 2 seconds",
+			"ad.err.remoteUnavailable": "remote.autodream is unavailable — the host side of the plugin may have failed to load; check the DSH startup log",
+			"ad.err.noInterface": "The host has no {name} API (older version?)",
+			"ad.err.noSetSettings": "The host has no setSettings API yet (older plugin version)",
+			"ad.err.limitInteger": "{label} must be an integer",
+			"ad.err.limitRange": "{label} must be between {lo}–{hi}",
+			"ad.err.notSaved": "Not saved — {detail}",
+			"ad.err.saveRejected": "Save rejected",
+			"ad.notice.limitsSaved": "Saved — restart DSH for it to take effect",
+			"ad.notice.sidebarOn": "Sidebar entry enabled (takes effect immediately)",
+			"ad.notice.sidebarOff": "Sidebar entry disabled (the Settings entry remains)",
+			"ad.err.reservedRejected": "Reserved-name list rejected",
+			"ad.notice.reservedSaved": "Reserved-name list saved — restart DSH for it to take effect",
+			"ad.err.reservedNeedName": "Enter a file name first, e.g. project_notes.md",
+			"ad.err.reservedBadName": "A reserved name must be a .md file name (no path): {name}",
+			"ad.err.reservedDup": "{name} is already in the list",
+			"ad.note.modelCatalogUnavailable": "The model catalog is unavailable ({error}) — enter provider and model below by hand.",
+
+			// ── 2.1.0: auto-archive settings (62-archive-settings.js) ──
+			"archive.title": "What auto-archive does",
+			"archive.intro1": "Memories that have not been injected for too long are moved into archive/ — never deleted, always recoverable. This page decides how long counts as idle, and whether it may actually act.",
+			"archive.intro2": "It does not call a model: candidates are computed purely from the access ledger's day counts, so the same input always yields the same result.",
+			"archive.intro3": "To see what would be collected right now: Files → “Tools ▾” → Archive candidates.",
+			"archive.modeTitle": "Auto-archive",
+			"archive.mode.off": "Off",
+			"archive.mode.report": "Report only",
+			"archive.mode.auto": "Run when conditions are met",
+			"archive.cost.off": "Off: no file is touched — candidates are only listed, waiting for you to act.",
+			"archive.cost.report": "Report only: candidates go into the organization report, no file is touched. The default and most conservative option.",
+			"archive.cost.auto": "Run when conditions are met: candidates are really moved into archive/ (moved, not deleted; recoverable at any time); if “Changes” is set to report only, this option degrades to report only.",
+			"archive.degrade": "Note: “Autodream → Changes” is currently report only — this option degrades to report only and will not touch any file.",
+			"archive.th.title": "How many idle days before a memory may be archived",
+			"archive.th.project": "Project",
+			"archive.th.reference": "Reference",
+			"archive.th.user": "User",
+			"archive.th.hintProject": "project_* not injected for this many days in a row → candidate",
+			"archive.th.hintReference": "reference_* same (documents usually outlive projects)",
+			"archive.th.hintUser": "user_* same (be extra careful with persona-type memories)",
+			"archive.loadingConfig": "Reading config…",
+			"archive.action.save": "Save archive conditions",
+			"archive.action.saving": "Saving…",
+			"archive.note.immediate": "Takes effect immediately, no DSH restart needed",
+			"archive.note.thresholds": "Days are counted from the access ledger (when this memory was last injected to the model). feedback_* is never selected; locked memories are never selected either.",
+			"archive.err.noConfig": "The host has no autodream config API yet (older plugin version)",
+			"archive.err.readConfig": "Could not read the Autodream config",
+			"archive.err.readFailed": "Failed to read config: {error}",
+			"archive.err.saveFailed": "Save failed: {error}",
+			"archive.err.notApplied": "Save did not take effect: {error}. setConfig ignores invalid values and keeps the old ones — try again, or check the DSH startup log.",
+			"archive.notice.modeSet": "Auto-archive set to “{mode}”",
+			"archive.err.modeStill": "Config still says “{mode}”",
+			"archive.unknown": "unreadable",
+			"archive.err.thresholdBad": "{label} threshold must be between 1 and 3650 days (currently “{value}”)",
+			"archive.notice.thresholdsSaved": "Archive conditions saved",
+			"archive.err.thresholdStill": "{label} is still {value}",
 		};
 
 		/**
@@ -4248,7 +4700,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			const sidebarEntryOn = !(memSet && memSet.ui && memSet.ui.sidebarEntry === false);
 
 			react.useEffect(function () {
-				if (!remote) { setErr("remote.autodream 不可用 —— 插件的 宿主侧可能没加载成功，看 DSH 启动日志"); return undefined; }
+				if (!remote) { setErr(t("ad.err.remoteUnavailable")); return undefined; }
 				let alive = true;
 				function pull() {
 					callRemote("status", [], function (d) {
@@ -4288,7 +4740,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			 */
 			function callRemote(name, args, onOk, onErr) {
 				const fn = remote ? remote[name] : null;
-				if (typeof fn !== "function") { if (onErr) onErr("宿主侧没有 " + name + " 接口（版本较旧？）"); return; }
+				if (typeof fn !== "function") { if (onErr) onErr(t("ad.err.noInterface", { name: name })); return; }
 				let p;
 				try { p = fn.apply(remote, args || []); }
 				catch (e) { if (onErr) onErr(detail(e)); return; }
@@ -4306,12 +4758,14 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			// ── 注入设置：5 项上限 + 保留名名单 ─────────────────────────────
 			// 边界与 host 的 LIMIT_SPECS 一一对应（那边是权威，这里只是提前拦明显笔误）。
 			const LIMIT_FIELDS = [
-				{ key: "maxResults", label: "一次注入条数", lo: 1, hi: 30, unit: "条" },
-				{ key: "maxChars", label: "单条字符上限", lo: 200, hi: 20000, unit: "字符" },
-				{ key: "maxBaseline", label: "baseline 名额", lo: 1, hi: 50, unit: "条" },
-				{ key: "maxSessionBytes", label: "单会话字节预算", lo: 4096, hi: 524288, unit: "字节" },
-				{ key: "staleDays", label: "新鲜度门槛", lo: 0, hi: 365, unit: "天" },
+				{ key: "maxResults", labelKey: "ad.limit.maxResults", lo: 1, hi: 30, unitKey: "ad.unit.items" },
+				{ key: "maxChars", labelKey: "ad.limit.maxChars", lo: 200, hi: 20000, unitKey: "ad.unit.chars" },
+				{ key: "maxBaseline", labelKey: "ad.limit.maxBaseline", lo: 1, hi: 50, unitKey: "ad.unit.items" },
+				{ key: "maxSessionBytes", labelKey: "ad.limit.maxSessionBytes", lo: 4096, hi: 524288, unitKey: "ad.unit.bytes" },
+				{ key: "staleDays", labelKey: "ad.limit.staleDays", lo: 0, hi: 365, unitKey: "ad.unit.days" },
 			];
+			const limitLabel = function (f) { return t(f.labelKey); };
+			const limitUnit = function (f) { return t(f.unitKey); };
 
 			/** 把一份 limits 对象摊成输入框用的字符串草稿（输入期间允许非法，保存时再校验）。 */
 			function limitsDraftOf(src) {
@@ -4332,27 +4786,27 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 
 			/** 保存 5 项上限。越界/非整数**本地先拦**（host 也是直接拒绝），别让它白跑一趟。 */
 			function saveLimits() {
-				if (!memRemote || typeof memRemote.setSettings !== "function") { setErr("宿主侧还没有 setSettings 接口（插件版本较旧）"); return; }
+				if (!memRemote || typeof memRemote.setSettings !== "function") { setErr(t("ad.err.noSetSettings")); return; }
 				const draft = limitsDraft || {};
 				const limits = {};
 				const bad = [];
 				for (const f of LIMIT_FIELDS) {
 					const raw = String(draft[f.key] == null ? "" : draft[f.key]).trim();
 					const n = Number(raw);
-					if (raw === "" || !Number.isFinite(n) || !Number.isInteger(n)) { bad.push(f.label + "要整数"); continue; }
-					if (n < f.lo || n > f.hi) { bad.push(f.label + " 要在 " + f.lo + "–" + f.hi + " 之间"); continue; }
+					if (raw === "" || !Number.isFinite(n) || !Number.isInteger(n)) { bad.push(t("ad.err.limitInteger", { label: limitLabel(f) })); continue; }
+					if (n < f.lo || n > f.hi) { bad.push(t("ad.err.limitRange", { label: limitLabel(f), lo: f.lo, hi: f.hi })); continue; }
 					limits[f.key] = n;
 				}
-				if (bad.length) { setErr("没保存 —— " + bad.join("；")); return; }
+				if (bad.length) { setErr(t("ad.err.notSaved", { detail: bad.join(t("ad.errSep")) })); return; }
 				setSaveBusy(true); setErr(null); setNotice("");
 				Promise.resolve(memRemote.setSettings({ limits: limits })).then(function (out) {
 					setSaveBusy(false);
 					// setSettings 是 {ok:true, settings, restartRequired} 形状：不要过 unwrap
 					// （unwrap 只认 {ok, value}，这里会把 settings 吃掉）。
-					if (out && out.ok === false) { setErr(out.error || "保存被拒绝"); return; }
+					if (out && out.ok === false) { setErr(out.error || t("ad.err.saveRejected")); return; }
 					if (out && out.settings) { setMemSet(out.settings); setLimitsDraft(limitsDraftOf(out.settings.pendingLimits)); }
 					else loadMemSettings();
-					setNotice("已保存 —— 需重启 DSH 才生效");
+					setNotice(t("ad.notice.limitsSaved"));
 				}, function (e) { setSaveBusy(false); setErr(detail(e)); });
 			}
 
@@ -4365,7 +4819,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			 */
 			function saveSidebarEntry(next) {
 				if (!memRemote || typeof memRemote.setSettings !== "function") {
-					setSidebarErr("宿主侧还没有 setSettings 接口（插件版本较旧）");
+					setSidebarErr(t("ad.err.noSetSettings"));
 					return;
 				}
 				if (sidebarBusy) return;
@@ -4373,11 +4827,11 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				Promise.resolve(memRemote.setSettings({ ui: { sidebarEntry: !!next } })).then(function (out) {
 					setSidebarBusy(false);
 					// 与 saveLimits 同款：setSettings 是 {ok, settings, restartRequired} 形状，不要过 unwrap。
-					if (out && out.ok === false) { setSidebarErr(out.error || "保存被拒绝"); return; }
+					if (out && out.ok === false) { setSidebarErr(out.error || t("ad.err.saveRejected")); return; }
 					if (out && out.settings) setMemSet(out.settings);
 					else loadMemSettings();
 					setSidebarEntry(!!next);
-					setNotice(!!next ? "侧栏入口已开启（立即生效）" : "侧栏入口已关闭（设置页入口仍在）");
+					setNotice(!!next ? t("ad.notice.sidebarOn") : t("ad.notice.sidebarOff"));
 				}, function (e) { setSidebarBusy(false); setSidebarErr(detail(e)); });
 			}
 
@@ -4388,28 +4842,28 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			 * 那是生效清单里固定的两个，删不掉。这里管的只是用户自己加的那些。
 			 */
 			function saveReserved(list) {
-				if (!memRemote || typeof memRemote.setSettings !== "function") { setErr("宿主侧还没有 setSettings 接口（插件版本较旧）"); return; }
+				if (!memRemote || typeof memRemote.setSettings !== "function") { setErr(t("ad.err.noSetSettings")); return; }
 				setSaveBusy(true); setErr(null); setNotice("");
 				Promise.resolve(memRemote.setSettings({ reserved: list })).then(function (out) {
 					setSaveBusy(false);
-					if (out && out.ok === false) { setErr(out.error || "名单被拒绝"); return; }
+					if (out && out.ok === false) { setErr(out.error || t("ad.err.reservedRejected")); return; }
 					if (out && out.settings) setMemSet(out.settings);
 					else loadMemSettings();
-					setNotice("保留名名单已保存 —— 需重启 DSH 才生效");
+					setNotice(t("ad.notice.reservedSaved"));
 				}, function (e) { setSaveBusy(false); setErr(detail(e)); });
 			}
 
 			function addReserved() {
 				const name = String(reservedNew || "").trim();
 				const extra = Array.isArray(memSet && memSet.reservedExtra) ? memSet.reservedExtra : [];
-				if (!name) { setErr("先写一个文件名，例如 project_notes.md"); return; }
+				if (!name) { setErr(t("ad.err.reservedNeedName")); return; }
 				// 与 host 的校验同一套：单个 .md 文件名、不许带路径
 				if (!name.endsWith(".md") || name.includes("/") || name.includes("\\") || name.startsWith("..")) {
-					setErr("保留名要是一个 .md 文件名（不能带路径）：" + name);
+					setErr(t("ad.err.reservedBadName", { name: name }));
 					return;
 				}
 				if (extra.some(function (x) { return String(x).toLowerCase() === name.toLowerCase(); })) {
-					setErr("名单里已经有 " + name + " 了");
+					setErr(t("ad.err.reservedDup", { name: name }));
 					return;
 				}
 				setReservedNew("");
@@ -4438,7 +4892,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				callRemote("listModels", [], function (d) {
 					setModels(d && typeof d === "object" && !Array.isArray(d) ? d : { catalogAvailable: false, routes: [], note: "" });
 				}, function (m) {
-					setModels({ catalogAvailable: false, routes: [], note: "模型目录不可用（" + m + "）—— 请在下面手填 provider 与 model。" });
+					setModels({ catalogAvailable: false, routes: [], note: t("ad.note.modelCatalogUnavailable", { error: m }) });
 				});
 			}
 
@@ -4447,27 +4901,27 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				// 契约：runNow({ reason })。reason 只落进 manifest 给人看；门控的豁免
 				// 由 宿主侧负责（手动点了按钮就不该被「还没到 N 小时」挡回来）。
 				callRemote("runNow", [{ reason: "设置页手动触发" }], function (d) {
-					if (d && d.ok === false) setErr(d.error || "启动失败");
-					else { setNotice("已开始整理 —— 进度每 2 秒刷新一次"); refreshLists(); }
+					if (d && d.ok === false) setErr(d.error || t("ad.err.startFailed"));
+					else { setNotice(t("ad.notice.started")); refreshLists(); }
 					setBusy(false);
 				}, function (m) { setErr(m); setBusy(false); });
 			}
 
 			function openReport(name) {
 				if (name === null) { setOpen(null); setBody(""); return; }
-				setOpen(name); setBody("载入中…");
+				setOpen(name); setBody(t("ad.loading"));
 				callRemote("readReport", [name], function (d) {
-					setBody((d && d.content) || "(空)");
-				}, function (m) { setBody("读取失败：" + m); });
+					setBody((d && d.content) || t("ad.empty"));
+				}, function (m) { setBody(t("ad.err.readFailed", { error: m })); });
 			}
 
 			/** 整理声明：点开才拉，拉回来的是 Markdown 原文，直接用 pre 呈现。 */
 			function openDecl(runId) {
 				if (declOpen === runId) { setDeclOpen(null); setDeclBody(""); return; }
-				setDeclOpen(runId); setDeclBody("载入中…");
+				setDeclOpen(runId); setDeclBody(t("ad.loading"));
 				callRemote("readDeclaration", [{ runId: runId }], function (d) {
-					setDeclBody((d && d.markdown) || "(这一趟没有留下声明正文)");
-				}, function (m) { setDeclBody("读取失败：" + m); });
+					setDeclBody((d && d.markdown) || t("ad.emptyDeclaration"));
+				}, function (m) { setDeclBody(t("ad.err.readFailed", { error: m })); });
 			}
 
 			/**
@@ -4480,26 +4934,31 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				callRemote("rollback", [{ snapshotId: sp.name, scope: scope }], function (d) {
 					const x = d || {};
 					if (x.ok === false) {
-						setRbMsg({ bad: true, text: "回滚失败：" + (x.error || "未知原因") });
+						setRbMsg({ bad: true, text: t("ad.err.rollbackFailed", { error: x.error || t("ad.unknownReason") }) });
 					} else {
-						setRbMsg({ bad: false, text: "已回滚到 " + String(sp.atHuman || "") + "：恢复 " +
-							(x.restored == null ? "?" : x.restored) + " 个文件，移走 " + (x.parked == null ? "?" : x.parked) + " 个" +
+						setRbMsg({ bad: false, text: t("ad.rb.rolledBack", {
+							at: String(sp.atHuman || ""),
+							restored: (x.restored == null ? "?" : x.restored),
+							parked: (x.parked == null ? "?" : x.parked),
+						}) +
 							// skipped = 想动但没动的（archive/ 已有同名、或回滚点里没那一版）。
 							// 不显示它等于「部分成功」被说成「成功」——回滚这种事不能含糊。
-							(x.skipped ? "，跳过 " + x.skipped + " 个（详见回滚报告）" : "") +
-							(x.protection ? " · 保护快照 " + x.protection : "") + (x.report ? " · 报告 " + x.report : "") });
+							(x.skipped ? t("ad.rb.skipped", { count: x.skipped }) : "") +
+							(x.protection ? t("ad.rb.protection", { id: x.protection }) : "") +
+							(x.report ? t("ad.rb.report", { name: x.report }) : "") });
 						setConfirmSnap(null);
 					}
 					setRbBusy(null);
 					refreshLists();
-				}, function (m) { setRbMsg({ bad: true, text: "回滚失败：" + m }); setRbBusy(null); });
+				}, function (m) { setRbMsg({ bad: true, text: t("ad.err.rollbackFailed", { error: m }) }); setRbBusy(null); });
 			}
 
 			// 实际生效路线（契约：route 可能为 null；source==='none' 时 error 里是原因）。
 			const routeBad = !route || route.source === "none" || !route.provider || !route.model;
 			const routeInfo = routeBad
-				? ("实际生效路线：拿不到 —— " + ((route && route.error) || "宿主没能解析出 provider / model（配置留空且取不到会话默认模型）"))
-				: ("实际生效路线：" + route.provider + " / " + route.model + (route.fromDefault ? "（跟随默认）" : "（配置指定）"));
+				? t("ad.route.bad", { error: (route && route.error) || t("ad.route.badFallback") })
+				: t("ad.route.ok", { provider: route.provider, model: route.model }) +
+					(route.fromDefault ? t("ad.route.fromDefault") : t("ad.route.fromConfig"));
 
 			// 模型 <select> 的取值：''=跟随默认；否则是 "provider::model" 的 JSON 编码。
 			// 配置里指定的路线万一下架了（不在目录里），也要让它显示出来 —— 否则
@@ -4523,9 +4982,9 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 
 			return h("div", { className: "smem-autodream" }, [
 				h("div", { className: "smem-subtabs", key: "segs" }, [
-					subtab("run", "运行"),
-					subtab("settings", "设置"),
-					subtab("records", "记录", String(snaps.length + runs.length + reports.length)),
+					subtab("run", t("ad.tab.run")),
+					subtab("settings", t("ad.tab.settings")),
+					subtab("records", t("ad.tab.records"), String(snaps.length + runs.length + reports.length)),
 				]),
 				segOf === "run" ? h("div", { key: "seg-run" }, [
 				h("div", { className: "smem-autodream-sec", key: "top" }, [
@@ -4533,54 +4992,53 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 						h("button", {
 							type: "button", key: "sw", className: "smem-switch",
 							"data-on": c.enabled ? "1" : "0",
-							title: c.enabled ? "点击停用" : "点击启用",
-							"aria-label": "启用或停用自动做梦",
+							title: c.enabled ? t("ad.switch.onTitle") : t("ad.switch.offTitle"),
+							"aria-label": t("ad.switch.aria"),
 							onClick: function () { patch({ enabled: !c.enabled }); },
 						}),
-						h("span", { key: "t", style: { fontWeight: "600" } }, "自动做梦"),
+						h("span", { key: "t", style: { fontWeight: "600" } }, t("ad.title")),
 						h("span", { className: "smem-status", key: "s" },
-							running ? ("运行中 · " + String((st && st.phase) || "准备中")) : (c.enabled ? "已启用 · 空闲" : "未启用")),
+							running ? t("ad.status.running", { phase: String((st && st.phase) || t("ad.status.preparing")) }) : (c.enabled ? t("ad.status.idle") : t("ad.status.off"))),
 					]),
-					h("div", { className: "smem-autodream-note", key: "n" },
-						"把记忆目录通读一遍：合并重复的、删掉被推翻的、修索引与断链、把相对日期换成绝对日期。"),
+					h("div", { className: "smem-autodream-note", key: "n" }, t("ad.note.what")),
 				]),
 				h("div", { className: "smem-autodream-sec", key: "mode" }, [
 					h("div", { className: "smem-autodream-row", key: "a" }, [
-						h("span", { className: "smem-autodream-key", key: "k" }, "触发"),
+						h("span", { className: "smem-autodream-key", key: "k" }, t("ad.row.trigger")),
 						h(Seg, {
 							key: "v", value: c.trigger,
-							options: [{ value: "manual", label: "只手动" }, { value: "auto", label: "满足条件自动跑" }],
+							options: [{ value: "manual", label: t("ad.trigger.manual") }, { value: "auto", label: t("ad.trigger.auto") }],
 							onChange: function (v) { patch({ trigger: v }); },
 						}),
 					]),
 					h("div", { className: "smem-autodream-row", key: "b" }, [
-						h("span", { className: "smem-autodream-key", key: "k" }, "改动方式"),
+						h("span", { className: "smem-autodream-key", key: "k" }, t("ad.row.apply")),
 						h(Seg, {
 							key: "v", value: c.apply ? "apply" : "report",
-							options: [{ value: "report", label: "只出报告" }, { value: "apply", label: "直接改写（先快照）" }],
+							options: [{ value: "report", label: t("ad.apply.report") }, { value: "apply", label: t("ad.apply.apply") }],
 							onChange: function (v) { patch({ apply: v === "apply" }); },
 						}),
 					]),
 					h("div", { className: "smem-autodream-row", key: "c" }, [
-						h("span", { className: "smem-autodream-key", key: "k" }, "输入源"),
+						h("span", { className: "smem-autodream-key", key: "k" }, t("ad.row.source")),
 						h(Seg, {
 							key: "v", value: c.source,
-							options: [{ value: "memory", label: "仅记忆目录" }, { value: "memory+sessions", label: "记忆 + 会话记录" }],
+							options: [{ value: "memory", label: t("ad.source.memory") }, { value: "memory+sessions", label: t("ad.source.sessions") }],
 							onChange: function (v) { patch({ source: v }); },
 						}),
 					]),
 					h("div", { className: "smem-autodream-note", key: "w" },
 						c.source === "memory+sessions"
-							? "会解压会话记录做定向搜索 —— 私密对话会进入模型上下文，token 成本也更高。"
-							: "只看记忆文件本身，不碰会话记录。"),
+							? t("ad.note.sourceSessions")
+							: t("ad.note.sourceMemory")),
 					h("div", { className: "smem-autodream-note", key: "w2" },
 						c.apply
-							? "改写前会自动把整个记忆目录快照一份（memory 上一层 .sage-mem/autodream/snapshots/），改坏可回退。"
-							: "只读模式：这一趟连写工具都不会挂给模型，所以它不可能改到任何文件。"),
+							? t("ad.note.applySnapshot")
+							: t("ad.note.reportOnly")),
 				]),
 				h("div", { className: "smem-autodream-sec", key: "model" }, [
 					h("div", { className: "smem-autodream-row", key: "model" }, [
-						h("span", { className: "smem-autodream-key", key: "k" }, "模型"),
+						h("span", { className: "smem-autodream-key", key: "k" }, t("ad.row.model")),
 						// 有可枚举的模型目录就给 <select>（首项 = 跟随会话默认，值 "":""）；
 						// 目录不可用就退化成两个文本框（契约第六节第 2 条）。
 						(models && models.catalogAvailable)
@@ -4594,11 +5052,11 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 										patch({ provider: r.provider, model: r.model });
 									},
 								}, [h("option", { key: "__def", value: "" },
-										"跟随当前会话默认模型" + ((models.defaultRoute && models.defaultRoute.provider && models.defaultRoute.model)
-											? ("（" + String(models.defaultRoute.provider) + " / " + String(models.defaultRoute.model) + "）")
+										t("ad.model.followDefault") + ((models.defaultRoute && models.defaultRoute.provider && models.defaultRoute.model)
+											? t("ad.model.defaultRoute", { provider: String(models.defaultRoute.provider), model: String(models.defaultRoute.model) })
 											: ""),
 									)].concat(
-										modelValueInCatalog ? [] : [h("option", { key: "__cur", value: modelValue }, String(c.provider) + " / " + String(c.model) + "（配置里指定，不在目录中）")],
+										modelValueInCatalog ? [] : [h("option", { key: "__cur", value: modelValue }, String(c.provider) + " / " + String(c.model) + t("ad.model.currentOutOfCatalog"))],
 										modelRoutes.map(function (r) {
 											return h("option", { key: String(r.provider) + "/" + String(r.model), value: encodeRoute(r.provider, r.model) },
 												r.label || (String(r.provider) + " / " + String(r.model)));
@@ -4606,13 +5064,13 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 									))
 							: models
 								? [
-										h("input", { className: "smem-input", key: "p", style: { flex: "1", minWidth: "110px" }, value: prov, placeholder: "provider（留空=跟随默认）", onChange: function (e) { setProv(e.target.value); } }),
-										h("input", { className: "smem-input", key: "m", style: { flex: "1", minWidth: "110px" }, value: model, placeholder: "model（留空=跟随默认）", onChange: function (e) { setModel(e.target.value); } }),
-										h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "ok", onClick: function () { patch({ provider: prov, model: model }); setNotice("模型已保存"); } }, "保存"),
+										h("input", { className: "smem-input", key: "p", style: { flex: "1", minWidth: "110px" }, value: prov, placeholder: t("ad.model.placeholder.provider"), onChange: function (e) { setProv(e.target.value); } }),
+										h("input", { className: "smem-input", key: "m", style: { flex: "1", minWidth: "110px" }, value: model, placeholder: t("ad.model.placeholder.model"), onChange: function (e) { setModel(e.target.value); } }),
+										h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "ok", onClick: function () { patch({ provider: prov, model: model }); setNotice(t("ad.model.saved")); } }, t("ad.action.save")),
 									]
 								: [
-										h("span", { className: "smem-status", key: "load" }, "模型目录载入中…"),
-										h("button", { type: "button", className: "smem-btn", key: "man", onClick: function () { setModels({ catalogAvailable: false, routes: [], note: "" }); } }, "手填"),
+										h("span", { className: "smem-status", key: "load" }, t("ad.loadingModels")),
+										h("button", { type: "button", className: "smem-btn", key: "man", onClick: function () { setModels({ catalogAvailable: false, routes: [], note: "" }); } }, t("ad.action.manualEntry")),
 									],
 					]),
 					h("div", {
@@ -4629,29 +5087,32 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 							type: "button", className: "smem-btn smem-btn-primary", key: "go",
 							disabled: busy || running || !remote,
 							onClick: run,
-						}, running ? "正在整理…" : "立即整理"),
+						}, running ? t("ad.action.runningNow") : t("ad.action.runNow")),
 						h("span", { className: "smem-status", key: "s" },
 							running
-								? ("已跑 " + ((st && st.steps && st.steps.length) || 0) + " 轮 · " + String((st && st.phase) || ""))
-								: (st && st.hoursSince != null ? ("距上次整理 " + st.hoursSince.toFixed(1) + " 小时") : "从未整理过")),
+								? t("ad.run.steps", { count: ((st && st.steps && st.steps.length) || 0), phase: String((st && st.phase) || "") })
+								: (st && st.hoursSince != null ? t("ad.run.hoursSince", { hours: st.hoursSince.toFixed(1) }) : t("ad.run.never"))),
 					]),
 					running && st && st.steps && st.steps.length
 						? h("div", { className: "smem-autodream-note", key: "prog" }, st.steps.map(function (x) {
-								return "第 " + x.step + " 轮：" + (x.tools.length ? x.tools.join("、") : "结束");
-							}).join("　·　"))
+								return t("ad.run.progress", { step: x.step, tools: (x.tools.length ? x.tools.join(t("ad.toolSep")) : t("ad.run.stepDone")) });
+							}).join(t("ad.progressSep")))
 						: null,
 					last
 						? h("div", { className: "smem-status", key: "last" },
-								"上次 " + String(last.atHuman || "") + " · " + (last.ok
-									? ("成功" + (last.apply ? "，改写了 " + ((last.touched || []).length) + " 个文件" : "（只出报告）") +
-										" · 结构问题 " + last.problemsBefore + " → " + last.problemsAfter +
-										" · token " + last.tokensIn + " / " + last.tokensOut)
-									: ("失败：" + (last.error || "未知"))) +
+								t("ad.last.prefix", {
+									at: String(last.atHuman || ""),
+									result: (last.ok
+										? (t("ad.last.ok") + (last.apply ? t("ad.last.applied", { count: ((last.touched || []).length) }) : t("ad.last.reportOnly")) +
+											t("ad.last.problems", { before: last.problemsBefore, after: last.problemsAfter }) +
+											t("ad.last.tokens", { in: last.tokensIn, out: last.tokensOut }))
+										: t("ad.last.failed", { error: (last.error || t("ad.unknown")) })),
+								}) +
 								// 1.9.2：残篇必须在状态行上就能看见 —— 只写「成功」正是 10-25 那次误判的来源。
-								(last.ok && last.truncated ? " · ⚠ 报告被截断（残篇）" : "") +
-								(last.ok && !last.truncated && last.retries ? (" · 零正文重试 " + last.retries + " 次后补齐") : "") +
-								(last.continuations ? (" · 续写 " + last.continuations + " 轮") : "") +
-								(last.report ? " · 报告 " + last.report : ""))
+								(last.ok && last.truncated ? t("ad.last.truncated") : "") +
+								(last.ok && !last.truncated && last.retries ? t("ad.last.retried", { count: last.retries }) : "") +
+								(last.continuations ? t("ad.last.continuations", { count: last.continuations }) : "") +
+								(last.report ? t("ad.last.report", { name: last.report }) : ""))
 						: null,
 				]),
 				]) : null,
@@ -4660,11 +5121,10 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				// 「设置 → 记忆管理」这个入口永远在（它注册在 80-apply，和这个开关无关）。
 				h("div", { className: "smem-autodream-sec", key: "sidebar-entry" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "侧栏入口"),
-						h("span", { className: "smem-status", key: "s" }, sidebarEntryOn ? "已开启" : "已关闭"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("ad.sidebar.title")),
+						h("span", { className: "smem-status", key: "s" }, sidebarEntryOn ? t("ad.sidebar.on") : t("ad.sidebar.off")),
 					]),
-					h("div", { className: "smem-autodream-note", key: "n" },
-						"在 DSH 侧栏显示「记忆管理」图标，点它把中央主区切到本页。默认开启；关闭后「设置 → 记忆管理」这个入口仍然保留。改动立即生效，不需要重启。"),
+					h("div", { className: "smem-autodream-note", key: "n" }, t("ad.sidebar.note")),
 					h("label", { className: "smem-check", key: "row" }, [
 						h("input", {
 							type: "checkbox", key: "c",
@@ -4672,7 +5132,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 							disabled: sidebarBusy,
 							onChange: function (e) { saveSidebarEntry(!!(e.target && e.target.checked)); },
 						}),
-						h("span", { key: "l" }, "在侧栏显示「记忆管理」入口"),
+						h("span", { key: "l" }, t("ad.sidebar.label")),
 					]),
 					sidebarErr ? h("div", { className: "smem-autodream-note smem-ad-warn", key: "err" }, sidebarErr) : null,
 				]),
@@ -4681,27 +5141,25 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				// 同一件事只在一处设定，这里不再重复摆一份。
 				h("div", { className: "smem-autodream-sec", key: "limits" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "记忆注入参数"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("ad.limits.title")),
 						memSet && memSet.restartRequired
-							? h("span", { className: "smem-ad-badge smem-ad-badge--warn", key: "w" }, "有改动待生效")
+							? h("span", { className: "smem-ad-badge smem-ad-badge--warn", key: "w" }, t("ad.limits.pending"))
 							: null,
 					]),
 					memSet && memSet.restartRequired
-						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "rw" },
-								"⚠ 这些值在 DSH 启动时就固化了 —— 要重启 DSH 才生效。下面每行都写清「当前 → 重启后」。")
-						: h("div", { className: "smem-autodream-note", key: "rn" },
-								"这些值在 DSH 启动时固化：保存后要重启 DSH 才生效 —— 所以每行都会标出「当前生效」与「重启后」。"),
+						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "rw" }, t("ad.limits.restartWarn"))
+						: h("div", { className: "smem-autodream-note", key: "rn" }, t("ad.limits.restartNote")),
 					// 五个参数排两列（一行两个）：同样的信息，行数少一半，扫读反而更清楚。
 					h("div", { className: "smem-ad-grid2", key: "grid" }, LIMIT_FIELDS.map(function (f) {
 						const cur = memSet && memSet.limits ? memSet.limits[f.key] : null;
 						const pend = memSet && memSet.pendingLimits ? memSet.pendingLimits[f.key] : null;
 						const diff = cur != null && pend != null && cur !== pend;
 						return h("div", { className: "smem-ad-field", key: f.key }, [
-							h("span", { className: "smem-autodream-key", key: "k", title: f.unit + " · 范围 " + f.lo + "–" + f.hi }, f.label),
+							h("span", { className: "smem-autodream-key", key: "k", title: t("ad.limit.labelTitle", { unit: limitUnit(f), lo: f.lo, hi: f.hi }) }, limitLabel(f)),
 							h("input", {
 								className: "smem-num", key: "v", type: "number",
 								min: String(f.lo), max: String(f.hi),
-								title: "范围 " + f.lo + "–" + f.hi + " " + f.unit,
+								title: t("ad.limit.inputTitle", { lo: f.lo, hi: f.hi, unit: limitUnit(f) }),
 								value: limitsDraft && limitsDraft[f.key] != null ? limitsDraft[f.key] : "",
 								onChange: function (e) {
 									const nx = Object.assign({}, limitsDraft);
@@ -4710,73 +5168,72 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 								},
 							}),
 							diff
-								? h("span", { className: "smem-ad-badge smem-ad-badge--warn", key: "d" }, "当前 " + String(cur) + " → 重启后 " + String(pend))
-								: h("span", { className: "smem-status", key: "d" }, "范围 " + f.lo + "–" + f.hi + (cur == null ? "" : (" · 当前生效 " + String(cur)))),
+								? h("span", { className: "smem-ad-badge smem-ad-badge--warn", key: "d" }, t("ad.limit.diff", { current: String(cur), pending: String(pend) }))
+								: h("span", { className: "smem-status", key: "d" }, t("ad.limit.range", { lo: f.lo, hi: f.hi }) + (cur == null ? "" : t("ad.limit.current", { current: String(cur) }))),
 						]);
 					})),
 					h("div", { className: "smem-autodream-row", key: "save" }, [
-						h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "s", disabled: saveBusy, onClick: saveLimits }, saveBusy ? "保存中…" : "保存注入参数"),
-						h("span", { className: "smem-status", key: "n" }, "保存后需重启 DSH 才生效"),
+						h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "s", disabled: saveBusy, onClick: saveLimits }, saveBusy ? t("ad.action.saving") : t("ad.action.saveLimits")),
+						h("span", { className: "smem-status", key: "n" }, t("ad.limits.saveHint")),
 					]),
 				]),
 				h("div", { className: "smem-autodream-sec", key: "reserved" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "保留名保护名单"),
-						h("span", { className: "smem-status", key: "c" }, "名单里的文件不参与注入"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("ad.reserved.title")),
+						h("span", { className: "smem-status", key: "c" }, t("ad.reserved.subtitle")),
 					]),
-					h("div", { className: "smem-autodream-note", key: "n" },
-						"内置的两个固定不可删；下面可以再加自己的（只写文件名，不要带路径）。改完需重启 DSH 才生效。"),
+					h("div", { className: "smem-autodream-note", key: "n" }, t("ad.reserved.note")),
 					h("div", { className: "smem-raw-names", key: "fixed" }, fixedReserved.map(function (n) {
-						return h("span", { className: "smem-chip smem-chip--fixed", key: n, title: "内置固定，不可删除" }, n + " · 固定");
+						return h("span", { className: "smem-chip smem-chip--fixed", key: n, title: t("ad.reserved.fixedTitle") }, n + t("ad.reserved.fixedSuffix"));
 					})),
 					h("div", { className: "smem-raw-names", key: "extra" },
 						extraReserved.length
 							? extraReserved.map(function (n) {
 									return h("span", { className: "smem-chip", key: n, "data-on": "1" }, [
 										n,
-										h("button", { type: "button", className: "smem-chip-x", key: "x", title: "从名单里移除 " + n, onClick: function () { removeReserved(n); } }, "✕"),
+										h("button", { type: "button", className: "smem-chip-x", key: "x", title: t("ad.reserved.removeTitle", { name: n }), onClick: function () { removeReserved(n); } }, "✕"),
 									]);
 								})
-							: h("span", { className: "smem-status", key: "none" }, "（还没有自己加的保留名）")),
+							: h("span", { className: "smem-status", key: "none" }, t("ad.reserved.empty"))),
 					h("div", { className: "smem-autodream-row", key: "add" }, [
 						h("input", {
 							className: "smem-input", key: "i",
 							style: { flex: "1", minWidth: "150px" },
 							value: reservedNew,
-							placeholder: "例如 project_notes.md（要 .md 文件名）",
+							placeholder: t("ad.reserved.placeholder"),
 							onChange: function (e) { setReservedNew(e.target.value); },
 						}),
-						h("button", { type: "button", className: "smem-btn", key: "a", disabled: saveBusy, onClick: addReserved }, "加入名单"),
+						h("button", { type: "button", className: "smem-btn", key: "a", disabled: saveBusy, onClick: addReserved }, t("ad.action.addToList")),
 					]),
 				]),
 				h("details", { className: "smem-autodream-adv", key: "adv", open: true }, [
-					h("summary", { key: "s" }, "高级设置"),
+					h("summary", { key: "s" }, t("ad.advanced")),
 					h("div", { key: "d" }, [
 						c.trigger === "auto" ? h("div", { className: "smem-autodream-row", key: "gate" }, [
-							h("span", { className: "smem-autodream-key", key: "k" }, "自动触发"),
-							h("span", { className: "smem-status", key: "a" }, "距上次 ≥"),
+							h("span", { className: "smem-autodream-key", key: "k" }, t("ad.adv.autoTrigger")),
+							h("span", { className: "smem-status", key: "a" }, t("ad.adv.since")),
 							h("input", { className: "smem-num", key: "h", type: "number", min: "1", max: "720", value: c.minHours, onChange: function (e) { patch({ minHours: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "b" }, "小时，且期间 ≥"),
+							h("span", { className: "smem-status", key: "b" }, t("ad.adv.hoursAndSessions")),
 							h("input", { className: "smem-num", key: "m", type: "number", min: "1", max: "200", value: c.minSessions, onChange: function (e) { patch({ minSessions: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "c" }, "个会话有更新"),
+							h("span", { className: "smem-status", key: "c" }, t("ad.adv.sessionsUpdated")),
 						]) : null,
 						h("div", { className: "smem-autodream-row", key: "steps" }, [
-							h("span", { className: "smem-autodream-key", key: "k" }, "最多轮数"),
+							h("span", { className: "smem-autodream-key", key: "k" }, t("ad.adv.maxSteps")),
 							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "80", value: c.maxSteps, onChange: function (e) { patch({ maxSteps: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "s" }, "一轮 = 一次模型调用 + 它要的工具调用"),
+							h("span", { className: "smem-status", key: "s" }, t("ad.adv.stepNote")),
 						]),
 						// 1.9.2：单次输出上限（原写死 4096）。思考型模型下 4096 会让收尾轮只剩思考、零正文。
 						h("div", { className: "smem-autodream-row", key: "maxout" }, [
-							h("span", { className: "smem-autodream-key", key: "k" }, "单次输出上限"),
+							h("span", { className: "smem-autodream-key", key: "k" }, t("ad.adv.maxOutput")),
 							h("input", { className: "smem-num", key: "v", type: "number", min: "1024", max: "131072", value: c.maxOutputTokens, onChange: function (e) { patch({ maxOutputTokens: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "s" }, "token（思考与正文共用；报告残篇时先调它）"),
+							h("span", { className: "smem-status", key: "s" }, t("ad.adv.maxOutputNote")),
 						]),
 						h("div", { className: "smem-autodream-row", key: "keep" }, [
-							h("span", { className: "smem-autodream-key", key: "k" }, "保留快照"),
+							h("span", { className: "smem-autodream-key", key: "k" }, t("ad.adv.keepSnapshots")),
 							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "50", value: c.maxSnapshotKeep, onChange: function (e) { patch({ maxSnapshotKeep: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "s" }, "份"),
+							h("span", { className: "smem-status", key: "s" }, t("ad.unit.copies")),
 						]),
-						h("div", { className: "smem-status", key: "paths" }, "配置与状态：" + ((st && st.paths && st.paths.configPath) || "—")),
+						h("div", { className: "smem-status", key: "paths" }, t("ad.adv.paths", { path: ((st && st.paths && st.paths.configPath) || "—") })),
 					]),
 				]),
 				]) : null,
@@ -4785,53 +5242,51 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				segOf === "records" ? h("div", { key: "seg-rec" }, [
 				h("div", { className: "smem-autodream-sec", key: "snap" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "回滚点"),
-						h("span", { className: "smem-status", key: "c" }, String(snaps.length) + " 个"),
-						h("button", { type: "button", className: "smem-btn", key: "rf", onClick: refreshLists }, "刷新"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("ad.records.snapshots")),
+						h("span", { className: "smem-status", key: "c" }, t("ad.records.countSnaps", { count: String(snaps.length) })),
+						h("button", { type: "button", className: "smem-btn", key: "rf", onClick: refreshLists }, t("ad.action.refresh")),
 					]),
 					h("div", { className: "smem-autodream-row", key: "scope" }, [
-						h("span", { className: "smem-autodream-key", key: "k" }, "回滚范围"),
+						h("span", { className: "smem-autodream-key", key: "k" }, t("ad.row.rollbackScope")),
 						h(Seg, {
 							key: "v", value: rollbackScope,
-							options: [{ value: "files", label: "只恢复本次动过的文件" }, { value: "all", label: "整目录回到该时点" }],
+							options: [{ value: "files", label: t("ad.scope.files") }, { value: "all", label: t("ad.scope.all") }],
 							onChange: function (v) { patch({ rollbackScope: v }); },
 						}),
 					]),
-					h("div", { className: "smem-autodream-note", key: "n" },
-						"回滚前会自动把整个记忆目录再存一份保护快照 —— 所以回滚本身也能再退回来。多出来的文件只移进 archive/，不删除。"),
+					h("div", { className: "smem-autodream-note", key: "n" }, t("ad.note.rollback")),
 					snaps.length === 0
-						? h("div", { className: "smem-status", key: "e" }, "还没有回滚点 —— 用「直接改写」跑过一次就有了。")
+						? h("div", { className: "smem-status", key: "e" }, t("ad.snap.empty"))
 						: h("div", { className: "smem-autodream-list", key: "l" }, snaps.slice(0, 15).map(function (sp) {
-								const label = sp.legacy ? "旧版快照" : (sp.runId ? ("运行 " + String(sp.runId)) : "回滚保护");
+								const label = sp.legacy ? t("ad.snap.legacyLabel") : (sp.runId ? t("ad.snap.runLabel", { id: String(sp.runId) }) : t("ad.snap.protectionLabel"));
 								return h("div", { className: "smem-ad-wrap", key: String(sp.name) }, [
 									h("div", { className: "smem-ad-snap", key: "row" }, [
 										h("div", { className: "smem-ad-main", key: "m" }, [
-											h("div", { key: "l1" }, String(sp.atHuman || "") + " · " + (sp.files == null ? "?" : sp.files) + " 个文件"),
+											h("div", { key: "l1" }, t("ad.snap.meta", { at: String(sp.atHuman || ""), files: (sp.files == null ? "?" : sp.files) })),
 											h("div", { className: "smem-ad-sub", key: "l2" }, label + " · " + String(sp.name || "")),
 										]),
-										sp.legacy ? h("span", { className: "smem-ad-badge smem-ad-badge--legacy", key: "lg" }, "旧版") : null,
+										sp.legacy ? h("span", { className: "smem-ad-badge smem-ad-badge--legacy", key: "lg" }, t("ad.snap.legacyBadge")) : null,
 										confirmSnap === sp.name
 											? null
 											: h("button", {
 													type: "button", className: "smem-btn", key: "go",
 													disabled: rbBusy !== null,
 													onClick: function () { setRbMsg(null); setConfirmSnap(sp.name); },
-												}, "回滚"),
+												}, t("ad.action.rollback")),
 									]),
 									confirmSnap === sp.name
 										? h("div", { className: "smem-ad-confirm", key: "cf" }, [
-												h("div", { key: "t", style: { fontWeight: "600" } }, "确认回滚到 " + String(sp.atHuman || "") + "？"),
-												h("div", { key: "d" }, "范围：" + (rollbackScope === "all"
-													? "整目录回到该时点 —— 快照里没有、当前目录里有的文件会被移进 archive/（不删除）"
-													: "只恢复这次运行动过的文件 —— 该次新建的移进 archive/，该次归档的移回顶层") +
-													"。回滚前会先存一份保护快照，所以这一步本身也能退。"),
+												h("div", { key: "t", style: { fontWeight: "600" } }, t("ad.snap.confirmTitle", { at: String(sp.atHuman || "") })),
+												h("div", { key: "d" }, t("ad.snap.confirmScope", {
+													scope: rollbackScope === "all" ? t("ad.snap.scopeAll") : t("ad.snap.scopeFiles"),
+												}) + t("ad.snap.confirmSuffix")),
 												h("div", { className: "smem-autodream-row", key: "acts" }, [
 													h("button", {
 														type: "button", className: "smem-btn smem-btn-danger", key: "yes",
 														disabled: rbBusy === sp.name,
 														onClick: function () { doRollback(sp); },
-													}, rbBusy === sp.name ? "回滚中…" : "确认回滚"),
-													h("button", { type: "button", className: "smem-btn", key: "no", onClick: function () { setConfirmSnap(null); } }, "取消"),
+													}, rbBusy === sp.name ? t("ad.action.rollingBack") : t("ad.action.confirmRollback")),
+													h("button", { type: "button", className: "smem-btn", key: "no", onClick: function () { setConfirmSnap(null); } }, t("ad.action.cancel")),
 												]),
 											])
 										: null,
@@ -4842,14 +5297,13 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				// ── 整理声明（新）──────────────────────────────────────────
 				h("div", { className: "smem-autodream-sec", key: "runs" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "整理记录"),
-						h("span", { className: "smem-status", key: "c" }, String(runs.length) + " 条"),
-						h("button", { type: "button", className: "smem-btn", key: "rf", onClick: refreshLists }, "刷新"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("ad.records.runs")),
+						h("span", { className: "smem-status", key: "c" }, t("ad.records.countRuns", { count: String(runs.length) })),
+						h("button", { type: "button", className: "smem-btn", key: "rf", onClick: refreshLists }, t("ad.action.refresh")),
 					]),
-					h("div", { className: "smem-autodream-note", key: "n" },
-						"每一趟都留一份整理声明：改了什么、为什么改、哪些想法被拒了。点一条看全文。"),
+					h("div", { className: "smem-autodream-note", key: "n" }, t("ad.records.runsNote")),
 					runs.length === 0
-						? h("div", { className: "smem-status", key: "e" }, "还没有整理记录 —— 跑一次就有了。")
+						? h("div", { className: "smem-status", key: "e" }, t("ad.records.runsEmpty"))
 						: h("div", { className: "smem-autodream-list", key: "l" }, runs.slice(0, 15).map(function (rn) {
 								return h("div", { className: "smem-ad-wrap", key: String(rn.runId) }, [
 									h("button", {
@@ -4858,14 +5312,14 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 										onClick: function () { openDecl(rn.runId); },
 									}, [
 										h("span", { key: "t" }, String(rn.atHuman || "")),
-										h("span", { className: "smem-ad-badge", key: "m" }, rn.mode === "apply" ? "直接改写" : "只出报告"),
-										h("span", { key: "c" }, "改 " + (rn.changeCount == null ? "?" : rn.changeCount) + " 条"),
-										rn.report ? h("span", { className: "smem-ad-sub", key: "r" }, "报告 " + String(rn.report)) : null,
+										h("span", { className: "smem-ad-badge", key: "m" }, rn.mode === "apply" ? t("ad.badge.apply") : t("ad.badge.report")),
+										h("span", { key: "c" }, t("ad.run.changes", { count: (rn.changeCount == null ? "?" : rn.changeCount) })),
+										rn.report ? h("span", { className: "smem-ad-sub", key: "r" }, t("ad.run.reportName", { name: String(rn.report) })) : null,
 										rn.rolledBackAt
 											? h("span", { className: "smem-ad-badge smem-ad-badge--warn", key: "rb" },
-													"已回滚" + (rn.rolledBackAtHuman ? (" · " + String(rn.rolledBackAtHuman)) : ""))
+													rn.rolledBackAtHuman ? t("ad.run.rolledBackAt", { at: String(rn.rolledBackAtHuman) }) : t("ad.run.rolledBack"))
 											: null,
-										h("span", { className: "smem-ad-sub", key: "x" }, declOpen === rn.runId ? "收起" : "看声明"),
+										h("span", { className: "smem-ad-sub", key: "x" }, declOpen === rn.runId ? t("ad.action.collapse") : t("ad.action.showDeclaration")),
 									]),
 									declOpen === rn.runId
 										? h("pre", { className: "smem-ad-md", key: "body" }, declBody)
@@ -4875,11 +5329,11 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				]),
 				h("div", { className: "smem-autodream-sec", key: "rep" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "历史报告"),
-						h("span", { className: "smem-status", key: "c" }, String(reports.length) + " 份"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("ad.records.reports")),
+						h("span", { className: "smem-status", key: "c" }, t("ad.records.countReports", { count: String(reports.length) })),
 					]),
 					reports.length === 0
-						? h("div", { className: "smem-status", key: "e" }, "还没有报告 —— 跑一次就有了。报告写在 memory/autodream/ 下，不会混进记忆列表。")
+						? h("div", { className: "smem-status", key: "e" }, t("ad.records.reportsEmpty"))
 						: h("div", { className: "smem-autodream-list", key: "l" }, reports.slice(0, 12).map(function (r) {
 								return h("button", {
 									type: "button", key: r.name, className: "smem-report",
@@ -4887,8 +5341,8 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 									onClick: function () { openReport(open === r.name ? null : r.name); },
 								}, [
 									h("span", { key: "t" }, String(r.atHuman || "") + " · " + String(r.name) + " · " + fmtSize(r.bytes)),
-									r.legacy ? h("span", { className: "smem-ad-badge smem-ad-badge--legacy", key: "lg", style: { marginLeft: "6px" } }, "旧版") : null,
-									h("span", { className: "smem-ad-sub", key: "x", style: { marginLeft: "6px" } }, open === r.name ? "收起" : "查看"),
+									r.legacy ? h("span", { className: "smem-ad-badge smem-ad-badge--legacy", key: "lg", style: { marginLeft: "6px" } }, t("ad.snap.legacyBadge")) : null,
+									h("span", { className: "smem-ad-sub", key: "x", style: { marginLeft: "6px" } }, open === r.name ? t("ad.action.collapse") : t("ad.action.view")),
 								]);
 							})),
 					open && body ? h("pre", { className: "smem-report-pre", key: "body" }, body) : null,
@@ -4929,12 +5383,25 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			const sBusy = react.useState(false); const busy = sBusy[0], setBusy = sBusy[1];
 
 			const TH_KEYS = ["archiveAfterDaysProject", "archiveAfterDaysReference", "archiveAfterDaysUser"];
-			const TH_LABEL = { archiveAfterDaysProject: "项目", archiveAfterDaysReference: "参考", archiveAfterDaysUser: "用户" };
-			const TH_HINT = {
-				archiveAfterDaysProject: "project_* 连续这么多天没被注入 → 进候选",
-				archiveAfterDaysReference: "reference_* 同上（资料一般比项目留得久）",
-				archiveAfterDaysUser: "user_* 同上（人设这类动它要格外谨慎）",
+			// 2.1.0：标签与提示走字典（键在这里，文案在 55-i18n-memory.js）。
+			const TH_LABEL_KEY = {
+				archiveAfterDaysProject: "archive.th.project",
+				archiveAfterDaysReference: "archive.th.reference",
+				archiveAfterDaysUser: "archive.th.user",
+			};
+			const TH_HINT_KEY = {
+				archiveAfterDaysProject: "archive.th.hintProject",
+				archiveAfterDaysReference: "archive.th.hintReference",
+				archiveAfterDaysUser: "archive.th.hintUser",
 			};
+			const thLabel = function (k) { return t(TH_LABEL_KEY[k] || ""); };
+			const thHint = function (k) { return t(TH_HINT_KEY[k] || ""); };
+			// 2.1.0：三档策略的标题与代价走字典。键必须**写成字面量**（死键守卫会逐键回分片里找）；
+			// 用 "archive.mode." + v 拼接既拿不到字面量，也会让守卫把前缀当成一个缺失的键。
+			const MODE_KEY = { off: "archive.mode.off", report: "archive.mode.report", auto: "archive.mode.auto" };
+			const COST_KEY = { off: "archive.cost.off", report: "archive.cost.report", auto: "archive.cost.auto" };
+			const modeLabel = function (v) { return t(MODE_KEY[v] || ""); };
+			const costText = function (v) { return t(COST_KEY[v] || ""); };
 
 			/** 阈值 → 输入框草稿。存成字符串：number input 清空时立刻变 0 会很难用。 */
 			const draftOf = function (c) {
@@ -4946,18 +5413,18 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 
 			react.useEffect(function () {
 				if (!remote || typeof remote.getConfig !== "function") {
-					setErr("宿主侧没有 autodream 配置接口（插件版本较旧）");
+					setErr(t("archive.err.noConfig"));
 					return;
 				}
 				remote.getConfig()
 					.then(function (r) {
 						const d = unwrap(r);
 						const c = d && d.config ? d.config : null;
-						if (!c) { setErr("读不出自动做梦配置"); return; }
+						if (!c) { setErr(t("archive.err.readConfig")); return; }
 						setCfg(c);
 						setDraft(draftOf(c));
 					})
-					.catch(function (e) { setErr("读配置失败：" + ((e && e.message) || e)); });
+					.catch(function (e) { setErr(t("archive.err.readFailed", { error: (e && e.message) || e })); });
 			}, []);
 
 			const c = cfg || {};
@@ -4979,16 +5446,16 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 						if (got) { setCfg(got); setDraft(draftOf(got)); }
 						const bad = failOf(got);
 						if (!bad) { setNotice(okMsg); return; }
-						setErr("保存没生效：" + bad + "。setConfig 对非法值会忽略并保留原值 —— 请重试，或看 DSH 启动日志。");
+						setErr(t("archive.err.notApplied", { error: bad }));
 					})
-					.catch(function (e) { setErr("保存失败：" + ((e && e.message) || e)); })
+					.catch(function (e) { setErr(t("archive.err.saveFailed", { error: (e && e.message) || e })); })
 					.then(function () { setBusy(false); });
 			}
 
 			function saveMode(v) {
-				save({ autoArchive: v }, "自动归档已设为「" + AUTO_ARCHIVE_LABEL[v] + "」", function (got) {
+				save({ autoArchive: v }, t("archive.notice.modeSet", { mode: modeLabel(v) }), function (got) {
 					const g = got ? autoArchiveOf(got.autoArchive) : null;
-					return g === v ? null : ("配置里仍是「" + (g ? AUTO_ARCHIVE_LABEL[g] : "读不出来") + "」");
+					return g === v ? null : t("archive.err.modeStill", { mode: g ? modeLabel(g) : t("archive.unknown") });
 				});
 			}
 
@@ -4999,15 +5466,15 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				for (const k of TH_KEYS) {
 					const n = Number(d[k]);
 					if (!Number.isFinite(n) || n < 1 || n > 3650) {
-						setErr(TH_LABEL[k] + "的阈值要是 1~3650 之间的天数（现在是「" + d[k] + "」）");
+						setErr(t("archive.err.thresholdBad", { label: thLabel(k), value: d[k] }));
 						return;
 					}
 					patch[k] = Math.round(n);
 				}
-				save(patch, "归档条件已保存", function (got) {
+				save(patch, t("archive.notice.thresholdsSaved"), function (got) {
 					const bad = TH_KEYS.filter(function (k) { return !got || Number(got[k]) !== patch[k]; });
 					if (!bad.length) return null;
-					return bad.map(function (k) { return TH_LABEL[k] + " 仍是 " + (got ? got[k] : "读不出来"); }).join("、");
+					return bad.map(function (k) { return t("archive.err.thresholdStill", { label: thLabel(k), value: got ? got[k] : t("archive.unknown") }); }).join(t("ad.toolSep"));
 				});
 			}
 
@@ -5015,45 +5482,41 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				// ── ① 它做什么（这一屏存在的理由写在最前面）──
 				h("div", { className: "smem-autodream-sec", key: "what" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "自动归档做什么"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("archive.title")),
 					]),
-					h("div", { className: "smem-autodream-note", key: "p1" },
-						"闲置太久没被注入过的记忆，会被移进 archive/ —— 不删除，随时能恢复。这一页决定「多久算闲置」，以及要不要真的动手。"),
-					h("div", { className: "smem-autodream-note", key: "p2" },
-						"它不调模型：候选完全按访问台账的天数算，同一份输入每次算出来都一样。"),
-					h("div", { className: "smem-autodream-note", key: "p3" },
-						"想现在看看会被收走哪些：文件列表 →「工具 ▾」→ 归档候选。"),
+					h("div", { className: "smem-autodream-note", key: "p1" }, t("archive.intro1")),
+					h("div", { className: "smem-autodream-note", key: "p2" }, t("archive.intro2")),
+					h("div", { className: "smem-autodream-note", key: "p3" }, t("archive.intro3")),
 				]),
 				// ── ② 三档策略 ──
 				h("div", { className: "smem-autodream-sec", key: "mode" }, [
 					h("div", { className: "smem-autodream-row", key: "r" }, [
-						h("span", { className: "smem-autodream-key", key: "k" }, "自动归档"),
+						h("span", { className: "smem-autodream-key", key: "k" }, t("archive.modeTitle")),
 						h(Seg, {
 							key: "v", value: mode,
 							options: [
-								{ value: "off", label: AUTO_ARCHIVE_LABEL.off },
-								{ value: "report", label: AUTO_ARCHIVE_LABEL.report },
-								{ value: "auto", label: AUTO_ARCHIVE_LABEL.auto },
+								{ value: "off", label: modeLabel("off") },
+								{ value: "report", label: modeLabel("report") },
+								{ value: "auto", label: modeLabel("auto") },
 							],
 							onChange: function (v) { if (v !== mode) saveMode(v); },
 						}),
-						busy ? h("span", { className: "smem-status", key: "s" }, "保存中…") : null,
+						busy ? h("span", { className: "smem-status", key: "s" }, t("archive.action.saving")) : null,
 					]),
-					h("div", { className: "smem-autodream-note", key: "cost" }, AUTO_ARCHIVE_COST[mode]),
+					h("div", { className: "smem-autodream-note", key: "cost" }, costText(mode)),
 					mode === "auto" && !c.apply
-						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "deg" },
-								"注意：「自动做梦 → 改动方式」现在是只出报告 —— 这一档会自动降级成只出报告，不会动文件。")
+						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "deg" }, t("archive.degrade"))
 						: null,
 				]),
 				// ── ③ 三个阈值 ──
 				h("div", { className: "smem-autodream-sec", key: "th" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "闲置多少天算可以归档"),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("archive.th.title")),
 					]),
 					draft
 						? h("div", { key: "rows" }, TH_KEYS.map(function (k) {
 								return h("div", { className: "smem-autodream-row", key: k }, [
-									h("span", { className: "smem-autodream-key", key: "k" }, TH_LABEL[k]),
+									h("span", { className: "smem-autodream-key", key: "k" }, thLabel(k)),
 									h("input", {
 										className: "smem-input smem-num", key: "i", type: "number", min: 1, max: 3650,
 										value: draft[k],
@@ -5063,19 +5526,18 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 											setDraft(nx);
 										},
 									}),
-									h("span", { className: "smem-muted", key: "u" }, TH_HINT[k]),
+									h("span", { className: "smem-muted", key: "u" }, thHint(k)),
 								]);
 							}))
-						: h("div", { className: "smem-muted", key: "loading" }, "读配置中…"),
+						: h("div", { className: "smem-muted", key: "loading" }, t("archive.loadingConfig")),
 					h("div", { className: "smem-autodream-row", key: "btns" }, [
 						h("button", {
 							type: "button", className: "smem-btn smem-btn-primary", key: "save",
 							disabled: busy || !draft, onClick: saveThresholds,
-						}, busy ? "保存中…" : "保存归档条件"),
-						h("span", { className: "smem-muted", key: "n" }, "保存即生效，不用重启 DSH"),
+						}, busy ? t("archive.action.saving") : t("archive.action.save")),
+						h("span", { className: "smem-muted", key: "n" }, t("archive.note.immediate")),
 					]),
-					h("div", { className: "smem-autodream-note", key: "note" },
-						"天数按访问台账算（这条记忆上次被注入给模型是什么时候）。feedback_* 永不入选；锁定的记忆也不会被选中。"),
+					h("div", { className: "smem-autodream-note", key: "note" }, t("archive.note.thresholds")),
 				]),
 				err ? h("div", { className: "smem-err", key: "err" }, "⚠ " + err) : null,
 				notice ? h("div", { className: "smem-ok", key: "ok" }, "✓ " + notice) : null,