dsh-instruction-memory 1.0.16 → 1.0.18

package/CHANGELOG.md

@@ -7,6 +7,64 @@
 > 1.0.13 起由 CI 经 OIDC Trusted Publishing 发布（首个带 provenance 的版本）。
 > 这些历史 tag **不应回填**——npm 上的版本号已被占用。
 
+## [1.0.18] — 2026-10-13
+
+### 新增
+
+- **标签分组（F2）**：每条指令可维护若干标签（编辑器内回车/逗号/分号提交的 chips，最多 8 个、
+  单个不超过 24 字符；去空白、折叠连续空白、去重）。标签只服务于设置页，**不会进入注入文本**，
+  `buildBlock`/`planInjection` 的输出与决策不受其影响。条目新增可选 `tags: string[]`（格式仍为 v1，
+  旧记忆无该字段即按无标签加载）。
+- **多维筛选与排序（F2）**：列表可按标签（chips）、生效方式（始终/按需）、启用状态组合筛选，
+  并在按优先级 / 按更新时间 / 按标题之间切换排序；关键词搜索与这些筛选叠加且覆盖标签文本。
+  排序仅影响列表展示，宿主侧注入顺序不变。筛选无结果时给出独立空态文案。
+- **批量操作（F3）**：设置页新增多选模式，可一次性启用、停用、设置优先级、加标签或删除；
+  全选只作用于当前筛选/搜索后的可见条目，批量删除需确认。Host 新增 `batch` 路由
+  （`set-enabled` / `set-priority` / `add-tags` / `remove-tags` / `delete` 五个 op）：
+  整批在**单次事务**内完成（一次落盘、rev 只 +1、一次 SSE 推送），先纯计算变更计划，
+  全部条目已是目标状态或只涉及不存在 id 时不写盘，部分命中会在消息中注明未找到的条数；
+  复用未来版本拒绝、rev 冲突、写盘失败回滚等既有保护。批量元数据调整不重盖 `updatedAt`。
+- 请求体上限推导纳入标签字段，继续保证「本插件导出的文件必能导回」。
+
+### 测试
+
+- `smoke-test.mjs` 新增标签规范化与「标签不进注入文本/计划」断言。
+- `contract-test.mjs` 新增独立 `batch` 验证块：经真实路由断言五个 op、单次事务（rev 恰好 +1）、
+  no-op 不写盘、部分命中计数、非法 op/value/空 ids 拒绝、stale rev 冲突、标签不进 preview。
+- `verify.mjs` 新增客户端 `__parseTagInput` 断言（分隔符、空白折叠、去重、上限、非字符串输入）
+  与 F2/F3 双语文案键存在性；`draftIsDirty` 对 `tags` 缺省/`[]` 归一比较，旧条目不被误判为已修改。
+- `docs/demo.html` 演示数据加入标签，演示宿主支持 `batch` 路由与标签编辑/筛选/排序/批量操作。
+
+## [1.0.17] — 2026-10-12
+
+### 新增
+
+- **注入预算可视化（F1）**：设置页在「注入字数上限」下方显示用量条与「实际注入 x / y 字符
+  （约 z token，估算）」（token 按 0.6 系数估算，与既有说明同一口径，仅作参考）；被上限略过的
+  **生效中**条目在列表中逐条标注橙色「本轮不注入」（悬停说明原因），极端情况下首条被迫截断时
+  标注红色「已截断」，用量条同时变为警示色并给出条数提示。调高上限或调整优先级保存后标记即时变化。
+- Host 新增导出纯函数 `planInjection(data)`：在**不改变注入文本一个字节**的前提下，返回注入文本、
+  生效上限（clamp 后的 budget）、候选条目数，以及每条 `included`（`{id, chars, truncated}`）
+  / `omitted`（`{id, chars}`）的取舍明细与考虑顺序（先「始终」后「按需」、同档优先级/更新时间降序）；
+  `buildBlock()` 改为它的薄封装。
+- 快照 `injection` 新增 `budget` / `activeCount` / `included` / `omitted` 字段（SSE 帧随之自动携带）。
+  存储格式仍为 v1、**无新增落盘字段**；旧客户端收到新字段自然忽略，新客户端对没有这些字段的旧宿主
+  快照回退到 `data.budgetChars`、不显示条目标记，两侧均不报错。
+
+### 测试
+
+- `smoke-test.mjs` 新增 20+ 条 `planInjection` 断言：空/总开关关闭/非法输入、budget 越界夹取、
+  与 `buildBlock()` 逐字节一致、停用与空条目不参与、「始终」先于「按需」、紧预算下 included/omitted
+  恰好分区全部候选、单条超长首条截断标记、计划本身确定性。
+- `contract-test.mjs` 新增独立验证块：经真实路由在 800 字符上限下断言快照预算、`chars === preview.length`
+  且不超上限、取舍明细恰好覆盖全部生效条目且不含停用条目、预览脚注数量与 omitted 一致、提高上限后
+  全部纳入；并把真实/旧版/垃圾三类快照喂给客户端 reducer 验证接缝。
+- `verify.mjs` 新增客户端 `__budgetMeter` reducer 断言（计划字段优先、旧快照回退、非法项忽略、
+  垃圾输入零值不抛错、percent 封顶 100、0.6 token 估算）及 6 个新 i18n 键的双语存在性；
+  键集与占位符一致性仍由既有用例锁定。
+- `docs/demo.html` 的演示宿主改为实时计算注入计划（与 `planInjection` 同一算法），演示数据
+  默认 800 字符上限以直接展示用量条与「本轮不注入」标记；旧的手工静态预览文本移除。
+
 ## [1.0.16] — 2026-10-05
 
 一次定向缺陷修复 + 宿主范围扩展。每项修复都有对应回归断言（`npm test` 五套件全绿：

package/README.md

@@ -54,6 +54,19 @@ dsh plugin --profile web remove dsh-instruction-memory
   上限单位是**字符**而非 token——按 DeepSeek 官方分词比例约 1 个中文字符 ≈ 0.6 token、
   1 个英文字符 ≈ 0.3 token（不同模型分词有差异，实际用量以模型返回为准），上限 40000
   字符约合 24000 token。
+- **预算用量可视化**：设置页在上限输入框下方显示用量条——「实际注入 x / y 字符（约 z token，
+  估算）」（token 数按 0.6 系数估算，仅作参考）；被上限略过的**生效中**条目会在列表里逐条
+  标注橙色「本轮不注入」（悬停可见原因），极端情况下首条被迫截断时标注红色「已截断」。
+  调高上限或调整优先级后标记实时变化。这些数据只是对注入取舍的**展示**，不改变注入文本本身；
+  存储格式不变，旧宿主/旧客户端对新字段一律忽略，互不影响。
+- **标签、筛选与排序**：每条指令可加若干**标签**（回车或逗号添加，最多 8 个、单个不超过 24 字符）。
+  标签只用于设置页分组与筛选，**不会进入注入文本**；标签缺失的旧记忆照常加载（等同无标签）。
+  列表可按标签、生效方式（始终/按需）、启用状态组合筛选，并在「按优先级 / 按更新时间 / 按标题」
+  之间切换排序；列表排序纯为查看方便，不改变宿主侧的注入顺序。
+- **批量操作**：点「批量操作」进入多选，可对勾选条目一次性启用、停用、设置优先级、加标签或删除；
+  多选与上方的筛选/搜索叠加（「全选」只作用于当前可见条目）。整批修改在宿主侧是**单次写入**
+  （只产生一次落盘、一次修订号递增与一次同步推送），全部条目已是目标状态时不写盘；批量删除需确认。
+  批量的启停/优先级/标签调整不重盖更新时间，因此不会改变同优先级下的注入先后。
 
 条目全部停用或总开关关闭时，该提示词段落**整个注销**，系统提示词与未安装本插件时逐字节一致。
 
@@ -432,6 +445,7 @@ Package → Settings → Trusted publishing → Add trusted publisher
       "when": "",
       "priority": 1,
       "enabled": true,
+      "tags": ["沟通"],
       "updatedAt": 1700000000000
     }
   ]
