dsh-baize-rules 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bvcvb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# dsh-baize-rules
+
+![npm version](https://img.shields.io/npm/v/dsh-baize-rules)
+![license](https://img.shields.io/npm/l/dsh-baize-rules)
+
+> English: *`dsh-baize-rules` (Baize) is a dsh plugin that injects user-set, durable "must-do / must-not" requirements — plain-text rules — into the model at conversation start as a sourced `user/message`.*
+
+[dsh](https://www.npmjs.com/package/@deepseek-ai/dsh) 的**会话 / 全局「必须做 / 不能做」要求**插件。名字取自**白泽**——传说中「通万物之情、晓万物之名、知万物之理」的神兽，用它来承载「用户给模型立下的行为基线」。
+
+- 规则是**纯文本**，没有 `must`/`mustNot` 标记——「必须做 / 不能做」由正文语言表达（例如 `用中文写注释。`=必须，`不要删除测试。`=禁止）。
+- 注入发生在**会话起点**：把当前生效规则作为一条**持久** `user/message` 注入模型请求，套用 `<system-reminder>` 框架，来源标记为 `source.kind='plugin'`、`plugin='baize-rules'`。
+- **无规则则不注入**；字节预算小到裁光所有规则时返回 `undefined`，绝不注入空壳 reminder。
+
+---
+
+## 功能特性
+
+| 特性 | 说明 |
+|---|---|
+| **三作用域** | `global`（所有会话）/ `session`（当前会话）/ `project`（按会话工作目录，**实验性**） |
+| **持久化** | 全部落盘到 `$DSH_HOME`（默认 `~/.dsh`），跨会话、跨重启 |
+| **具体优先** | 渲染顺序 `project > session > global`；字节预算受压时优先保留更具体的规则 |
+| **去重** | 按渲染文本 SHA-1 digest 抑制重复注入；`injectAtEveryStep` 可选每步强制刷新 |
+| **防逃逸** | 正文里的字面 `</system-reminder>` 会被转义，防止用户文本关闭插件框架 |
+| **命令 + API 同源** | `/baize-rules` 命令与前端面板共用同一套 store/core，改动始终同一真值 |
+
+---
+
+## 安装
+
+> dsh 插件从 npm 仓库分发，通过 `dsh plugin` 安装到某个 profile。
+
+```bash
+# 从 npm 安装到 web profile（版本以发布后的实际版本为准）
+dsh plugin --profile web add dsh-baize-rules@0.1.0
+pm2 restart dsh          # dsh 由 pm2 托管时重载生效
+dsh --profile web
+```
+
+安装时依赖的 peer 包（`@deepseek-ai/` 系列、`react` 等）由 dsh profile 提供；若缺少，pnpm 会在 profile 目录里按 `peerDependencies` 解析。
+
+### 本地开发联调（link）
+
+尚未发布或想改源码即时生效时，用本目录作为 link 依赖：
+
+```jsonc
+// /home/abc/.dsh/profiles/web/package.json
+"dependencies": {
+  "dsh-baize-rules": "link:/home/abc/work/plugin/dsh-baize-rules"
+}
+```
+
+随后在 profile 目录执行 `pnpm install`，并把 `dsh-baize-rules` 加进 `dsh.profile.bundles`。
+
+---
+
+## 快速开始
+
+```bash
+/baize-rules                                   # 等价于 /baize-rules list，查看当前生效规则
+/baize-rules add 用中文写注释。                 # 加到默认作用域（通常是 session）
+/baize-rules global add 不要删除或改写现有测试。 # 明确加到 global
+/baize-rules list                              # 显示 global + session（含缩略 id / disabled 标注）
+/baize-rules edit <id> 只用 pnpm 构建。          # 修改某条规则文本
+/baize-rules disable <id>                      # 停用某条（保留不删）
+/baize-rules enable <id>                       # 重新启用
+/baize-rules scope global                      # 之后命令默认写到 global
+/baize-rules clear session                     # 清空当前会话规则
+/baize-rules export                            # 导出全部规则为 JSON
+```
+
+---
+
+## 命令
+
+所有子命令挂在 **`/baize-rules`** 下；无参数时等价于 `list`。
+
+```
+/baize-rules [list|add <text>|remove <id>|edit <id> <text>|enable|disable <id>|scope <global|session|project>|clear <scope>|export]
+```
+
+| 子命令 | 语法 | 作用 |
+|---|---|---|
+| **list** | `/baize-rules list` | 列出合并后的生效规则（`Project`/`Global`/`Session` 节；空时显示 `No active rules.`） |
+| **add** | `/baize-rules add <text>` | 追加一条规则到目标作用域（默认 `scope`）；文本即规则 |
+| **remove** | `/baize-rules remove <id>` | 按**完整 id** 删除一条规则 |
+| **edit** | `/baize-rules edit <id> <text>` | 修改某条规则的文本 |
+| **enable** | `/baize-rules enable <id>` | 启用一条被停用的规则 |
+| **disable** | `/baize-rules disable <id>` | 停用一条规则（保留但不生效） |
+| **scope** | `/baize-rules scope <global\|session\|project>` | 切换后续命令的默认作用域（持久到当前进程） |
+| **clear** | `/baize-rules clear <global\|session\|project>` | 清空某作用域的全部规则 |
+| **export** | `/baize-rules export` | 以 JSON 导出 `{ global, session }` |
+
+**参数细节**
+
+- `<text>`：规则正文，可含空格；是「必须做」还是「不能做」由正文语言表达，无标记。
+- `<id>`：规则的稳定 id（`crypto.randomUUID`）。`list` 显示**前 8 位缩略 id** 便于阅读；
+  执行 `remove`/`edit`/`enable`/`disable` 时请提供**完整 id**（可用 `list` 或 `export` 查看完整 id）。
+
+### 作用域写法
+
+`add/remove/edit/enable/disable` 支持**显式作用域**，两种等价写法：
+
+- **前缀**：`/baize-rules global add 用中文。`
+- **后缀**：`/baize-rules add 用中文。 global`（仅当作用域是**最后一个 token** 时）
+
+> 只有 `add/remove/edit/enable/disable` 会把**末尾**的作用域关键字识别为作用域修饰；
+> `scope`/`clear` 的参数本身就是作用域，不会被吞。因此正文里含 `global`/`session` 不会被误判
+>（例如 `/baize-rules add 用global写`）。
+
+未指定作用域时，用 `/baize-rules scope` 设定的默认值（初始来自配置文件 `Config.scope`，通常 `session`）。
+
+---
+
+## 注入行为（模型上下文如何被改变）
+
+- **会话起点基线**：会话开始时，`agent/pre-step`（`prepend:true`）把生效规则作为一条 `user/message` 插入请求，内容为 `<system-reminder>` 框架，`source.kind='plugin'`、`plugin='baize-rules'`、`form='snapshot'`。
+- **具体优先**：`project > session > global`；预算受限时优先裁剪较宽泛的 `global` 规则。
+- **去重**：对渲染文本算 SHA-1 digest，规则不变则不重复注入；`injectAtEveryStep:true` 时每步强制刷新。
+- **转义**：正文里的 `</system-reminder>` 会被 `escapeReminder` 转义。
+- **空 / 全裁**：无规则、或预算裁光所有规则时返回 `undefined`（即不注入该消息）。
+
+### 模型实际看到的形态
+
+```markdown
+<system-reminder>
+The following user requirements apply to every step of this conversation. Obey them.
+More specific instructions take precedence over broader ones. They do not override system, developer, or direct user instructions.
+
+Session requirements (this conversation only):
+- 插件每次都要隔离测试后才能部署。
+
+Global requirements:
+- 用中文写注释。
+- 不要删除或改写现有的测试。
+</system-reminder>
+```
+
+---
+
+## 配置（`Config`）
+
+插件启动时用 `@deepseek-ai/schemastery` 校验 `Config`；非法值会令插件加载失败。
+
+| 配置 | 默认 | 说明 |
+|---|---|---|
+| `scope` | —（必填） | 默认作用域，`/baize-rules` 未指定时使用；仅允许 `global`/`session` |
+| `maxBytes` | —（必填） | 模型可见字节上限；超出时按「具体优先」裁剪 |
+| `globalRulesPath` | `$DSH_HOME/rules/global.json` | 覆盖全局规则文件路径 |
+| `injectAtEveryStep` | `false` | 每步强制重渲（调试用）；默认为仅变化时打补丁 |
+
+### 挂载元数据（`cordis.patch.yml`）
+
+发布的 npm 包里携带 `dsh.bundle.patch`，安装 `dsh-baize-rules@<version>` 时由 dsh 自动接入：
+`cordis.patch.yml` 中 `insert` 一行插件，默认 `scope: session`、`maxBytes: 8192`。如需调整默认作用域 / 预算，改这里即可。
+
+---
+
+## 数据落点
+
+| 作用域 | 存储位置 | 何时写 | 持久性 |
+|---|---|---|---|
+| global | `$DSH_HOME/rules/global.json` | 任一命令 / API 提交时 | ✅ 跨重启 |
+| session | `$DSH_HOME/rules/sessions/<sessionId>.json` | 同上 | ✅ 跨重启 |
+| project | `$DSH_HOME/rules/projects/<slug>.json`（slug 来自会话 cwd） | 同上 | ✅ 跨重启 |
+
+> `$DSH_HOME` 由 `@deepseek-ai/dsh-home-paths` 解析，默认 `~/.dsh`。
+> 读写走 `ctx.fs`（`resolve/stat/readText/writeText`，写时自动建目录）；缺失容忍、损坏文件 failing-loud。
+> **注意**：`project` 规则可通过命令管理并落盘，但**当前 pre-step 注入视图只包含 `global` + `session`**，故 `project` 规则暂未进入模型上下文（预留/实验性）。
+
+---
+
+## 客户端面板（可选）
+
+发布包还暴露一个 dsh web 客户端面板（`lib/client.js`，见 `package.json` 的 `exports` 里的 `./client`），通过宿主 HTTP API `/baize-rules.api` 与命令共用同一套 store/core：
+
+- `GET /baize-rules.api?sessionId=…&project=…` → `{ global, session, project }`
+- `POST /baize-rules.api`，body `{ sessionId, raw, scope }` → `{ ok, text, view }`
+
+---
+
+## 模块结构
+
+```
+src/rules.ts      纯逻辑：Rule 模型 + 渲染/<system-reminder>/字节预算(具体优先)/digest/escapeReminder
+src/core.ts       纯逻辑：parseCommand/runCommand/作用域解析/CRUD（零依赖，可脱离 dsh 单测）
+src/store.ts      纯逻辑：global/session/project 规则文件持久化（ctx.fs + dshHomePath）
+src/command.ts    薄 dsh 适配：喂 view/defaultScope → core，持久化 nextView/defaultScope
+src/index.ts      apply：agent/pre-step 注入 + /baize-rules 命令注册 + API 挂载（inject: agents/commands/fs/webServer/sessions）
+src/api.ts        Host HTTP API：GET/POST /baize-rules.api（供前端面板）
+src/invariant.ts  dsh-invariants 契约 companion（name/inject/apply）
+scripts/dev-render.ts  Loop 0 演示
+test/*.spec.ts    rules/core/composition 测试
+cordis.patch.yml  挂载元数据（insert baize-rules 插件行 + 默认配置）
+```
+
+**公共入口**（见 `package.json` 的 `exports`）：`.`（index）、`./invariant`、`./client`、`./src/*`。
+
+---
+
+## 开发与即时反馈
+
+```bash
+pnpm dev:render            # 打印模型实际会看到的 <system-reminder> 文案（支持预算参数）
+pnpm test                  # 跑单元 + REAL-composition 测试
+pnpm test:watch            # 保存即重跑
+pnpm build                 # tsc -p tsconfig.build.json → lib/
+pnpm typecheck             # npx tsc --noEmit
+```
+
+改 `src/rules.ts`（渲染）或 `src/core.ts`（命令决策）里的纯函数，重跑 `pnpm dev:render` 即可看到变化——**最快的反馈回路**（亚秒级，不碰 dsh）。
+
+---
+
+## 发布
+
+```bash
+pnpm build && pnpm test      # 发布前确认构建与测试通过
+npm publish --access public  # package.json 已含 publishConfig.access=public
+```
+
+> 发布后建议补上 `repository` 字段指向公开 git 仓库，供社区查阅与反馈。
+
+---
+
+## 许可证
+
+[MIT](./LICENSE)

package/cordis.patch.yml

@@ -0,0 +1,17 @@
+# dsh-baize-rules bundle patch
+#
+# This file is the `dsh.bundle.patch` layer of the published npm package. When
+# installed via `dsh plugin --profile <name> add dsh-baize-rules@<version>`, the
+# command reconciles `dsh.profile.bundles` against installed packages and mounts
+# this patch (a single `insert` of the plugin row) — exactly like the manual
+# cordis.patch.yml mount line. The plugin's own `name='baize-rules'` is used for
+# the injected `user/message` source attribution.
+#
+# To tune default scope / budget, add a `config` to the inserted row
+# (mirrors the plugin `Config` schema).
+- insert:
+    - id: baize-rules
+      name: 'dsh-baize-rules'
+      config:
+        scope: session
+        maxBytes: 8192

package/lib/api.js

@@ -0,0 +1,108 @@
+/**
+ * Host HTTP API for the rules panel. The client (`lib/client.js`) fetches rules
+ * via GET and applies mutations via POST, reusing the same store + core as the
+ * `/baize-rules` command (so the panel and command are the same source of truth).
+ *
+ * Routes (json):
+ *   GET  /baize-rules.api?sessionId=...  -> { global, session }
+ *   POST /baize-rules.api { sessionId, raw, scope } -> { ok, text, view }
+ *
+ * @module dsh-baize-rules/api
+ */
+import { runCommand } from "./core.js";
+import { view, writeGlobal, writeSession, writeProject, readProject } from "./store.js";
+function sendJson(res, status, payload) {
+    const r = res;
+    r.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+    r.end(JSON.stringify(payload));
+}
+function readBody(req) {
+    return new Promise((resolve) => {
+        const r = req;
+        let body = '';
+        r.on('data', (chunk) => { body += chunk; });
+        r.on('end', () => resolve(body));
+        r.on('error', () => resolve(''));
+    });
+}
+function parseBody(text) {
+    try {
+        return JSON.parse(text || '{}');
+    }
+    catch {
+        return {};
+    }
+}
+/** Register the rules panel API on the host web server. */
+export function registerRulesApi(ctx, options = {}) {
+    if (ctx.webServer === undefined)
+        return () => { };
+    return ctx.webServer.register({
+        kind: 'exact',
+        path: '/baize-rules.api',
+        handler: async (req, res) => {
+            const method = req.method ?? '';
+            const url = req.url ?? '';
+            const query = new URLSearchParams(url.split('?')[1] ?? '');
+            const sessionId = query.get('sessionId') ?? '';
+            const project = await resolveProject(ctx, sessionId, query.get('project') ?? '');
+            if (method === 'GET') {
+                try {
+                    sendJson(res, 200, await viewFor(ctx, sessionId, project, options));
+                }
+                catch (e) {
+                    sendJson(res, 500, { error: String(e) });
+                }
+                return;
+            }
+            if (method === 'POST') {
+                const body = parseBody(await readBody(req));
+                const pSessionId = String(body.sessionId ?? '');
+                const pProject = await resolveProject(ctx, pSessionId, String(body.project ?? ''));
+                const raw = String(body.raw ?? '');
+                const defaultScope = (body.scope ?? 'session');
+                if (!raw.trim()) {
+                    sendJson(res, 400, { error: 'empty raw' });
+                    return;
+                }
+                try {
+                    const v = await viewFor(ctx, pSessionId, pProject, options);
+                    const out = runCommand({ raw, view: v, defaultScope });
+                    if (out.nextView !== undefined) {
+                        await writeGlobal(ctx, options, out.nextView.global);
+                        if (pSessionId)
+                            await writeSession(ctx, pSessionId, out.nextView.session);
+                        if (pProject)
+                            await writeProject(ctx, pProject, out.nextView.project ?? []);
+                    }
+                    sendJson(res, out.ok ? 200 : 400, { ok: out.ok, text: out.text, view: out.nextView ?? v });
+                }
+                catch (e) {
+                    sendJson(res, 500, { error: String(e) });
+                }
+                return;
+            }
+            sendJson(res, 405, { error: 'method not allowed' });
+        },
+    });
+}
+/** Resolve the project key (cwd) from an explicit `project`, else the session's header cwd. */
+async function resolveProject(ctx, sessionId, project) {
+    if (project)
+        return project;
+    if (!sessionId)
+        return '';
+    try {
+        const sess = ctx.sessions?.get?.(sessionId);
+        return (sess && sess.header?.cwd) || '';
+    }
+    catch {
+        return '';
+    }
+}
+/** Load global (disk) + session (per-session file) + project (per-cwd file) rules. */
+async function viewFor(ctx, sessionId, project, options) {
+    const v = await view(ctx, { id: sessionId }, options);
+    const proj = project ? await readProject(ctx, project) : [];
+    return { ...v, project: proj };
+}

package/lib/client.js

@@ -0,0 +1,295 @@
+/**
+ * Baize rules client — the 规则 button (sidebar footer) + 规则 conversation tab
+ * (对话/项目/全局). Hand-authored after @modusensus/dsh-mneme's client bundle:
+ * click the footer button → click the matching conversation.view tab; if there's
+ * no tab ring (new-chat hero) → open a full-viewport overlay. Data goes through
+ * the host HTTP API `/baize-rules.api` (same source of truth as /baize-rules).
+ *
+ * @module dsh-baize-rules/client
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-baize-rules',
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+
+    const react = require('react');
+    const primitives = require('@deepseek-ai/dsh-client-ui-primitives');
+    const { useState, useEffect, useCallback } = react;
+    const h = react.createElement;
+
+    const inject = ['slots', 'locale'];
+    const NS = 'baize-rules';
+
+    const dictionaries = {
+      zh: {
+        'rules.sidebar.aria': '打开规则',
+        'rules.panel.open': '规则',
+        'rules.view.label': '规则',
+        'rules.scope.session': '对话',
+        'rules.scope.project': '项目',
+        'rules.scope.global': '全局',
+        'rules.add': '添加规则',
+        'rules.remove': '删除',
+        'rules.edit': '编辑',
+        'rules.save': '保存',
+        'rules.cancel': '取消',
+        'rules.empty': '暂无规则',
+        'rules.addHint': '输入规则，回车添加（如：用中文写注释）',
+        'rules.error': '操作失败',
+        'rules.overlay.close': '关闭',
+      },
+      en: {
+        'rules.sidebar.aria': 'Open rules',
+        'rules.panel.open': 'Rules',
+        'rules.view.label': 'Rules',
+        'rules.scope.session': 'Session',
+        'rules.scope.project': 'Project',
+        'rules.scope.global': 'Global',
+        'rules.add': 'Add rule',
+        'rules.remove': 'Remove',
+        'rules.edit': 'Edit',
+        'rules.save': 'Save',
+        'rules.cancel': 'Cancel',
+        'rules.empty': 'No rules',
+        'rules.addHint': 'Type a rule and press Enter (e.g. write comments in Chinese)',
+        'rules.error': 'Failed',
+        'rules.overlay.close': 'Close',
+      },
+    };
+
+    // --- Module-scoped overlay store (mirrors dsh-mneme's useOverlayOpen). ---
+    let overlayOpen = false;
+    const overlayListeners = new Set();
+    function setOverlayOpen(open) { overlayOpen = open; overlayListeners.forEach((fn) => fn(open)); }
+    function useRulesOverlay() {
+      const [open, setOpen] = useState(overlayOpen);
+      useEffect(() => {
+        const fn = (v) => setOpen(v);
+        overlayListeners.add(fn);
+        return () => { overlayListeners.delete(fn); };
+      }, []);
+      return [open, setOverlayOpen];
+    }
+
+    // --- Themed CSS (mirrors dsh-mneme's .mneme-trigger) + a themed rules icon. ---
+    const RULES_CSS = [
+      '.baize-trigger{box-sizing:border-box;cursor:pointer;width:calc(100% + 4px);height:42px;color:var(--dsw-alias-label-primary);background:0 0;border:none;border-radius:12px;flex:none;align-items:center;gap:8px;margin:4px -2px;padding:0 10px 0 8px;font-family:inherit;font-size:14px;line-height:22px;display:flex;overflow:hidden}',
+      '.baize-trigger:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.baize-trigger.baize-rail{border-radius:50%;justify-content:center;gap:0;width:36px;height:36px;margin:8px 0 10px;padding:0}',
+      '.baize-trigger-label{white-space:nowrap;overflow:hidden}',
+      '.baize-seg{box-sizing:border-box;cursor:pointer;padding:5px 12px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:transparent;color:var(--dsw-alias-label-primary);font-family:inherit;font-size:13px;line-height:18px}',
+      '.baize-seg:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.baize-seg.baize-seg-on{background:var(--dsw-alias-interactive-bg-hover);border-color:var(--dsw-alias-state-business-primary);color:var(--dsw-alias-label-primary);font-weight:600}',
+      '.baize-ghost{box-sizing:border-box;cursor:pointer;padding:3px 8px;border-radius:6px;border:none;background:transparent;color:var(--dsw-alias-label-secondary);font-family:inherit;font-size:12px;line-height:16px}',
+      '.baize-ghost:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}',
+    ].join('');
+    let stylesInjected = false;
+    function injectStyles() {
+      if (stylesInjected || typeof document === 'undefined') return;
+      stylesInjected = true;
+      const tag = document.createElement('style');
+      tag.dataset.plugin = 'baize-rules';
+      tag.textContent = RULES_CSS;
+      document.head.appendChild(tag);
+    }
+    // Themed rules icon (list w/ checkmarks), stroke currentColor so it blends.
+    const RulesIcon = ({ size = 16 }) => h('svg', { width: size, height: size, viewBox: '0 0 16 16', fill: 'none', xmlns: 'http://www.w3.org/2000/svg' },
+      h('path', { d: 'M5 4.5 6.2 5.7 8.4 3.4M5 8.5 6.2 9.7 8.4 7.4M5 12.5 6.2 13.7 8.4 11.4', stroke: 'currentColor', strokeWidth: 1.3, strokeLinecap: 'round', strokeLinejoin: 'round' }),
+      h('path', { d: 'M11 4.5h1.5M11 8.5h1.5M11 12.5h1.5', stroke: 'currentColor', strokeWidth: 1.3, strokeLinecap: 'round' })
+    );
+
+    // --- Tab activation: find the conversation.view tab by label and click it,
+    // polling aria-selected (bounded) so a silent React gap isn't read as success. ---
+    function findRulesTab(label) {
+      const tabs = document.querySelectorAll('[role="tab"]');
+      for (const tab of tabs) if ((tab.textContent || '').trim() === label) return tab;
+      return null;
+    }
+    function activateRulesTab(label) {
+      return new Promise((resolve) => {
+        const tab = findRulesTab(label);
+        if (!tab) { resolve(false); return; }
+        tab.click();
+        const deadline = Date.now() + 400;
+        (function check() {
+          if (tab.getAttribute('aria-selected') === 'true') { resolve(true); return; }
+          if (Date.now() >= deadline) { resolve(false); return; }
+          requestAnimationFrame(check);
+        })();
+      });
+    }
+
+    // --- API (same-origin; host exposes /baize-rules.api). ---
+    function rulesQuery(sessionId, project) {
+      const q = new URLSearchParams();
+      if (sessionId) q.set('sessionId', sessionId);
+      if (project) q.set('project', project);
+      const s = q.toString();
+      return s ? '?' + s : '';
+    }
+    async function apiGet(sessionId, project) {
+      const res = await fetch('/baize-rules.api' + rulesQuery(sessionId, project));
+      if (!res.ok) throw new Error('get failed');
+      return res.json();
+    }
+    async function apiPost(sessionId, project, raw, scope) {
+      const res = await fetch('/baize-rules.api', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId, project, raw, scope }),
+      });
+      const body = await res.json();
+      if (!res.ok) throw new Error(body.error || body.text || 'post failed');
+      return body;
+    }
+
+    // One rule row with inline edit (编辑 → input + 保存/取消), instead of delete+re-add.
+    function RuleRow({ rule, onSave, onRemove, t }) {
+      const [editing, setEditing] = useState(false);
+      const [val, setVal] = useState(rule.text);
+      const begin = () => { setVal(rule.text); setEditing(true); };
+      const save = () => { if (val.trim()) onSave(rule.id, val.trim()); setEditing(false); };
+      return h('li', { style: { display: 'flex', alignItems: 'center', gap: 8, padding: '4px 0' } },
+        editing
+          ? h(react.Fragment, null,
+              h('input', { value: val, onChange: (e) => setVal(e.target.value), onKeyDown: (e) => { if (e.key === 'Enter') save(); if (e.key === 'Escape') setEditing(false); }, style: { flexGrow: 1, padding: '4px 8px', borderRadius: 6, border: '1px solid var(--dsw-alias-border-l2)', background: 'transparent', color: 'var(--dsw-alias-label-primary)' } }),
+              h('button', { type: 'button', className: 'baize-ghost', onClick: save }, t('rules.save')),
+              h('button', { type: 'button', className: 'baize-ghost', onClick: () => setEditing(false) }, t('rules.cancel'))
+            )
+          : h(react.Fragment, null,
+              h('span', { style: { flexGrow: 1, color: 'var(--dsw-alias-label-primary)' } }, rule.text),
+              h('button', { type: 'button', className: 'baize-ghost', onClick: begin }, t('rules.edit')),
+              h('button', { type: 'button', className: 'baize-ghost', onClick: () => onRemove(rule.id) }, t('rules.remove'))
+            )
+      );
+    }
+
+    function ScopeSection({ scopeLabel, rules, onSave, onRemove, t }) {
+      return h('div', { style: { margin: '8px 0' } },
+        h('div', { style: { fontWeight: 600, marginBottom: 4 } }, scopeLabel),
+        rules.length === 0
+          ? h('div', { style: { color: 'var(--dsw-alias-label-secondary, #888)', fontSize: 12 } }, t('rules.empty'))
+          : h('ul', { style: { listStyle: 'none', padding: 0, margin: 0 } },
+            rules.map(r => h(RuleRow, { key: r.id, rule: r, onSave, onRemove, t }))
+          )
+      );
+    }
+
+    function RulesPanel({ t, sessionId, project }) {
+      const [scope, setScope] = useState('session');
+      const [view, setView] = useState({ global: [], session: [], project: [] });
+      const [text, setText] = useState('');
+      const [err, setErr] = useState('');
+
+      const load = useCallback(async () => {
+        try { setView(await apiGet(sessionId, project)); setErr(''); }
+        catch (e) { setErr(String(e)); }
+      }, [sessionId]);
+      useEffect(() => { void load(); }, [load]);
+
+      async function add() {
+        if (!text.trim()) return;
+        try { const r = await apiPost(sessionId, project, 'add ' + text.trim(), scope); setView(r.view); setText(''); setErr(''); }
+        catch (e) { setErr(String(e)); }
+      }
+      async function remove(id) {
+        try { const r = await apiPost(sessionId, project, 'remove ' + id, scope); setView(r.view); }
+        catch (e) { setErr(String(e)); }
+      }
+      async function saveRule(id, text) {
+        try { const r = await apiPost(sessionId, project, 'edit ' + id + ' ' + text, scope); setView(r.view); setErr(''); }
+        catch (e) { setErr(String(e)); }
+      }
+
+      const scopeKeys = [
+        ['session', 'rules.scope.session'],
+        ['project', 'rules.scope.project'],
+        ['global', 'rules.scope.global'],
+      ];
+      const activeRules = view[scope] || [];
+      const activeLabelKey = (scopeKeys.find(([k]) => k === scope) || ['session'])[1];
+      return h('div', { style: { padding: 16, fontFamily: 'inherit' } },
+        h('div', { style: { display: 'flex', gap: 4, marginBottom: 12 } },
+          scopeKeys.map(([k, key]) => h('button', {
+            key: k, type: 'button', onClick: () => setScope(k),
+            className: 'baize-seg' + (scope === k ? ' baize-seg-on' : ''),
+          }, t(key)))
+        ),
+        h('div', { style: { display: 'flex', gap: 4, marginBottom: 12 } },
+          h('input', { value: text, onChange: (e) => setText(e.target.value), onKeyDown: (e) => { if (e.key === 'Enter') add(); }, placeholder: t('rules.addHint'), style: { flexGrow: 1, padding: '6px 8px', borderRadius: 8, border: '1px solid var(--dsw-alias-border-l2)', background: 'transparent', color: 'var(--dsw-alias-label-primary)' } }),
+          h('button', { type: 'button', onClick: add, className: 'baize-seg baize-seg-on', style: { padding: '6px 12px' } }, t('rules.add'))
+        ),
+        err ? h('div', { style: { color: 'var(--dsw-alias-state-error, #c33)', fontSize: 12 } }, err) : null,
+        h(ScopeSection, { t, scopeLabel: t(activeLabelKey), rules: activeRules, onSave: (id, text) => { void saveRule(id, text); }, onRemove: (id) => { void remove(id); } })
+      );
+    }
+
+    // --- Sidebar foot trigger: clicks the rules tab; falls back to overlay. ---
+    function RulesTrigger({ wide, t }) {
+      const [, setOpen] = useRulesOverlay();
+      return h('button', {
+        type: 'button',
+        className: wide ? 'baize-trigger' : 'baize-trigger baize-rail',
+        'aria-label': t('rules.sidebar.aria'),
+        title: t('rules.sidebar.aria'),
+        onClick: () => { activateRulesTab(t('rules.view.label')).then((ok) => { if (!ok) setOpen(true); }); },
+      },
+        h(RulesIcon, { size: wide ? 16 : 18 }),
+        wide ? h('span', { className: 'baize-trigger-label' }, t('rules.panel.open')) : null
+      );
+    }
+
+    // Full-viewport fallback when there's no tab ring (new-chat hero). Esc closes.
+    function RulesOverlay({ t }) {
+      const [open, setOpen] = useRulesOverlay();
+      useEffect(() => {
+        if (!open) return undefined;
+        const onKey = (e) => { if (e.key === 'Escape') setOpen(false); };
+        window.addEventListener('keydown', onKey);
+        return () => window.removeEventListener('keydown', onKey);
+      }, [open]);
+      if (!open) return null;
+      return h('div', { style: { position: 'fixed', inset: 0, background: 'var(--dsw-alias-bg-base, #111)', zIndex: 9999, overflow: 'auto' } },
+        h('div', { style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', padding: '8px 16px', borderBottom: '1px solid var(--dsw-alias-border-l2, #333)' } },
+          h('span', { style: { fontWeight: 600 } }, t('rules.view.label')),
+          h('button', { type: 'button', className: 'baize-ghost', onClick: () => setOpen(false) }, t('rules.overlay.close'))
+        ),
+        h(RulesPanel, { t })
+      );
+    }
+
+    function apply(ctx) {
+      injectStyles();
+      ctx.effect(() => ctx.locale.register(NS, dictionaries), 'baize-rules: dictionaries');
+
+      ctx.slots.inject('sidebar.footer.action', () => {
+        const t = ctx.locale.bind(NS);
+        return ctx.slots.register({
+          name: 'sidebar.footer.action',
+          id: 'baize-rules',
+          order: 1,
+          label: () => t('rules.panel.open')
+        }, (props) => h(react.Fragment, null,
+          h(RulesTrigger, { ...props, t }),
+          h(RulesOverlay, { t })
+        ));
+      });
+
+      ctx.slots.inject('conversation.view', () => {
+        const t = ctx.locale.bind(NS);
+        return ctx.slots.register({
+          name: 'conversation.view',
+          id: 'baize-rules-rules',
+          order: 30,
+          locale: NS,
+          label: () => t('rules.view.label')
+        }, (props) => h(RulesPanel, { t, sessionId: props?.sessionId ?? '', project: props?.cwd ?? props?.session?.header?.cwd ?? props?.session?.cwd ?? '' }));
+      });
+    }
+
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  }
+});