@@ -439,4 +453,6 @@ Package → Settings → Trusted publishing → Add trusted publisher
 ```
 
 `mode` 为 `always` | `auto`；`priority` 为 `2` 高 / `1` 普通 / `0` 低。`rev` 是存储修订号，
-由插件在每次成功写入时递增，**无需手填**（缺失视为 0）。
+由插件在每次成功写入时递增，**无需手填**（缺失视为 0）。`tags` 为可选的短标签字符串数组
+（最多 8 个、单个不超过 24 字符，仅用于设置页筛选，不参与注入）；缺失或非数组一律按无标签处理，
+非法项会被剔除、超长会被截断、重复项会去重，格式版本号仍为 `1`。

package/lib/client.js

@@ -58,6 +58,31 @@ window.__ModuleLoader__.load({
 .im-tag-always { color:var(--dsw-alias-brand-primary,#3b6cff); border-color:currentColor; }
 .im-tag-auto { color:var(--dsw-alias-state-success-primary,#18a058); border-color:currentColor; }
 .im-tag-high { color:var(--dsw-alias-state-warn-primary,#d97706); border-color:currentColor; }
+.im-tag-off { color:var(--dsw-alias-state-warn-primary,#d97706); border-color:currentColor; }
+.im-tag-cut { color:var(--dsw-alias-state-error-primary,#d94838); border-color:currentColor; }
+.im-meter { height:6px; border-radius:999px; overflow:hidden;
+  background:var(--dsw-alias-bg-layer-2,rgba(0,0,0,.08)); }
+.im-meter-fill { height:100%; border-radius:999px; background:var(--dsw-alias-brand-primary,#3b6cff); }
+.im-meter-fill-warn { background:var(--dsw-alias-state-warn-primary,#d97706); }
+.im-entry-tags { display:flex; flex-wrap:wrap; gap:4px; }
+.im-chip { display:inline-flex; align-items:center; gap:3px; padding:1px 4px 1px 9px; border-radius:999px; font-size:11px;
+  border:1px solid var(--dsw-alias-border-l1,rgba(0,0,0,.14)); color:var(--dsw-alias-label-secondary,#6b7280);
+  background:var(--dsw-alias-bg-layer-2,rgba(0,0,0,.03)); white-space:nowrap; }
+.im-chip-x { border:none; background:transparent; color:inherit; cursor:pointer; font-size:13px; line-height:1;
+  padding:0 5px; border-radius:999px; }
+.im-chip-x:hover:not(:disabled) { background:rgba(0,0,0,.08); }
+.im-filter-row { display:flex; flex-direction:column; gap:7px; }
+.im-filter-chips { display:flex; flex-wrap:wrap; gap:6px; }
+.im-filter-chip { border:1px solid var(--dsw-alias-border-l2,rgba(0,0,0,.18)); background:var(--dsw-alias-bg-layer-1,#fff);
+  color:inherit; border-radius:999px; padding:2px 11px; font-size:11.5px; font-family:inherit; cursor:pointer; }
+.im-filter-chip-on { background:var(--dsw-alias-brand-primary,#3b6cff); border-color:transparent; color:#fff; }
+.im-filter-selects { display:flex; flex-wrap:wrap; gap:12px; }
+.im-fselect { display:flex; align-items:center; gap:6px; font-size:12px; color:var(--dsw-alias-label-secondary,#8a9099); }
+.im-select-sm { padding:3px 6px; font-size:12px; border-radius:7px; border:1px solid var(--dsw-alias-border-l2,rgba(0,0,0,.18));
+  background:var(--dsw-alias-bg-base,#fff); color:inherit; }
+.im-batch-bar { display:flex; align-items:center; gap:8px; flex-wrap:wrap; padding:10px 12px; border-radius:10px;
+  border:1px solid var(--dsw-alias-state-warn-primary,#d97706); background:rgba(217,119,6,.08); }
+.im-batch-check { width:15px; height:15px; margin:0; cursor:pointer; accent-color:var(--dsw-alias-brand-primary,#3b6cff); }
 .im-empty { padding:26px; border-radius:10px; text-align:center; font-size:12px;
   border:1px dashed var(--dsw-alias-border-l2,rgba(0,0,0,.18)); color:var(--dsw-alias-label-secondary,#8a9099); }
 .im-err { font-size:12px; color:var(--dsw-alias-state-error-primary,#d94838); }
@@ -79,6 +104,7 @@ window.__ModuleLoader__.load({
 .im-body-open { max-height:none; }
 .im-more { margin-top:4px; font-size:11.5px; color:var(--dsw-alias-brand-primary,#3b6cff); cursor:pointer; user-select:none; }
 .im-search-meta { margin-top:5px; }
+.im-meter-line { margin-top:5px; }
 .im-undo { display:flex; align-items:center; gap:10px; padding:9px 13px; border-radius:8px; font-size:12px;
   border:1px solid var(--dsw-alias-border-l2,rgba(0,0,0,.14)); background:var(--dsw-alias-bg-layer-2,rgba(0,0,0,.04)); }
 .im-undo button { border:1px solid var(--dsw-alias-brand-primary,#3b6cff); color:var(--dsw-alias-brand-primary,#3b6cff);
@@ -140,10 +166,47 @@ window.__ModuleLoader__.load({
         'budget.unitHint': '单位是字符，不是 token',
         'budget.rangeError': '上限需在 {min} ~ {max} 之间',
         'budget.note': '单位为字符、非 token：按 DeepSeek 分词约 1 个中文字符 ≈ 0.6 token（英文 ≈ 0.3），{max} 字符上限约合 {tokens} token，实际以模型为准。',
+        'budget.used': '实际注入 {used} / {budget} 字符（约 {tokens} token，估算）',
+        'budget.omitted': '有 {count} 条生效指令因超出上限本轮未注入，可调高上限或调整优先级',
+        'tag.omitted': '本轮不注入',
+        'tag.truncated': '已截断',
+        'tag.omittedTitle': '因超出注入字数上限，本条当前不会进入系统提示词',
+        'tag.truncatedTitle': '本条过长，仅开头部分进入系统提示词',
         'rules.label': '生效规则',
         'rules.note': '「始终」无条件生效；「按需」由模型按相关性自动判断。超出上限时按优先级保留，其余暂不注入。',
         'search.placeholder': '搜索指令：标题 / 内容 / 适用场景（共 {count} 条）',
         'search.matchCount': '匹配 {shown} / {total} 条',
+        'tags.label': '标签（可选，仅用于在本页分组与筛选，不会注入提示词）',
+        'tags.placeholder': '输入标签后回车，逗号分隔多个，例如：代码规范',
+        'tags.hint': '每条最多 {max} 个标签，单个不超过 {len} 字符',
+        'tags.duplicate': '已有同名标签',
+        'tags.full': '每条最多 {max} 个标签',
+        'filter.all': '全部',
+        'filter.tag': '标签',
+        'filter.mode': '生效方式',
+        'filter.status': '状态',
+        'filter.modeAlways': '始终',
+        'filter.modeAuto': '按需',
+        'filter.statusEnabled': '已启用',
+        'filter.statusDisabled': '已停用',
+        'sort.label': '排序',
+        'sort.priority': '按优先级',
+        'sort.updated': '按更新时间',
+        'sort.title': '按标题',
+        'action.batch': '批量操作',
+        'batch.exit': '退出批量',
+        'batch.selectAll': '全选',
+        'batch.selected': '已选 {count} 条',
+        'batch.enable': '启用',
+        'batch.disable': '停用',
+        'batch.priority': '设优先级…',
+        'batch.addTags': '加标签…',
+        'batch.delete': '删除',
+        'batch.confirmDelete': '确定删除选中的 {count} 条指令？删除后无法恢复。',
+        'batch.tagPrompt': '输入要添加到 {count} 条指令的标签（多个用逗号分隔）',
+        'batch.tagEmpty': '未输入有效的标签',
+        'batch.noneSelected': '请先勾选要操作的指令',
+        'batch.promptUnavailable': '当前环境不支持快捷输入，请逐条编辑标签',
         'action.new': '＋ 新增指令',
         'action.reload': '重新载入',
         'action.export': '导出',
@@ -160,6 +223,7 @@ window.__ModuleLoader__.load({
         'preview.empty': '（当前没有生效中的指令）',
         'list.empty': '还没有指令记忆。点击「＋ 新增指令」添加第一条，例如“所有回答使用简体中文”。',
         'list.noMatch': '没有匹配“{query}”的指令。',
+        'list.filteredEmpty': '没有符合当前筛选条件的指令。',
         'tag.always': '始终',
         'tag.auto': '按需',
         'entry.enabled': '启用',
@@ -217,10 +281,47 @@ window.__ModuleLoader__.load({
         'budget.unitHint': 'The unit is characters, not tokens',
         'budget.rangeError': 'The limit must be between {min} and {max}',
         'budget.note': 'Characters, not tokens: with DeepSeek tokenization roughly 1 Chinese character ≈ 0.6 token (English ≈ 0.3), the {max}-character ceiling is about {tokens} tokens; actual usage depends on the model.',
+        'budget.used': '{used} of {budget} characters actually injected (≈{tokens} tokens, estimate)',
+        'budget.omitted': '{count} active entries are not injected this turn because the limit is exceeded; raise the limit or adjust priorities',
+        'tag.omitted': 'Not injected',
+        'tag.truncated': 'Truncated',
+        'tag.omittedTitle': 'This entry currently stays out of the system prompt because the injection size limit is exceeded',
+        'tag.truncatedTitle': 'This entry is too long; only its beginning reaches the system prompt',
         'rules.label': 'How instructions apply',
         'rules.note': '“Always” applies unconditionally; “On demand” lets the model judge by relevance. When the limit is exceeded, higher-priority entries are kept and the rest are skipped.',
         'search.placeholder': 'Search instructions: title / content / scenario ({count} in total)',
         'search.matchCount': '{shown} of {total} match',
+        'tags.label': 'Tags (optional; used only for grouping/filtering on this page, never injected)',
+        'tags.placeholder': 'Type a tag and press Enter; separate several with commas, e.g. code-style',
+        'tags.hint': 'Up to {max} tags per entry, each at most {len} characters',
+        'tags.duplicate': 'This tag already exists',
+        'tags.full': 'Up to {max} tags per entry',
+        'filter.all': 'All',
+        'filter.tag': 'Tag',
+        'filter.mode': 'Mode',
+        'filter.status': 'Status',
+        'filter.modeAlways': 'Always',
+        'filter.modeAuto': 'On demand',
+        'filter.statusEnabled': 'Enabled',
+        'filter.statusDisabled': 'Disabled',
+        'sort.label': 'Sort',
+        'sort.priority': 'By priority',
+        'sort.updated': 'By updated time',
+        'sort.title': 'By title',
+        'action.batch': 'Bulk actions',
+        'batch.exit': 'Exit bulk',
+        'batch.selectAll': 'Select all',
+        'batch.selected': '{count} selected',
+        'batch.enable': 'Enable',
+        'batch.disable': 'Disable',
+        'batch.priority': 'Set priority…',
+        'batch.addTags': 'Add tags…',
+        'batch.delete': 'Delete',
+        'batch.confirmDelete': 'Delete the {count} selected entries? This cannot be undone.',
+        'batch.tagPrompt': 'Enter tags to add to {count} entries (separate several with commas)',
+        'batch.tagEmpty': 'No valid tag entered',
+        'batch.noneSelected': 'Tick the entries to act on first',
+        'batch.promptUnavailable': 'Quick entry is unavailable in this environment; edit tags one by one',
         'action.new': '＋ New instruction',
         'action.reload': 'Reload',
         'action.export': 'Export',
@@ -237,6 +338,7 @@ window.__ModuleLoader__.load({
         'preview.empty': '(no active instructions right now)',
         'list.empty': 'No instructions yet. Click “＋ New instruction” to add your first one, e.g. “Always answer in Simplified Chinese”.',
         'list.noMatch': 'No instructions match “{query}”.',
+        'list.filteredEmpty': 'No instructions match the current filters.',
         'tag.always': 'Always',
         'tag.auto': 'On demand',
         'entry.enabled': 'Enabled',
@@ -377,6 +479,32 @@ window.__ModuleLoader__.load({
 
     /* ---------------- data helpers ---------------- */
 
+    // Mirror the Host's tag limits (lib/index.js); kept local so the editor
+    // constrains input before the round-trip and tests can pin both to match.
+    const MAX_TAGS = 8
+    const MAX_TAG_LEN = 24
+
+    /**
+     * Parse free text typed into the tag box into normalised tag candidates.
+     * Tags are split on commas (ASCII/full-width), semicolons and newlines —
+     * never spaces, so a tag may contain spaces. Each piece is trimmed,
+     * collapsed to one line, cut to MAX_TAG_LEN, de-duplicated and capped at
+     * MAX_TAGS. Pinned as a pure export.
+     */
+    function parseTagInput(text) {
+      if (typeof text !== 'string') return []
+      const out = []
+      const seen = new Set()
+      for (const piece of text.split(/[,，;；\n\r]+/)) {
+        const tag = piece.replace(/\s+/g, ' ').trim().slice(0, MAX_TAG_LEN)
+        if (tag === '' || seen.has(tag)) continue
+        seen.add(tag)
+        if (out.length >= MAX_TAGS) break
+        out.push(tag)
+      }
+      return out
+    }
+
     function cloneEntry(entry) {
       return {
         id: entry.id,
@@ -386,12 +514,13 @@ window.__ModuleLoader__.load({
         when: entry.when,
         priority: entry.priority,
         enabled: entry.enabled,
+        tags: Array.isArray(entry.tags) ? entry.tags.slice() : [],
         updatedAt: entry.updatedAt,
       }
     }
 
     function blankDraft() {
-      return { id: '', title: '', content: '', mode: 'always', when: '', priority: 1, enabled: true, updatedAt: 0 }
+      return { id: '', title: '', content: '', mode: 'always', when: '', priority: 1, enabled: true, tags: [], updatedAt: 0 }
     }
 
     /**
@@ -409,7 +538,11 @@ window.__ModuleLoader__.load({
       const fields = ['title', 'content', 'mode', 'when', 'priority', 'enabled']
       const base = draft.id === '' ? blankDraft() : (entries || []).find((entry) => entry.id === draft.id)
       if (base === undefined) return true
-      return fields.some((field) => String(draft[field]) !== String(base[field]))
+      if (fields.some((field) => String(draft[field]) !== String(base[field]))) return true
+      // Tags are an optional array that may be absent on old entries; compare
+      // a normalised form so [] and undefined both read as "no tags".
+      const tagsKey = (entry) => (Array.isArray(entry && entry.tags) ? entry.tags : []).join('')
+      return tagsKey(draft) !== tagsKey(base)
     }
 
     /**
@@ -497,6 +630,41 @@ window.__ModuleLoader__.load({
       return focused ? currentText : String(incoming)
     }
 
+    /**
+     * Reduce a snapshot's injection plan to the values the header meter and
+     * the entry badges render. Pinned as a pure export so the fallback math is
+     * testable without React.
+     *
+     * Tolerates an older Host whose snapshot predates the plan fields: the
+     * ceiling then falls back to data.budgetChars and there are simply no
+     * per-entry marks (included/omitted). Garbage input degrades to zeros
+     * instead of throwing mid-render.
+     */
+    function budgetMeter(snapshot) {
+      const inj = snapshot !== null && typeof snapshot === 'object'
+        && snapshot.injection !== null && typeof snapshot.injection === 'object'
+        ? snapshot.injection : {}
+      const data = snapshot !== null && typeof snapshot === 'object'
+        && snapshot.data !== null && typeof snapshot.data === 'object'
+        ? snapshot.data : {}
+      const budget = typeof inj.budget === 'number' && inj.budget > 0
+        ? inj.budget
+        : (typeof data.budgetChars === 'number' && data.budgetChars > 0 ? data.budgetChars : 0)
+      const used = typeof inj.chars === 'number' && inj.chars >= 0 ? inj.chars : 0
+      const countFlagged = (list, wantTruncated) =>
+        Array.isArray(list)
+          ? list.filter((item) => item !== null && typeof item === 'object'
+            && typeof item.id === 'string' && item.id !== ''
+            && (wantTruncated ? item.truncated === true : true)).length
+          : 0
+      const omitted = countFlagged(inj.omitted, false)
+      const truncated = countFlagged(inj.included, true)
+      const percent = budget > 0 ? Math.min(100, Math.round((used / budget) * 100)) : 0
+      // The same rough ratio the budget note quotes; displayed as an ESTIMATE.
+      const tokens = Math.round(used * 0.6)
+      return { budget, used, omitted, truncated, percent, tokens }
+    }
+
     async function callHost(method, args) {
       // A hung host used to pin the panel on 保存中… forever; fail visibly
       // after a generous timeout instead.
@@ -588,6 +756,13 @@ window.__ModuleLoader__.load({
             onChange: (ev) => set({ when: ev.target.value }),
           })))
       }
+      children.push(h('div', { key: 'tags' },
+        h('label', { className: 'im-label' }, t('tags.label')),
+        h(TagInput, {
+          tags: draft.tags,
+          disabled: props.busy,
+          onChange: (next) => set({ tags: next }),
+        })))
       children.push(h('div', { className: 'im-row-wrap', key: 'a' },
         h('button', { className: 'im-btn im-btn-primary', disabled: props.busy, onClick: props.onSave },
           props.busy ? t('editor.saving') : t('editor.save')),
@@ -597,6 +772,73 @@ window.__ModuleLoader__.load({
       return h('div', { className: 'im-card' }, children)
     }
 
+    /**
+     * Tag chips editor for one entry. Tags live only on this panel (they are
+     * never injected). Committing (Enter / comma / semicolon / blur) parses the
+     * typed text through parseTagInput and merges de-duplicated tags up to the
+     * shared cap; Backspace on an empty box removes the last chip.
+     */
+    function TagInput(props) {
+      const [text, setText] = React.useState('')
+      const tags = Array.isArray(props.tags) ? props.tags : []
+      const merge = (pieces) => {
+        const merged = []
+        for (const tag of [...tags, ...pieces]) {
+          if (!merged.includes(tag)) merged.push(tag)
+        }
+        props.onChange(merged.slice(0, MAX_TAGS))
+      }
+      const commit = () => {
+        const parsed = parseTagInput(text)
+        if (parsed.length > 0) merge(parsed)
+        setText('')
+      }
+      const remove = (tag) => {
+        props.onChange(tags.filter((candidate) => candidate !== tag))
+      }
+      return h('div', null,
+        tags.length > 0
+          ? h('div', { className: 'im-entry-tags' },
+            tags.map((tag) => h('span', { className: 'im-chip', key: tag },
+              tag,
+              h('button', {
+                type: 'button', className: 'im-chip-x', disabled: props.disabled,
+                onClick: () => remove(tag),
+              }, '×'))))
+          : null,
+        h('input', {
+          className: 'im-input',
+          value: text,
+          disabled: props.disabled,
+          maxLength: MAX_TAG_LEN,
+          placeholder: t('tags.placeholder'),
+          onChange: (ev) => {
+            const v = ev.target.value
+            if (/[,，;；\n\r]/.test(v)) {
+              // A separator commits the pending text as chips immediately.
+              // v is the input's full new value (it already contains what was
+              // typed before the separator) — do NOT prepend `text`, that
+              // duplicated it ("b" + "b," -> "bb").
+              const parsed = parseTagInput(v)
+              if (parsed.length > 0) merge(parsed)
+              setText('')
+            } else {
+              setText(v.slice(0, MAX_TAG_LEN))
+            }
+          },
+          onKeyDown: (ev) => {
+            if (ev.key === 'Enter') {
+              ev.preventDefault()
+              commit()
+            } else if (ev.key === 'Backspace' && text === '' && tags.length > 0) {
+              remove(tags[tags.length - 1])
+            }
+          },
+          onBlur: commit,
+        }),
+        h('div', { className: 'im-meta' }, t('tags.hint', { max: MAX_TAGS, len: MAX_TAG_LEN })))
+    }
+
     /**
      * Entry body with an explicit 展开/收起 toggle. The collapsed cap lives in
      * CSS (max-height + overflow:hidden), so whether overflow actually happens
@@ -632,6 +874,14 @@ window.__ModuleLoader__.load({
       const [showPreview, setShowPreview] = React.useState(false)
       const [query, setQuery] = React.useState('')
       const [undo, setUndo] = React.useState(null)
+      // F2: tag/mode/status filters ('' = all) and the list sort key.
+      const [tagFilter, setTagFilter] = React.useState('')
+      const [modeFilter, setModeFilter] = React.useState('')
+      const [statusFilter, setStatusFilter] = React.useState('')
+      const [sortKey, setSortKey] = React.useState('priority')
+      // F3: bulk-select mode and the chosen entry ids in it.
+      const [batchMode, setBatchMode] = React.useState(false)
+      const [selected, setSelected] = React.useState([])
       const importInputRef = React.useRef(null)
       // Whether the budget input is being edited right now. A live SSE push
       // from another window must not replace the number under the cursor;
@@ -716,6 +966,54 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ---- F3 bulk actions: one request, one host-side transaction ----
+
+      /** Selected ids that still exist in the latest snapshot. */
+      const liveSelected = () => selected.filter((id) => data.entries.some((entry) => entry.id === id))
+
+      function toggleSelected(id) {
+        setSelected((prev) => (prev.includes(id) ? prev.filter((x) => x !== id) : [...prev, id]))
+      }
+
+      function exitBatch() {
+        setBatchMode(false)
+        setSelected([])
+      }
+
+      async function doBatch(op, value) {
+        const ids = liveSelected()
+        if (ids.length === 0) {
+          setError(t('batch.noneSelected'))
+          return
+        }
+        if (op === 'delete'
+          && typeof window.confirm === 'function'
+          && !window.confirm(t('batch.confirmDelete', { count: ids.length }))) {
+          return
+        }
+        const result = await send('batch', { op, ids, value, baseRev: revOf() })
+        if (result !== null && result.ok === true && op === 'delete') {
+          // Drop deleted ids from the selection; other ops keep it so several
+          // bulk actions can be chained (e.g. set priority, then disable).
+          setSelected((prev) => prev.filter((id) => !ids.includes(id)))
+        }
+      }
+
+      function batchAddTags() {
+        if (typeof window.prompt !== 'function') {
+          setError(t('batch.promptUnavailable'))
+          return
+        }
+        const answer = window.prompt(t('batch.tagPrompt', { count: liveSelected().length }), '')
+        if (answer === null) return
+        const tags = parseTagInput(answer)
+        if (tags.length === 0) {
+          setError(t('batch.tagEmpty'))
+          return
+        }
+        void doBatch('add-tags', tags)
+      }
+
       async function doExport() {
         try {
           const result = await callHost('export-data', null)
@@ -835,15 +1133,73 @@ window.__ModuleLoader__.load({
       const storage = view.storage || {}
       const limits = view.limits || { minBudget: 800, maxBudget: 40000, maxEntries: 200 }
       const injection = view.injection || { registered: false, chars: 0, error: null }
-      const entries = data.entries.slice().sort((a, b) => (b.priority - a.priority) || (b.updatedAt - a.updatedAt))
-      const activeCount = entries.filter((e) => e.enabled && e.content !== '').length
+      // List order is display-only and never changes what the Host injects
+      // (the injection order is decided host-side). The default mirrors the
+      // previous fixed order; updated-time and title are the other sorts.
+      const sortEntries = (list) => {
+        const copy = list.slice()
+        if (sortKey === 'updated') {
+          copy.sort((a, b) => (b.updatedAt - a.updatedAt) || (b.priority - a.priority))
+        } else if (sortKey === 'title') {
+          copy.sort((a, b) =>
+            a.title.localeCompare(b.title, undefined, { sensitivity: 'base' })
+            || (b.priority - a.priority)
+            || (b.updatedAt - a.updatedAt))
+        } else {
+          copy.sort((a, b) => (b.priority - a.priority) || (b.updatedAt - a.updatedAt))
+        }
+        return copy
+      }
+      const entries = sortEntries(data.entries)
+      const activeCount = data.entries.filter((e) => e.enabled && e.content !== '').length
+      // Every tag actually in use, most frequent first (then name), for the
+      // tag filter row.
+      const allTags = (() => {
+        const counts = new Map()
+        for (const entry of data.entries) {
+          for (const tag of Array.isArray(entry.tags) ? entry.tags : []) {
+            if (typeof tag === 'string' && tag !== '') counts.set(tag, (counts.get(tag) || 0) + 1)
+          }
+        }
+        return [...counts.entries()]
+          .sort((a, b) => (b[1] - a[1]) || a[0].localeCompare(b[0], undefined, { sensitivity: 'base' }))
+          .map(([tag]) => tag)
+      })()
+      // Budget usage + per-entry marks straight from the Host's injection plan.
+      // Older hosts simply publish none of these fields: the meter falls back
+      // to data.budgetChars and the maps stay empty.
+      const meter = budgetMeter(view)
+      const omittedById = new Map()
+      const truncatedById = new Map()
+      {
+        const planItems = injection && typeof injection === 'object' ? injection : {}
+        for (const item of Array.isArray(planItems.omitted) ? planItems.omitted : []) {
+          if (item !== null && typeof item === 'object' && typeof item.id === 'string') omittedById.set(item.id, item)
+        }
+        for (const item of Array.isArray(planItems.included) ? planItems.included : []) {
+          if (item !== null && typeof item === 'object' && item.truncated === true && typeof item.id === 'string') {
+            truncatedById.set(item.id, item)
+          }
+        }
+      }
       const keyword = query.trim().toLowerCase()
-      const visible = keyword === ''
-        ? entries
-        : entries.filter((entry) =>
-          entry.title.toLowerCase().indexOf(keyword) !== -1
+      const filtersActive = tagFilter !== '' || modeFilter !== '' || statusFilter !== ''
+      const matchesFilters = (entry) => {
+        if (tagFilter !== '' && !(Array.isArray(entry.tags) && entry.tags.includes(tagFilter))) return false
+        if (modeFilter !== '' && entry.mode !== modeFilter) return false
+        if (statusFilter === 'enabled' && entry.enabled !== true) return false
+        if (statusFilter === 'disabled' && entry.enabled !== false) return false
+        return true
+      }
+      const visible = entries.filter((entry) => {
+        if (!matchesFilters(entry)) return false
+        if (keyword === '') return true
+        const inTags = (Array.isArray(entry.tags) ? entry.tags.join(' ') : '').toLowerCase()
+        return entry.title.toLowerCase().indexOf(keyword) !== -1
           || entry.content.toLowerCase().indexOf(keyword) !== -1
-          || entry.when.toLowerCase().indexOf(keyword) !== -1)
+          || entry.when.toLowerCase().indexOf(keyword) !== -1
+          || inTags.indexOf(keyword) !== -1
+      })
 
       const dotClass = injection.error
         ? 'im-dot im-dot-err'
@@ -902,6 +1258,112 @@ window.__ModuleLoader__.load({
             h('label', { className: 'im-label' }, t('rules.label')),
             h('div', { className: 'im-meta' },
               t('rules.note')))),
+        (data.enabled === true && activeCount > 0)
+          ? h('div', { key: 'meter' },
+            h('div', { className: 'im-meter' },
+              h('div', {
+                className: 'im-meter-fill' + (meter.omitted > 0 ? ' im-meter-fill-warn' : ''),
+                style: { width: meter.percent + '%' },
+              })),
+            h('div', { className: 'im-meta im-meter-line' },
+              t('budget.used', { used: meter.used, budget: meter.budget, tokens: meter.tokens })),
+            meter.omitted > 0
+              ? h('div', { className: 'im-warn im-meter-line' }, t('budget.omitted', { count: meter.omitted }))
+              : null)
+          : null,
+        // F3 bulk action bar, only while in multi-select mode. "Select all"
+        // covers the currently visible (filtered/searched) entries.
+        (batchMode && entries.length > 0)
+          ? h('div', { key: 'batchbar', className: 'im-batch-bar' },
+            h('label', { className: 'im-switch' },
+              h('input', {
+                type: 'checkbox',
+                className: 'im-batch-check',
+                checked: visible.length > 0 && visible.every((entry) => selected.includes(entry.id)),
+                disabled: busy,
+                onChange: (ev) => {
+                  const visibleIds = visible.map((entry) => entry.id)
+                  if (ev.target.checked) {
+                    setSelected([...new Set([...selected, ...visibleIds])])
+                  } else {
+                    setSelected(selected.filter((id) => !visibleIds.includes(id)))
+                  }
+                },
+              }),
+              t('batch.selectAll')),
+            h('span', { className: 'im-meta' }, t('batch.selected', { count: liveSelected().length })),
+            h('button', { className: 'im-btn', disabled: busy, onClick: () => doBatch('set-enabled', true) }, t('batch.enable')),
+            h('button', { className: 'im-btn', disabled: busy, onClick: () => doBatch('set-enabled', false) }, t('batch.disable')),
+            h('select', {
+              className: 'im-select im-select-sm',
+              defaultValue: '',
+              disabled: busy,
+              onChange: (ev) => {
+                const v = Number(ev.target.value)
+                if (v === 0 || v === 1 || v === 2) void doBatch('set-priority', v)
+                ev.target.value = ''
+              },
+            },
+              h('option', { value: '' }, t('batch.priority')),
+              h('option', { value: '2' }, t('priority.high')),
+              h('option', { value: '1' }, t('priority.normal')),
+              h('option', { value: '0' }, t('priority.low'))),
+            h('button', { className: 'im-btn', disabled: busy, onClick: batchAddTags }, t('batch.addTags')),
+            h('span', { className: 'im-spacer' }),
+            h('button', {
+              className: 'im-btn im-btn-danger',
+              disabled: busy,
+              onClick: () => doBatch('delete', undefined),
+            }, t('batch.delete')),
+            h('button', { className: 'im-btn', disabled: busy, onClick: exitBatch }, t('batch.exit')))
+          : null,
+        // F2 filters: tag chips (only when tags exist) plus mode/status/sort.
+        entries.length > 0
+          ? h('div', { key: 'filters', className: 'im-filter-row' },
+            allTags.length > 0
+              ? h('div', { className: 'im-filter-chips' },
+                h('button', {
+                  type: 'button',
+                  className: 'im-filter-chip' + (tagFilter === '' ? ' im-filter-chip-on' : ''),
+                  onClick: () => setTagFilter(''),
+                }, t('filter.all')),
+                allTags.map((tag) => h('button', {
+                  type: 'button',
+                  key: tag,
+                  className: 'im-filter-chip' + (tagFilter === tag ? ' im-filter-chip-on' : ''),
+                  title: t('filter.tag'),
+                  onClick: () => setTagFilter(tagFilter === tag ? '' : tag),
+                }, tag)))
+              : null,
+            h('div', { className: 'im-filter-selects' },
+              h('label', { className: 'im-fselect' }, t('filter.mode'),
+                h('select', {
+                  className: 'im-select im-select-sm',
+                  value: modeFilter,
+                  onChange: (ev) => setModeFilter(ev.target.value),
+                },
+                  h('option', { value: '' }, t('filter.all')),
+                  h('option', { value: 'always' }, t('filter.modeAlways')),
+                  h('option', { value: 'auto' }, t('filter.modeAuto')))),
+              h('label', { className: 'im-fselect' }, t('filter.status'),
+                h('select', {
+                  className: 'im-select im-select-sm',
+                  value: statusFilter,
+                  onChange: (ev) => setStatusFilter(ev.target.value),
+                },
+                  h('option', { value: '' }, t('filter.all')),
+                  h('option', { value: 'enabled' }, t('filter.statusEnabled')),
+                  h('option', { value: 'disabled' }, t('filter.statusDisabled')))),
+              h('label', { className: 'im-fselect' }, t('sort.label'),
+                h('select', {
+                  className: 'im-select im-select-sm',
+                  value: sortKey,
+                  onChange: (ev) => setSortKey(ev.target.value),
+                },
+                  h('option', { value: 'priority' }, t('sort.priority')),
+                  h('option', { value: 'updated' }, t('sort.updated')),
+                  h('option', { value: 'title' }, t('sort.title'))))))
+          : null,
         entries.length > 0 ? h('div', { key: 'search' },
           h('input', {
             className: 'im-input',
@@ -909,7 +1371,9 @@ window.__ModuleLoader__.load({
             placeholder: t('search.placeholder', { count: entries.length }),
             onChange: (ev) => setQuery(ev.target.value),
           }),
-          query.trim() !== '' ? h('div', { className: 'im-meta im-search-meta' }, t('search.matchCount', { shown: visible.length, total: entries.length })) : null) : null,
+          (query.trim() !== '' || filtersActive)
+            ? h('div', { className: 'im-meta im-search-meta' }, t('search.matchCount', { shown: visible.length, total: entries.length }))
+            : null) : null,
         h('div', { className: 'im-row-wrap' },
           h('button', {
             className: 'im-btn im-btn-primary',
@@ -931,6 +1395,11 @@ window.__ModuleLoader__.load({
             disabled: busy,
             onClick: () => setShowPreview(!showPreview),
           }, showPreview ? t('action.hidePreview') : t('action.showPreview')),
+          h('button', {
+            className: 'im-btn',
+            disabled: busy || entries.length === 0,
+            onClick: () => { setBatchMode(!batchMode); setSelected([]) },
+          }, batchMode ? t('batch.exit') : t('action.batch')),
           h('span', { className: 'im-spacer' }),
           h('span', { className: 'im-meta' }, t('stats.count', { total: entries.length, active: activeCount }))),
         h('div', { className: 'im-divider' }),
@@ -987,51 +1456,81 @@ window.__ModuleLoader__.load({
         ]
         if (entry.priority === 2) tags.push(h('span', { className: 'im-tag im-tag-high', key: 'p' }, t('priority.high')))
         else if (entry.priority === 0) tags.push(h('span', { className: 'im-tag', key: 'p' }, t('priority.low')))
+        // Budget marks from the Host's injection plan. Only active entries can
+        // appear in the plans, so a disabled entry never gets a stale mark.
+        if (omittedById.has(entry.id)) {
+          tags.push(h('span', {
+            className: 'im-tag im-tag-off', key: 'off', title: t('tag.omittedTitle'),
+          }, t('tag.omitted')))
+        } else if (truncatedById.has(entry.id)) {
+          tags.push(h('span', {
+            className: 'im-tag im-tag-cut', key: 'cut', title: t('tag.truncatedTitle'),
+          }, t('tag.truncated')))
+        }
         return h('div', {
           className: 'im-item' + (entry.enabled ? '' : ' im-item-off'),
           key: entry.id,
         },
           h('div', { className: 'im-item-head' },
+            batchMode
+              ? h('input', {
+                type: 'checkbox',
+                className: 'im-batch-check',
+                checked: selected.includes(entry.id),
+                disabled: busy,
+                onChange: () => toggleSelected(entry.id),
+              })
+              : null,
             h('span', { className: 'im-title' }, entry.title),
             tags,
             h('span', { className: 'im-spacer' }),
-            h('label', { className: 'im-switch' },
-              h('input', {
-                type: 'checkbox',
-                checked: entry.enabled === true,
+            batchMode
+              ? null
+              : h('label', { className: 'im-switch' },
+                h('input', {
+                  type: 'checkbox',
+                  checked: entry.enabled === true,
+                  disabled: busy,
+                  onChange: () => {
+                    const next = cloneEntry(entry)
+                    next.enabled = !entry.enabled
+                    send('save-entry', { entry: next, baseRev: revOf() })
+                  },
+                }),
+                t('entry.enabled')),
+            batchMode
+              ? null
+              : h('button', {
+                className: 'im-btn',
+                disabled: busy,
+                onClick: () => { setDraft(cloneEntry(entry)); setError('') },
+              }, t('entry.edit')),
+            batchMode
+              ? null
+              : h('button', {
+                className: 'im-btn im-btn-danger',
                 disabled: busy,
-                onChange: () => {
-                  const next = cloneEntry(entry)
-                  next.enabled = !entry.enabled
-                  send('save-entry', { entry: next, baseRev: revOf() })
+                onClick: () => {
+                  // confirm() is standard DOM, guarded anyway: if the embedded
+                  // shell omits it, deletion proceeds rather than breaking.
+                  if (typeof window.confirm === 'function'
+                    && !window.confirm(t('entry.confirmDelete', {
+                      title: entry.title !== '' ? entry.title : t('entry.untitled'),
+                    }))) return
+                  // Keep the full entry for the undo bar; the POST response
+                  // (not this closure) is what confirms the deletion happened.
+                  setUndo(null)
+                  send('delete-entry', { id: entry.id, baseRev: revOf() }).then((result) => {
+                    if (result === null || result.ok !== true) return
+                    setUndo({ entry, expires: Date.now() + UNDO_TTL_MS })
+                  })
                 },
-              }),
-              t('entry.enabled')),
-            h('button', {
-              className: 'im-btn',
-              disabled: busy,
-              onClick: () => { setDraft(cloneEntry(entry)); setError('') },
-            }, t('entry.edit')),
-            h('button', {
-              className: 'im-btn im-btn-danger',
-              disabled: busy,
-              onClick: () => {
-                // confirm() is standard DOM, guarded anyway: if the embedded
-                // shell omits it, deletion proceeds rather than breaking.
-                if (typeof window.confirm === 'function'
-                  && !window.confirm(t('entry.confirmDelete', {
-                    title: entry.title !== '' ? entry.title : t('entry.untitled'),
-                  }))) return
-                // Keep the full entry for the undo bar; the POST response
-                // (not this closure) is what confirms the deletion happened.
-                setUndo(null)
-                send('delete-entry', { id: entry.id, baseRev: revOf() }).then((result) => {
-                  if (result === null || result.ok !== true) return
-                  setUndo({ entry, expires: Date.now() + UNDO_TTL_MS })
-                })
-              },
-            }, t('entry.delete'))),
+              }, t('entry.delete'))),
           h(EntryBody, { text: entry.content, key: 'body' }),
+          Array.isArray(entry.tags) && entry.tags.length > 0
+            ? h('div', { className: 'im-entry-tags' },
+              entry.tags.map((tag) => h('span', { className: 'im-chip', key: tag }, tag)))
+            : null,
           entry.mode === 'auto' && entry.when !== ''
             ? h('div', { className: 'im-meta' }, t('entry.when', { when: entry.when }))
             : null,
@@ -1047,7 +1546,10 @@ window.__ModuleLoader__.load({
         ? h('div', { className: 'im-empty', key: 'empty' },
           t('list.empty'))
         : visible.length === 0
-          ? h('div', { className: 'im-empty', key: 'no-match' }, t('list.noMatch', { query: query.trim() }))
+          ? h('div', { className: 'im-empty', key: 'no-match' },
+            keyword === ''
+              ? t('list.filteredEmpty')
+              : t('list.noMatch', { query: query.trim() }))
           : h('div', { className: 'im-list', key: 'list' }, items)
 
       return h('div', { className: 'im-root' }, header, list)
@@ -1136,6 +1638,8 @@ window.__ModuleLoader__.load({
     exports.__confirmDiscard = confirmDiscard
     exports.__importSizeVerdict = importSizeVerdict
     exports.__nextBudgetText = nextBudgetText
+    exports.__budgetMeter = budgetMeter
+    exports.__parseTagInput = parseTagInput
     exports.__strings = STRINGS
     exports.__ns = NS
     exports.__dictionaryT = dictionaryT

package/lib/index.js

@@ -92,6 +92,15 @@ const MAX_ENTRIES = 200
 const MAX_TITLE = 120
 const MAX_CONTENT = 6000
 const MAX_WHEN = 200
+/** Tags are short grouping labels for the settings page only; they never enter the injected block. */
+const MAX_TAGS_PER_ENTRY = 8
+const MAX_TAG_LENGTH = 24
+
+/**
+ * The batch operations the `batch` route accepts. Kept here so the command and
+ * the route's dispatch share one list.
+ */
+const BATCH_OPS = ['set-enabled', 'set-priority', 'add-tags', 'remove-tags', 'delete']
 
 /**
  * Request body ceiling for the settings-page route; anything larger is refused
@@ -106,7 +115,7 @@ const MAX_WHEN = 200
  * the flat slack covers the `{method,args:{payload:{app,…,data:{entries:[…]}}}}`
  * wrapper.
  */
-export const MAX_BODY_CHARS = MAX_ENTRIES * (MAX_CONTENT + MAX_TITLE + MAX_WHEN + 200) * 2 + 100_000
+export const MAX_BODY_CHARS = MAX_ENTRIES * (MAX_CONTENT + MAX_TITLE + MAX_WHEN + MAX_TAGS_PER_ENTRY * MAX_TAG_LENGTH + 200) * 2 + 100_000
 
 /** How long a crashed holder's `memory.json.lock` may block writes before it is stolen. */
 const LOCK_STALE_MS = 10_000
@@ -158,6 +167,34 @@ function priorityLabel(value) {
   return '普通'
 }
 
+/**
+ * Normalise an entry's `tags`: a de-duplicated, single-line, capped string
+ * array used ONLY by the settings page for grouping/filtering. Tags never
+ * appear in the injected block, so they do not touch buildBlock. Exported for
+ * tests and reused by the batch "add-tags" path so both merge through one
+ * rule. Non-array input (an old/hand-made entry without tags) is simply no
+ * tags, not an error; non-string/blank items are dropped; anything past
+ * MAX_TAGS_PER_ENTRY is ignored after de-duplication.
+ */
+export function sanitizeTags(raw) {
+  if (!Array.isArray(raw)) return []
+  const out = []
+  const seen = new Set()
+  for (const item of raw) {
+    if (typeof item !== 'string') continue
+    // Collapse ALL whitespace runs (newlines and repeated spaces) so the same
+    // typed label normalises identically whether it came from the editor's
+    // tag box, an import, or a hand edit — otherwise "a b" and "a  b" would
+    // both survive and fail to de-duplicate.
+    const tag = singleLine(item, MAX_TAG_LENGTH).replace(/\s+/g, ' ').trim()
+    if (tag === '' || seen.has(tag)) continue
+    seen.add(tag)
+    if (out.length >= MAX_TAGS_PER_ENTRY) break
+    out.push(tag)
+  }
+  return out
+}
+
 export function sanitizeEntry(raw) {
   if (raw === null || typeof raw !== 'object') return null
   const title = singleLine(raw.title, MAX_TITLE)
@@ -171,6 +208,7 @@ export function sanitizeEntry(raw) {
     when: singleLine(raw.when, MAX_WHEN),
     priority: raw.priority === 2 || raw.priority === 0 ? raw.priority : 1,
     enabled: raw.enabled !== false,
+    tags: sanitizeTags(raw.tags),
     updatedAt: typeof raw.updatedAt === 'number' && Number.isFinite(raw.updatedAt) ? raw.updatedAt : Date.now(),
   }
 }
@@ -518,19 +556,41 @@ function formatEntry(entry, tag) {
 }
 
 /**
- * Render the injected block. Deliberately deterministic: identical memory
- * produces byte-identical text on every step, so the prompt prefix stays
- * cacheable across a session.
+ * Build the injection plan: the exact text assembled into the system prompt
+ * PLUS the per-entry decisions behind it, so the settings page can show how
+ * much of the character budget is in use and flag the enabled entries the
+ * current budget leaves out.
+ *
+ * Deliberately deterministic: identical memory produces a byte-identical
+ * plan on every step, so the prompt prefix stays cacheable across a session.
+ *
+ * Returned shape:
+ *   {
+ *     text:        string  — exactly what buildBlock() returns
+ *     budget:      number  — the clamped budgetChars in effect
+ *     activeCount: number  — enabled, non-blank candidates considered
+ *     included:    [{ id, chars, truncated }] — entries that reach the prompt,
+ *                    in consideration order (始终 first, then 按需; within
+ *                    each, priority desc then updatedAt desc); chars is the
+ *                    rendered length of that entry's block (its cut length
+ *                    when truncated)
+ *     omitted:     [{ id, chars }] — active entries the budget could not fit;
+ *                    chars is the full rendered block length they would need
+ *   }
+ *
+ * Disabled or blank entries are candidates for neither list: they are not
+ * competing for the budget at all. When nothing renders, `text` is '' and
+ * `included` is [] even though `budget` still reports the effective ceiling.
  */
-export function buildBlock(data) {
-  if (data === null || typeof data !== 'object' || data.enabled !== true) return ''
+export function planInjection(data) {
+  const budget = clampBudget(data !== null && typeof data === 'object' ? data.budgetChars : undefined)
+  const blank = () => ({ text: '', budget, activeCount: 0, included: [], omitted: [] })
+  if (data === null || typeof data !== 'object' || data.enabled !== true) return blank()
   const active = (Array.isArray(data.entries) ? data.entries : [])
     .filter((entry) => entry.enabled === true && entry.content !== '')
-  if (active.length === 0) return ''
+  if (active.length === 0) return blank()
   active.sort((a, b) => (b.priority - a.priority) || (b.updatedAt - a.updatedAt))
 
-  const budget = clampBudget(data.budgetChars)
-
   // Richest preamble that still leaves room for one real entry plus the
   // worst-case omission footer. A tight budget degrades the preamble instead of
   // silently injecting nothing.
@@ -565,6 +625,8 @@ export function buildBlock(data) {
   }
 
   const blocks = []
+  const included = []
+  const omittedPlan = []
   let used = header.length
   let omitted = 0
 
@@ -576,6 +638,7 @@ export function buildBlock(data) {
     if (used + block.length + 2 + reserve <= budget) {
       used += block.length + 2
       blocks.push(block)
+      included.push({ id: entry.id, chars: block.length, truncated: false })
       return
     }
     // The first entry always gets in, truncated if the budget demands it: a
@@ -593,17 +656,36 @@ export function buildBlock(data) {
         const body = head + note
         blocks.push(body)
         used += body.length + 2
+        included.push({ id: entry.id, chars: body.length, truncated: true })
         return
       }
     }
     omitted += 1
+    omittedPlan.push({ id: entry.id, chars: block.length })
   }
 
   for (const entry of active) if (entry.mode === 'always') consider(entry, '始终')
   for (const entry of active) if (entry.mode !== 'always') consider(entry, '按需')
 
-  if (blocks.length === 0) return ''
-  return header + blocks.join('\n\n') + footerFor(omitted)
+  if (blocks.length === 0) {
+    return { text: '', budget, activeCount: active.length, included: [], omitted: omittedPlan }
+  }
+  return {
+    text: header + blocks.join('\n\n') + footerFor(omitted),
+    budget,
+    activeCount: active.length,
+    included,
+    omitted: omittedPlan,
+  }
+}
+
+/**
+ * Render the injected block text. A thin wrapper over planInjection: the
+ * decision process lives in one place, and callers that only need the text
+ * (the prompt section) keep this byte-stable entry point.
+ */
+export function buildBlock(data) {
+  return planInjection(data).text
 }
 
 /* ------------------------------------------------------------------ *
@@ -725,6 +807,22 @@ export function apply(ctx) {
     }
   }
 
+  /**
+   * The full injection plan (text + per-entry budget decisions) behind the
+   * registered section. The snapshot publishes it so the settings page can
+   * show budget usage and mark the enabled entries that currently do not fit.
+   * A render failure degrades to an empty plan at the effective ceiling
+   * rather than throwing into the route/SSE path.
+   */
+  const sectionPlan = () => {
+    try {
+      return planInjection(state.data)
+    } catch (err) {
+      console.error('[instruction-memory] render failed:', err)
+      return { text: '', budget: clampBudget(state.data.budgetChars), activeCount: 0, included: [], omitted: [] }
+    }
+  }
+
   /**
    * The thunk handed to the harness.
    *
@@ -1287,7 +1385,8 @@ export function apply(ctx) {
   /* ---------------- snapshots ---------------- */
 
   const snapshot = () => {
-    const preview = sectionText()
+    const plan = sectionPlan()
+    const preview = plan.text
     return {
       data: {
         version: 1,
@@ -1310,6 +1409,16 @@ export function apply(ctx) {
         available: true,
         error: state.sectionError,
         chars: preview.length,
+        /**
+         * The budget decision behind `preview`, for the settings page's
+         * usage meter and per-entry marks. `budget` is the effective ceiling;
+         * `included`/`omitted` carry one item per active entry in
+         * consideration order; disabled or blank entries appear in neither.
+         */
+        budget: plan.budget,
+        activeCount: plan.activeCount,
+        included: plan.included.map((item) => ({ id: item.id, chars: item.chars, truncated: item.truncated === true })),
+        omitted: plan.omitted.map((item) => ({ id: item.id, chars: item.chars })),
         /**
          * How many times the harness has pulled this section into a prompt since
          * boot. 0 means "prepared, never assembled" — the distinction the old
@@ -1468,6 +1577,126 @@ export function apply(ctx) {
     return settle(null, saved)
   })
 
+  /**
+   * Apply ONE operation to many entries in a single transaction.
+   *
+   * The settings page's multi-select must not loop save-entry/delete-entry:
+   * that would bump `rev`, write the file and broadcast an SSE frame once per
+   * id. Instead the whole batch is planned first (only entries that actually
+   * change are touched — an all-no-op batch, like deleting ids that are not
+   * there, writes nothing and keeps `rev` still), then committed through the
+   * same commit()/writeToDisk() path as every other mutation, so the lock, rev
+   * guard, rollback-on-failed-write and broadcast all apply once.
+   *
+   * `value` semantics per op: set-enabled -> boolean; set-priority -> 0|1|2;
+   * add-tags/remove-tags -> string[] (run through sanitizeTags); delete ->
+   * unused. Batch edits deliberately do NOT re-stamp updatedAt: enabling a
+   * group or tagging it must not reshuffle the within-priority injection
+   * order, which is tied to updatedAt.
+   */
+  const batchEntries = (op, ids, value, baseRev) => enqueue(async () => {
+    if (state.versionRejected) return versionRefusal()
+    if (isStaleBaseRev(baseRev)) return conflictResponse()
+    if (typeof op !== 'string' || !BATCH_OPS.includes(op)) {
+      return { ok: false, saved: false, message: '未知的批量操作：' + String(op), snapshot: snapshot() }
+    }
+    const uniqueIds = Array.isArray(ids)
+      ? [...new Set(ids.filter((id) => typeof id === 'string' && id !== ''))]
+      : []
+    if (uniqueIds.length === 0) {
+      return { ok: false, saved: false, message: '没有选择任何条目', snapshot: snapshot() }
+    }
+
+    const list = state.data.entries
+    const targets = list.filter((entry) => uniqueIds.includes(entry.id))
+    const missing = uniqueIds.length - targets.length
+    const missingNote = missing > 0
+      ? '（另有 ' + missing + ' 条未找到，可能已被其他窗口或进程修改）'
+      : ''
+
+    if (op === 'delete') {
+      // Deleting ids that are all absent changes nothing — mirror single
+      // deleteEntry's no-write behaviour rather than manufacturing a save.
+      if (targets.length === 0) {
+        return { ok: true, saved: false, message: null, snapshot: snapshot() }
+      }
+      const gone = new Set(targets.map((entry) => entry.id))
+      const affected = targets.length
+      const saved = await commit(() => {
+        state.data.entries = state.data.entries.filter((entry) => !gone.has(entry.id))
+      })
+      return settle('已删除 ' + affected + ' 条指令' + missingNote, saved)
+    }
+
+    // Pure planners: return the patch to apply, or null when this entry is
+    // already at the target state. Nothing is mutated here.
+    let planner
+    if (op === 'set-enabled') {
+      if (typeof value !== 'boolean') {
+        return { ok: false, saved: false, message: '批量启停需要一个布尔值', snapshot: snapshot() }
+      }
+      planner = (entry) => (entry.enabled === value ? null : { enabled: value })
+    } else if (op === 'set-priority') {
+      if (value !== 0 && value !== 1 && value !== 2) {
+        return { ok: false, saved: false, message: '批量优先级只能是 0、1 或 2', snapshot: snapshot() }
+      }
+      planner = (entry) => (entry.priority === value ? null : { priority: value })
+    } else if (op === 'add-tags') {
+      if (!Array.isArray(value)) {
+        return { ok: false, saved: false, message: '批量添加标签需要一个标签数组', snapshot: snapshot() }
+      }
+      const add = sanitizeTags(value)
+      if (add.length === 0) {
+        return { ok: false, saved: false, message: '没有可添加的有效标签（单个标签不超过 ' + MAX_TAG_LENGTH + ' 字符）', snapshot: snapshot() }
+      }
+      planner = (entry) => {
+        const cur = Array.isArray(entry.tags) ? entry.tags : []
+        const merged = sanitizeTags([...cur, ...add])
+        if (merged.length === cur.length && merged.every((tag) => cur.includes(tag))) return null
+        return { tags: merged }
+      }
+    } else {
+      // remove-tags
+      if (!Array.isArray(value)) {
+        return { ok: false, saved: false, message: '批量移除标签需要一个标签数组', snapshot: snapshot() }
+      }
+      const remove = new Set(sanitizeTags(value))
+      if (remove.size === 0) {
+        return { ok: false, saved: false, message: '没有可移除的有效标签', snapshot: snapshot() }
+      }
+      planner = (entry) => {
+        const cur = Array.isArray(entry.tags) ? entry.tags : []
+        const kept = cur.filter((tag) => !remove.has(tag))
+        return kept.length === cur.length ? null : { tags: kept }
+      }
+    }
+
+    const changes = []
+    for (const entry of targets) {
+      const patch = planner(entry)
+      if (patch !== null) changes.push({ entry, patch })
+    }
+    if (changes.length === 0) {
+      return { ok: true, saved: false, message: '所选条目均已是目标状态' + missingNote, snapshot: snapshot() }
+    }
+    const saved = await commit(() => {
+      for (const change of changes) Object.assign(change.entry, change.patch)
+    })
+    const done = {
+      'set-enabled': value ? '已启用 ' : '已停用 ',
+      'set-priority': '已将 ',
+      'add-tags': '已为 ',
+      'remove-tags': '已从 ',
+    }[op]
+    const tail = {
+      'set-enabled': changes.length + ' 条指令',
+      'set-priority': changes.length + ' 条指令的优先级设为「' + priorityLabel(value) + '」',
+      'add-tags': changes.length + ' 条指令添加标签',
+      'remove-tags': changes.length + ' 条指令移除标签',
+    }[op]
+    return settle(done + tail + missingNote, saved)
+  })
+
   const reload = () => enqueue(async () => {
     // `saved` is only true when the load itself wrote to disk (the
     // backup-promotion or legacy-migration branch); a plain re-read claiming
@@ -1590,6 +1819,12 @@ export function apply(ctx) {
         return importData(
           args !== null && typeof args === 'object' ? args.payload : null,
           args !== null && typeof args === 'object' ? args.baseRev : undefined)
+      case 'batch':
+        return batchEntries(
+          args !== null && typeof args === 'object' ? args.op : null,
+          args !== null && typeof args === 'object' ? args.ids : null,
+          args !== null && typeof args === 'object' ? args.value : undefined,
+          args !== null && typeof args === 'object' ? args.baseRev : undefined)
       default:
         return { ok: false, saved: false, message: '未知方法：' + String(method), snapshot: snapshot() }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-instruction-memory",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "User-only instruction memory for DSH: long-term instructions maintained in the settings UI and auto-injected into every conversation — the model has no write access. 指令记忆：只由用户在设置页维护的长期指令，自动注入此后每轮对话；模型没有任何写入口。",
   "license": "MIT",
   "type": "module",