@leiyi-works/dsh-keyrule 0.0.0-stage → 1.7.0

package/README.md

@@ -1,3 +1,121 @@
-# Temporary Holding Version
+# 常驻钥则 · dsh-keyrule
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> 把用户明确说过的长期约定**每一步注入一次提示**——长会话、上下文压缩、重启之后都不会忘。
+> v1.2 起分三层：**全局** / **工作区** / **本会话**，并且删除会话时自动清掉会话级文件。
+
+## 它解决什么
+
+典型场景：
+
+> 「AI创作」这个会话用得很久了。你之前说过「非视频制作的任务交给团队」，
+> 但最近有一次任务，agent 还是自己从头做完了，你提醒它，它才想起来。
+
+根因不是 agent 不会记，而是：
+
+1. 那条约定**只存在于对话里**，不是文件；
+2. 长会话 + 上下文压缩/截断后，早期对话被摘要掉了；
+3. 就算没压缩，一句很久以前的话在长上下文里也会"沉底"。
+
+这个插件把这类约定变成**文件 + 每步注入**：
+
+- 每次组装模型提示时，把规则作为运行时上下文插进去（`systemPrompt.context`，每步一次）；
+- 提供 `standing_rules` 工具：agent 听到"以后都……/记住……/别再忘……"时，**立刻写进规则文件**。
+
+## 三层规则
+
+| 层 | 文件 | 谁看得到 | 适合放什么 |
+|---|---|---|---|
+| 全局 | `<DSH_HOME>/standing-rules.md`（默认 `C:\Users\TL\.dsh\standing-rules.md`） | 这个 profile 下**所有会话** | 通用习惯：「重要结论落文件」「花钱前先问」 |
+| 工作区 | `<会话工作目录>/.dsh-standing-rules.md` | 该工作区的会话 | 项目规矩：「本项目的交付格式」 |
+| 本会话 | `<DSH_HOME>/standing-rules/sessions/<sessionId>.md` | **仅当前会话** | 只在这个会话生效的约定 |
+
+- 只有真正往里写规则时才创建文件（插件不预先建空文件）；
+- 工作区层按会话的工作目录定位；本会话层按会话 id 定位；
+- **删除会话时，插件监听 `session/disposed` 自动删掉该会话的规则文件**，不留残留；
+- 想关掉某层：`includeWorkspaceRules: false` / `includeSessionRules: false`。
+
+## 安装
+
+Host-only bundle，无构建、无依赖。用 Harness 的 `plugin_manager`：
+
+```text
+plugin_manager({ action: "install_bundle", target: "<本目录绝对路径>" })
+```
+
+profile 级生效：该 profile 下所有会话都会加载。**替换已安装版本后需重启 DSH** 才会加载新代码。
+
+## 配置
+
+`cordis.patch.yml`：
+
+| 字段 | 默认 | 说明 |
+|---|---|---|
+| `rulesFile` | `~/.dsh/standing-rules.md` | 全局规则文件 |
+| `workspaceRulesFile` | `.dsh-standing-rules.md` | 工作区规则文件名（相对工作目录） |
+| `sessionRulesDir` | `~/.dsh/standing-rules/sessions` | 会话规则目录 |
+| `includeWorkspaceRules` | `true` | 关闭 = 不注入工作区规则 |
+| `includeSessionRules` | `true` | 关闭 = 不注入会话规则 |
+| `includeSubagents` | `true` | 子智能体/团队成员会话是否也注入 |
+| `maxChars` | `2400` | 每层规则正文上限，超出截断 |
+| `order` | `950` | 运行时上下文排序，越大越靠后 |
+| `enableTool` | `true` | 是否注册 `standing_rules` 工具 |
+
+## `standing_rules` 工具
+
+| 参数 | 说明 |
+|---|---|
+| `action` | `list` / `add` / `remove` |
+| `rule` | add / remove 的规则文本 |
+| `scope` | `global`（默认）/ `workspace` / `session` |
+
+示例：把「非视频制作交给团队」记为**只对当前会话**生效：
+
+```json
+{ "action": "add", "scope": "session",
+  "rule": "非视频制作类任务优先交给团队，主对话只做拆解、验收、汇总。" }
+```
+
+## 文件与残留
+
+插件只可能写这三个位置的 `.md`，此外不写任何文件（没有缓存、没有日志、没有状态文件）：
+
+- 全局规则（你自己维护，不随会话删除）；
+- 工作区规则（属于工作区，不随会话删除）；
+- 会话规则（按会话 id，**会话被删除时自动清理**）。
+
+特殊情况：如果插件在某个时刻被禁用/卸载，期间删除的会话其会话规则文件不会被自动清理，可手动删除 `~/.dsh/standing-rules/sessions/` 下对应文件。
+
+## 随时查看：左侧菜单「常驻钥则」→ 右侧边栏打开
+
+v1.6 起入口在**左侧主菜单**（和「插件」「自动化任务」「上下文洞察」「AI创作」「更多」并列）。
+
+- 点一下「常驻钥则」：**保持当前会话**，在**右侧边栏**打开「常驻钥则」标签页（和 H3 插件一样的侧边打开方式，不占会话框）；
+- 面板打开即显示 **① 全局规则** + **② 当前会话规则**（含「本工作区规则」和「本会话规则」两块，只显示当前这场会话的）；
+- 「刷新」重新读取（改完 md 文件点一下即可）；每条路径带「复制路径」；
+- 右侧边栏不可用时，才退回全页面板兜底（此时没有会话上下文，只显示全局规则）。
+
+面板只读，不提供编辑框；写规则仍然通过对话（"记住……"）或直接编辑文件。数据来自宿主只读接口 `GET /__dsh-keyrule/state?session=<会话id>`。
+
+## 卸载
+
+`plugin_manager({ action: "remove_bundle", target: "@local/dsh-keyrule" })`。
+规则文件不会被删，可自行保留或删除。
+
+## 2026-11-08 更新：二级菜单 + 密钥收纳
+
+- 面板（右侧栏「常驻钥则」标签页）顶部新增两个二级菜单，点哪个显示哪个界面：
+  - **常驻规则**：全局 / 本工作区 / 本会话三层规则（原功能）
+  - **常驻密钥**：插件 `secrets/` 目录的文件清单（名称 / 大小 / 更新时间 + 一键复制路径），并展示目录下 README 说明；**不展示私钥内容**
+- 密钥目录 `secrets/` 相对插件目录解析（可在 `cordis.patch.yml` 的 `secretsDir` 改）；该目录随插件源码一起被打包，所以换机包会带走
+- 工作区规则文件名改为 `.dsh-keyrule-rules.md`；旧文件 `.dsh-standing-rules.md` 仍会被回落读取（不会丢规则）
+- 主机接口：`GET /__dsh-keyrule/state?session=<id>`、`GET /__dsh-keyrule/secrets`
+## 2026-11-08 更新二：SSH 别名纳入插件自愈
+
+- 插件启动时（`apply`）调用 `ensureSshConfig`：
+  - 读 `~/.ssh/config`，维护 `# >>> dsh-keyrule managed host >>> … # <<< dsh-keyrule managed host <<<` 标记块
+  - 标记块缺失 → 追加；已存在 → 整体替换（路径随插件实际位置更新）
+  - 用户自定义同名 `Host` → 不触碰；写入前留 `config.dsh-keyrule.bak`
+- 配置项（`cordis.patch.yml`）：
+  - `ensureSshConfig: true`
+  - `sshHost: { alias, hostName, user, keyFile }`（keyFile 相对 `secretsDir` 解析）
+- 效果：换机后新机一启动 DSH，`ssh jdcloud` 别名自动就位，无需手动补 `~/.ssh/config`

package/client.js

@@ -0,0 +1,411 @@
+/**
+ * dsh-keyrule — Client half.
+ *
+ * 左侧菜单「常驻钥则」入口 + 右侧边栏标签页。
+ * 面板顶部两个二级菜单：
+ *   - 常驻规则：全局 / 本工作区 / 本会话三层规则
+ *   - 常驻密钥：插件 secrets/ 目录里的密钥清单（不展示私钥内容）
+ */
+window.__ModuleLoader__.load({
+  id: '@local/dsh-keyrule',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+    const NS = 'standingRules'
+    /** 右侧边栏标签页类型 id（native right Sidebar tab kind）。 */
+    const TAB_ID = 'standing-rules-tab'
+    /** 左侧菜单行 / 兜底全页面板 id。 */
+    const PANEL_ID = 'standing-rules'
+    const CSS_TAG_ID = 'dsh-keyrule/client.css'
+    const CSS = [
+      '.srRoot{height:100%;overflow:auto;box-sizing:border-box;padding:calc(var(--dsh-frame-top-clearance,0px) + 16px) 14px 28px;color:var(--dsw-alias-label-primary);font-size:13px;line-height:1.55}',
+      '.srInner{max-width:860px;margin:0 auto;display:flex;flex-direction:column;gap:12px}',
+      '.srTitle{margin:0;font-size:17px;font-weight:600}',
+      '.srHint{margin:0;color:var(--dsw-alias-label-secondary);font-size:12px}',
+      '.srTabs{display:flex;gap:4px;border-bottom:1px solid var(--dsw-alias-border-l1,rgba(127,127,127,.22));padding-bottom:0;margin-top:2px}',
+      '.srTab{appearance:none;cursor:pointer;border:none;background:transparent;color:var(--dsw-alias-label-secondary);font-size:13px;line-height:20px;padding:6px 12px;border-bottom:2px solid transparent;margin-bottom:-1px;border-radius:6px 6px 0 0}',
+      '.srTab:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-2,rgba(127,127,127,.08))}',
+      '.srTabOn{color:var(--dsw-alias-label-primary);font-weight:600;border-bottom-color:var(--dsw-alias-brand-primary,#4d6bfe)}',
+      '.srBar{display:flex;align-items:center;gap:8px;flex-wrap:wrap}',
+      '.srBtn{appearance:none;cursor:pointer;border-radius:7px;padding:4px 12px;font-size:12px;line-height:18px;border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.35));background:transparent;color:var(--dsw-alias-label-primary)}',
+      '.srBtn:hover{background:var(--dsw-alias-bg-layer-2,rgba(127,127,127,.08))}',
+      '.srBtn:disabled{opacity:.55;cursor:default}',
+      '.srMeta{font-size:11px;color:var(--dsw-alias-label-secondary)}',
+      '.srSection{display:flex;flex-direction:column;gap:6px;border:1px solid var(--dsw-alias-border-l1,rgba(127,127,127,.22));border-radius:10px;padding:10px 12px}',
+      '.srSectionHead{display:flex;align-items:baseline;justify-content:space-between;gap:8px}',
+      '.srLabel{font-size:12px;font-weight:600}',
+      '.srPath{font-family:ui-monospace,Consolas,monospace;font-size:10px;color:var(--dsw-alias-label-secondary);word-break:break-all}',
+      '.srPre{margin:0;font-family:ui-monospace,Consolas,monospace;font-size:11px;line-height:1.6;white-space:pre-wrap;word-break:break-word;background:var(--dsw-alias-bg-layer-2,rgba(127,127,127,.08));border-radius:8px;padding:8px;max-height:220px;overflow:auto}',
+      '.srEmpty{font-size:12px;color:var(--dsw-alias-label-secondary)}',
+      '.srErr{font-size:12px;color:var(--dsw-alias-state-error-primary,#d14a4a)}',
+      '.srSecRow{display:flex;align-items:center;gap:10px;border:1px solid var(--dsw-alias-border-l1,rgba(127,127,127,.22));border-radius:8px;padding:7px 10px}',
+      '.srSecName{font-family:ui-monospace,Consolas,monospace;font-size:12px;flex:1;word-break:break-all}',
+      '.srSecMeta{font-size:11px;color:var(--dsw-alias-label-secondary);white-space:nowrap}',
+    ].join('')
+    try {
+      if (typeof document !== 'undefined' && document.querySelector(`style[data-plugin-css="${CSS_TAG_ID}"]`) === null) {
+        const tag = document.createElement('style')
+        tag.dataset.plugin = 'dsh-keyrule'
+        tag.dataset.pluginCss = CSS_TAG_ID
+        tag.textContent = CSS
+        document.head.appendChild(tag)
+      }
+    } catch {
+      /* ignore */
+    }
+
+    const zh = {
+      label: '常驻钥则',
+      title: '常驻钥则',
+      tabRules: '常驻规则',
+      tabSecrets: '常驻密钥',
+      hint: '这里是每一步都会注入提示的规则。改文件保存后点「刷新」；本会话规则在删除会话时自动清理。',
+      secretsHint: '这里是随插件源码一起走（含换机包）的密钥目录。新增密钥直接放进该目录，私钥内容不在界面展示。',
+      guide: '查看常驻规则与常驻密钥',
+      global: '全局规则',
+      workspace: '本工作区规则',
+      session: '本会话规则',
+      current: '当前会话',
+      noSession: '当前没有会话上下文（从右侧栏打开可看到本会话规则）。',
+      refresh: '刷新',
+      copyPath: '复制路径',
+      copied: '已复制',
+      missing: '（文件还没创建）',
+      loading: '读取中…',
+      failed: '读取失败',
+      generatedAt: '读取于',
+      secretsDir: '密钥目录',
+      secretCount: '文件数',
+      secretBytes: '合计',
+      secretsEmpty: '（目录为空或还不存在）',
+      readme: '说明文件',
+      copyName: '复制路径',
+    }
+    const en = {
+      label: 'Key rules',
+      title: 'Key rules',
+      tabRules: 'Rules',
+      tabSecrets: 'Secrets',
+      hint: 'Rules injected into every model step. Edit a file and press Refresh; session-scoped files are cleaned when the session is deleted.',
+      secretsHint: 'Secrets bundled with this plugin source (travel with the migration pack). Add keys by dropping files in this directory; private key contents are not shown here.',
+      guide: 'View standing rules and bundled secrets',
+      global: 'Global rules',
+      workspace: 'Workspace rules',
+      session: 'Session rules',
+      current: 'Current session',
+      noSession: 'No session context. Open this from the right sidebar to see session rules.',
+      refresh: 'Refresh',
+      copyPath: 'Copy path',
+      copied: 'Copied',
+      missing: '(file not created yet)',
+      loading: 'Loading…',
+      failed: 'Failed to load',
+      generatedAt: 'Read at',
+      secretsDir: 'Secrets directory',
+      secretCount: 'Files',
+      secretBytes: 'Total',
+      secretsEmpty: '(empty or not created yet)',
+      readme: 'README',
+      copyName: 'Copy path',
+    }
+
+    function endpointUrl(name, sessionId) {
+      const query = sessionId ? `?session=${encodeURIComponent(sessionId)}` : ''
+      try {
+        return new URL(`__dsh-keyrule/${name}${query}`, document.baseURI).href
+      } catch {
+        return `/__dsh-keyrule/${name}${query}`
+      }
+    }
+
+    function formatBytes(n) {
+      const num = Number(n)
+      if (!Number.isFinite(num) || num < 0) return '-'
+      if (num < 1024) return `${num} B`
+      if (num < 1024 * 1024) return `${(num / 1024).toFixed(1)} KB`
+      return `${(num / 1024 / 1024).toFixed(2)} MB`
+    }
+
+    /** 左侧菜单行 / 右侧 tab 图标（剪贴板 + 对勾）。 */
+    function StandingRulesIcon(props) {
+      const size = props && typeof props.size === 'number' && props.size > 0 ? props.size : 18
+      return h('svg', {
+        width: size,
+        height: size,
+        viewBox: '0 0 24 24',
+        fill: 'none',
+        'aria-hidden': true,
+        style: { display: 'block' },
+      },
+        h('rect', {
+          x: 4.4, y: 4.2, width: 15.2, height: 16.4, rx: 2.2,
+          stroke: 'currentColor', strokeWidth: 1.6, strokeLinejoin: 'round',
+        }),
+        h('path', {
+          d: 'M9 4.4h6M9 3.4h6a1 1 0 0 1 1 1v1.4H8V4.4a1 1 0 0 1 1-1z',
+          stroke: 'currentColor', strokeWidth: 1.5, strokeLinejoin: 'round',
+        }),
+        h('path', { d: 'M8.2 12.2h7.6M8.2 15.6h5.2', stroke: 'currentColor', strokeWidth: 1.5, strokeLinecap: 'round' }),
+        h('path', { d: 'M14.2 18.1l1.5 1.5 3-3.4', stroke: 'currentColor', strokeWidth: 1.6, strokeLinecap: 'round', strokeLinejoin: 'round' }))
+    }
+
+    const TabIcon = (size) => h(StandingRulesIcon, { size })
+
+    function CopyButton({ path, t }) {
+      const [copied, setCopied] = React.useState(false)
+      const copy = () => {
+        try {
+          void navigator.clipboard.writeText(path).then(() => {
+            setCopied(true)
+            setTimeout(() => setCopied(false), 1200)
+          })
+        } catch {
+          /* ignore */
+        }
+      }
+      return h('button', { type: 'button', className: 'srBtn', onClick: copy }, copied ? t('copied') : t('copyPath'))
+    }
+
+    function RulesBlock({ title, path, text, t }) {
+      return h('div', { className: 'srSection' },
+        h('div', { className: 'srSectionHead' },
+          h('span', { className: 'srLabel' }, title),
+          h(CopyButton, { path, t })),
+        h('span', { className: 'srPath' }, path),
+        text && String(text).trim() !== ''
+          ? h('pre', { className: 'srPre' }, String(text))
+          : h('span', { className: 'srEmpty' }, t('missing')))
+    }
+
+    function RulesView({ sessionId, t }) {
+      const [state, setState] = React.useState({ phase: 'loading' })
+      const load = React.useCallback(() => {
+        setState({ phase: 'loading' })
+        fetch(endpointUrl('state', sessionId), { cache: 'no-store' })
+          .then((res) => res.json())
+          .then((data) => setState({ phase: 'ready', data }))
+          .catch((error) => setState({ phase: 'error', error: String(error && error.message ? error.message : error) }))
+      }, [sessionId])
+      React.useEffect(() => {
+        load()
+      }, [load])
+
+      const data = state.phase === 'ready' ? state.data : undefined
+      const current = data && data.current ? data.current : null
+      return h(React.Fragment, null,
+        h('div', { className: 'srBar' },
+          h('button', { type: 'button', className: 'srBtn', onClick: load, disabled: state.phase === 'loading' }, t('refresh')),
+          state.phase === 'loading' ? h('span', { className: 'srMeta' }, t('loading')) : null,
+          state.phase === 'ready' && data ? h('span', { className: 'srMeta' }, `${t('generatedAt')} ${new Date(data.generatedAt).toLocaleString()}`) : null),
+        state.phase === 'error' ? h('span', { className: 'srErr' }, `${t('failed')}: ${state.error}`) : null,
+        state.phase === 'ready' && data
+          ? h(React.Fragment, null,
+            h(RulesBlock, { title: t('global'), path: data.global.path, text: data.global.text, t }),
+            current
+              ? h(React.Fragment, null,
+                current.workspace
+                  ? h(RulesBlock, { title: t('workspace'), path: current.workspace.path, text: current.workspace.text, t })
+                  : null,
+                h(RulesBlock, { title: t('session'), path: current.session.path, text: current.session.text, t }))
+              : h('span', { className: 'srEmpty' }, t('noSession')))
+          : null)
+    }
+
+    function SecretsView({ t }) {
+      const [state, setState] = React.useState({ phase: 'loading' })
+      const load = React.useCallback(() => {
+        setState({ phase: 'loading' })
+        fetch(endpointUrl('secrets'), { cache: 'no-store' })
+          .then((res) => res.json())
+          .then((data) => setState({ phase: 'ready', data }))
+          .catch((error) => setState({ phase: 'error', error: String(error && error.message ? error.message : error) }))
+      }, [])
+      React.useEffect(() => {
+        load()
+      }, [load])
+      const data = state.phase === 'ready' ? state.data : undefined
+      return h(React.Fragment, null,
+        h('div', { className: 'srBar' },
+          h('button', { type: 'button', className: 'srBtn', onClick: load, disabled: state.phase === 'loading' }, t('refresh')),
+          state.phase === 'loading' ? h('span', { className: 'srMeta' }, t('loading')) : null,
+          data
+            ? h('span', { className: 'srMeta' }, `${t('secretCount')} ${(data.files || []).length} · ${t('secretBytes')} ${formatBytes(data.totalBytes)}`)
+            : null),
+        state.phase === 'error' ? h('span', { className: 'srErr' }, `${t('failed')}: ${state.error}`) : null,
+        data
+          ? h('div', { className: 'srSection' },
+            h('div', { className: 'srSectionHead' },
+              h('span', { className: 'srLabel' }, t('secretsDir')),
+              h(CopyButton, { path: data.dir, t })),
+            h('span', { className: 'srPath' }, data.dir),
+            (data.files || []).length === 0
+              ? h('span', { className: 'srEmpty' }, t('secretsEmpty'))
+              : h(React.Fragment, null,
+                ...(data.files || []).map((file) => h('div', { className: 'srSecRow', key: file.path },
+                  h('span', { className: 'srSecName' }, file.name),
+                  h('span', { className: 'srSecMeta' }, formatBytes(file.bytes)),
+                  h('span', { className: 'srSecMeta' }, new Date(file.mtime).toLocaleString()),
+                  h(CopyButton, { path: file.path, t })))))
+          : null,
+        data && data.readme
+          ? h('div', { className: 'srSection' },
+            h('div', { className: 'srSectionHead' },
+              h('span', { className: 'srLabel' }, `${t('readme')} · ${data.readmeName}`)),
+            h('pre', { className: 'srPre' }, data.readme))
+          : null)
+    }
+
+    function KeyRulePanel(props) {
+      const t = (key) => (typeof props.t === 'function' ? props.t(key) : zh[key] !== undefined ? zh[key] : key)
+      const sessionId = typeof props.sessionId === 'string' ? props.sessionId : ''
+      const [tab, setTab] = React.useState('rules')
+      const tabBtn = (id, label) => h('button', {
+        type: 'button',
+        className: `srTab${tab === id ? ' srTabOn' : ''}`,
+        onClick: () => setTab(id),
+      }, label)
+      return h('div', { className: 'srRoot' },
+        h('div', { className: 'srInner' },
+          h('h1', { className: 'srTitle' }, t('title')),
+          h('div', { className: 'srTabs' },
+            tabBtn('rules', t('tabRules')),
+            tabBtn('secrets', t('tabSecrets'))),
+          h('p', { className: 'srHint' }, tab === 'rules' ? t('hint') : t('secretsHint')),
+          tab === 'rules' ? h(RulesView, { sessionId, t }) : h(SecretsView, { t })))
+    }
+
+    return {
+      name: '@local/dsh-keyrule',
+      inject: ['slots', 'locale', 'layout'],
+      apply(ctx) {
+        ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-keyrule: dictionaries')
+        const t = ctx.locale.bind(NS)
+
+        /** 打开（或聚焦）右侧边栏的常驻钥则 tab。 */
+        let nativeOpen = null
+        let redirecting = false
+        const openTab = () => {
+          if (nativeOpen === null) return false
+          try {
+            nativeOpen()
+            return true
+          } catch (error) {
+            console.warn('[dsh-keyrule] native right-sidebar openTab failed:', error)
+            return false
+          }
+        }
+
+        // 注册右侧边栏 tab（和 H3 同款原生通道）。
+        const mountTab = (inner) => {
+          let registry
+          let slots
+          let sidebarRight
+          try {
+            registry = inner.sidebarRightTabs ?? inner.get?.('sidebarRightTabs')
+            slots = inner.slots
+            sidebarRight = inner.sidebarRight ?? inner.get?.('sidebarRight')
+          } catch {
+            return undefined
+          }
+          if (registry === undefined || typeof registry.register !== 'function' || slots === undefined) return undefined
+          const disposers = []
+          try {
+            const disposeType = registry.register({
+              id: TAB_ID,
+              kind: TAB_ID,
+              title: () => t('label'),
+              guide: [
+                { order: 60, title: () => t('label'), description: () => t('guide'), icon: TabIcon },
+              ],
+            })
+            if (typeof disposeType === 'function') disposers.push(disposeType)
+            const disposeBody = slots.inject('sidebar.right.pane.tab', () => slots.register({
+              name: 'sidebar.right.pane.tab',
+              key: TAB_ID,
+              locale: NS,
+            }, (props) => h(KeyRulePanel, props)))
+            if (typeof disposeBody === 'function') disposers.push(disposeBody)
+            if (sidebarRight !== undefined && typeof sidebarRight.openTab === 'function') {
+              nativeOpen = () => sidebarRight.openTab(TAB_ID)
+            }
+          } catch (error) {
+            for (const dispose of disposers.reverse()) {
+              try { dispose() } catch { /* ignore */ }
+            }
+            return undefined
+          }
+          return () => {
+            for (const dispose of disposers.reverse()) {
+              try { dispose() } catch { /* ignore */ }
+            }
+          }
+        }
+        try {
+          ctx.inject(['sidebarRightTabs', 'sidebarRight', 'slots'], mountTab)
+        } catch {
+          mountTab(ctx)
+        }
+
+        // 兜底：右侧边栏打不开时，仍可用全页面板查看。
+        ctx.effect(
+          () => ctx.slots.inject('main', () => ctx.slots.register({
+            name: 'main',
+            key: PANEL_ID,
+            locale: NS,
+          }, KeyRulePanel)),
+          'dsh-keyrule: main panel (fallback full page)',
+        )
+
+        // 左侧菜单入口。
+        ctx.effect(
+          () => ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({
+            name: 'sidebar.panellist',
+            id: PANEL_ID,
+            order: 44,
+            label: () => t('label'),
+            locale: NS,
+          }, StandingRulesIcon)),
+          'dsh-keyrule: sidebar entry',
+        )
+
+        // 点左侧行时保持会话：先回到会话，再开右侧 tab；打不开才退回全页面板。
+        ctx.effect(() => {
+          const layout = ctx.layout
+          const openAfterReturn = () => {
+            const opened = openTab()
+            if (!opened) {
+              try {
+                layout.selectPanel(PANEL_ID)
+              } catch (error) {
+                console.warn('[dsh-keyrule] full-page fallback failed:', error)
+              }
+            }
+            redirecting = false
+          }
+          const check = () => {
+            if (redirecting) return
+            let active
+            try {
+              active = layout.panelInfo.getSnapshot().activePanelId
+            } catch {
+              return
+            }
+            if (active !== PANEL_ID) return
+            redirecting = true
+            try {
+              layout.selectPanel(null)
+            } catch (error) {
+              redirecting = false
+              console.warn('[dsh-keyrule] returning to the conversation failed:', error)
+              return
+            }
+            if (typeof queueMicrotask === 'function') queueMicrotask(openAfterReturn)
+            else setTimeout(openAfterReturn, 0)
+          }
+          check()
+          return layout.panelInfo.subscribe(check)
+        }, 'dsh-keyrule: sidebar entry opens the native right-sidebar tab')
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,31 @@
+- insert:
+    - id: keyrule
+      name: '@local/dsh-keyrule'
+      config:
+        # 全局规则文件（所有会话可见）；~ 展开到用户主目录
+        rulesFile: '~/.dsh/standing-rules.md'
+        # 工作区规则文件名（相对每个会话的工作目录；该工作区的会话可见）
+        workspaceRulesFile: '.dsh-keyrule-rules.md'
+        # 密钥目录：相对路径按插件目录解析（secrets/ 随插件源码一起被打包带走）
+        secretsDir: 'secrets'
+        # 启动时自动补齐 ~/.ssh/config 里的服务器别名（换机后免手工补；只维护自己的标记块）
+        ensureSshConfig: true
+        sshHost:
+          alias: jdcloud
+          hostName: '111.228.26.140'
+          user: root
+          keyFile: jdcloud-lavm.pem
+        # 本会话规则文件目录（<sessionId>.md；会话删除时自动清理）
+        sessionRulesDir: '~/.dsh/standing-rules/sessions'
+        # 是否注入工作区规则（false = 只注入全局规则）
+        includeWorkspaceRules: true
+        # 是否注入本会话规则（false = 关闭第三层）
+        includeSessionRules: true
+        # 是否在子智能体/团队成员的会话里也注入（false = 只给主会话）
+        includeSubagents: true
+        # 每一步注入的上下文里，每层规则正文最多保留多少字符
+        maxChars: 2400
+        # 提示上下文排序（越大越靠后、越贴近当前回合）
+        order: 950
+        # 是否注册 standing_rules 工具（供 agent 记录新规则）
+        enableTool: true

package/icon.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64" role="img" aria-label="Standing rules">
+  <rect x="8" y="10" width="48" height="46" rx="10" fill="#2f6feb"/>
+  <rect x="20" y="4" width="24" height="12" rx="6" fill="#1b4fb0"/>
+  <circle cx="32" cy="10" r="4" fill="#dfe9ff"/>
+  <g stroke="#ffffff" stroke-width="4" stroke-linecap="round">
+    <line x1="20" y1="28" x2="44" y2="28"/>
+    <line x1="20" y1="38" x2="38" y2="38"/>
+  </g>
+  <path d="M22 48 l6 6 l12 -13" fill="none" stroke="#ffffff" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/index.js

@@ -0,0 +1,616 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Standing rules — 常驻钥则（v1.2：全局 + 工作区 + 本会话 三层）
+ *
+ * 用户说过的长期约定，每一步模型提示都重新注入一次，所以长会话、上下文压缩、
+ * 重启之后都不会忘。规则分三层：
+ *   1. 全局：<DSH_HOME>/standing-rules.md —— 所有会话都看得到；
+ *   2. 工作区：<会话工作目录>/.dsh-standing-rules.md —— 该工作区的会话都看得到；
+ *   3. 本会话：<DSH_HOME>/standing-rules/sessions/<sessionId>.md —— 只在当前会话注入。
+ *
+ * 残留约定：前两层属于用户/工作区，不随会话删除；第三层是"按会话"的文件，
+ * 插件监听 `session/disposed`，会话被删除时自动删掉该会话的规则文件。
+ */
+
+export const name = 'keyrule'
+
+export const inject = ['systemPrompt', 'tools']
+
+const DEFAULT_MAX_CHARS = 2400
+const DEFAULT_ORDER = 950
+const DEFAULT_WORKSPACE_FILE = '.dsh-keyrule-rules.md'
+/** 旧文件名：新文件不存在时回落读取，避免已有工作区规则丢失（2026-11-08 改名） */
+const LEGACY_WORKSPACE_FILE = '.dsh-standing-rules.md'
+/** 插件自身目录：secrets/ 就在下面，随插件源码一起被打包带走 */
+const HERE = dirname(fileURLToPath(import.meta.url))
+const DEFAULT_SECRETS_DIR = join(HERE, 'secrets')
+/** 插件管理的 ~/.ssh/config 标记块（只动自己这段，不碰用户其它 Host） */
+const SSH_BLOCK_BEGIN = '# >>> dsh-keyrule managed host >>>'
+const SSH_BLOCK_END = '# <<< dsh-keyrule managed host <<<'
+const HEADER = '## 常驻钥则（用户长期约定，必须遵守）'
+
+function dshHome() {
+  const env = process.env.DSH_HOME
+  return env && env.trim() ? env.trim() : join(homedir(), '.dsh')
+}
+
+function expandPath(input) {
+  if (typeof input !== 'string' || input.trim() === '') return join(dshHome(), 'standing-rules.md')
+  let value = input.trim()
+  if (value === '~') return homedir()
+  if (value.startsWith('~/') || value.startsWith('~\\')) value = join(homedir(), value.slice(2))
+  return isAbsolute(value) ? value : resolve(process.cwd(), value)
+}
+
+function readConfig(config) {
+  const c = config && typeof config === 'object' ? config : {}
+  const maxChars = Number.isFinite(c.maxChars) && c.maxChars > 0 ? Math.floor(c.maxChars) : DEFAULT_MAX_CHARS
+  const order = Number.isFinite(c.order) ? c.order : DEFAULT_ORDER
+  const workspaceRulesFile =
+    typeof c.workspaceRulesFile === 'string' && c.workspaceRulesFile.trim()
+      ? c.workspaceRulesFile.trim()
+      : DEFAULT_WORKSPACE_FILE
+  const sessionRulesDir =
+    typeof c.sessionRulesDir === 'string' && c.sessionRulesDir.trim()
+      ? expandPath(c.sessionRulesDir.trim())
+      : join(dshHome(), 'standing-rules', 'sessions')
+  const secretsDir =
+    typeof c.secretsDir === 'string' && c.secretsDir.trim()
+      ? (isAbsolute(c.secretsDir.trim()) ? c.secretsDir.trim() : join(HERE, c.secretsDir.trim()))
+      : DEFAULT_SECRETS_DIR
+  const sshHost = c.sshHost && typeof c.sshHost === 'object' && typeof c.sshHost.alias === 'string' && c.sshHost.alias.trim()
+    ? {
+        alias: c.sshHost.alias.trim(),
+        hostName: typeof c.sshHost.hostName === 'string' ? c.sshHost.hostName.trim() : '',
+        user: typeof c.sshHost.user === 'string' ? c.sshHost.user.trim() : 'root',
+        keyFile: typeof c.sshHost.keyFile === 'string' && c.sshHost.keyFile.trim() ? c.sshHost.keyFile.trim() : 'jdcloud-lavm.pem',
+      }
+    : null
+  return {
+    rulesFile: expandPath(c.rulesFile),
+    workspaceRulesFile,
+    secretsDir,
+    ensureSshConfig: c.ensureSshConfig === true && sshHost !== null && sshHost.hostName !== '',
+    sshHost,
+    sessionRulesDir,
+    includeWorkspaceRules: c.includeWorkspaceRules !== false,
+    includeSessionRules: c.includeSessionRules !== false,
+    includeSubagents: c.includeSubagents !== false,
+    maxChars,
+    order,
+    enableTool: c.enableTool !== false,
+  }
+}
+
+/** 工作区规则文件：优先用配置的文件名；找不到时回落到旧文件名（改名兼容）。 */
+function resolveWorkspaceFile(cwd, cfg) {
+  if (!cwd) return ''
+  const preferred = join(cwd, cfg.workspaceRulesFile)
+  if (existsSync(preferred)) return preferred
+  if (cfg.workspaceRulesFile === DEFAULT_WORKSPACE_FILE) {
+    const legacy = join(cwd, LEGACY_WORKSPACE_FILE)
+    if (existsSync(legacy)) return legacy
+  }
+  return preferred
+}
+
+/** 读取 secrets/ 目录清单（只列文件信息与 README 文本，不返回私钥内容）。 */
+function readSecrets(dir) {
+  const out = { ok: true, dir, exists: existsSync(dir), files: [], readme: '', readmeName: '', totalBytes: 0 }
+  try {
+    if (!out.exists) return out
+    const entries = readdirSync(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      if (!entry.isFile() || entry.name.startsWith('.')) continue
+      const full = join(dir, entry.name)
+      let st
+      try { st = statSync(full) } catch { continue }
+      out.files.push({ name: entry.name, path: full, bytes: st.size, mtime: st.mtimeMs })
+    }
+    out.files.sort((a, b) => a.name.localeCompare(b.name))
+    out.totalBytes = out.files.reduce((n, f) => n + f.bytes, 0)
+    const readme = out.files.find((f) => /^readme(\.txt)?$/i.test(f.name))
+    if (readme) {
+      out.readmeName = readme.name
+      try { out.readme = readFileSync(readme.path, 'utf8').slice(0, 8000) } catch { /* ignore */ }
+    }
+  } catch (error) {
+    out.ok = false
+    out.error = String(error && error.message ? error.message : error)
+  }
+  return out
+}
+
+/**
+ * 确保 ~/.ssh/config 里有插件管理的 Host 别名块（换机后免手工补）。
+ * 只维护带标记的块：已有标记块则整体替换；用户自己定义的同名 Host 则不碰。
+ */
+function ensureSshConfig(cfg) {
+  if (!cfg.ensureSshConfig || !cfg.sshHost) return { skipped: true, reason: 'disabled' }
+  const host = cfg.sshHost
+  const keyFile = isAbsolute(host.keyFile) ? host.keyFile : join(cfg.secretsDir, host.keyFile)
+  if (!existsSync(keyFile)) return { skipped: true, reason: 'private key missing', keyFile }
+  const dir = join(homedir(), '.ssh')
+  const file = join(dir, 'config')
+  let existing = ''
+  try {
+    existing = readFileSync(file, 'utf8').replace(/^\uFEFF/, '')
+  } catch {
+    existing = ''
+  }
+  const keyPath = keyFile.replace(/\\/g, '/')
+  const block = [
+    SSH_BLOCK_BEGIN,
+    `Host ${host.alias}`,
+    `    HostName ${host.hostName}`,
+    `    User ${host.user}`,
+    `    IdentityFile ${keyPath}`,
+    '    IdentitiesOnly yes',
+    '    ServerAliveInterval 30',
+    '    ServerAliveCountMax 3',
+    SSH_BLOCK_END,
+  ].join('\n')
+  const beginAt = existing.indexOf(SSH_BLOCK_BEGIN)
+  const endAt = existing.indexOf(SSH_BLOCK_END)
+  let next
+  if (beginAt !== -1 && endAt > beginAt) {
+    next = existing.slice(0, beginAt) + block + existing.slice(endAt + SSH_BLOCK_END.length)
+  } else if (new RegExp(`^\\s*Host\\s+${host.alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm').test(existing)) {
+    return { skipped: true, reason: 'host defined by user', file }
+  } else {
+    next = `${existing.trim() ? `${existing.replace(/\s+$/, '')}\n\n` : ''}${block}\n`
+  }
+  if (next === existing) return { changed: false, file, keyFile }
+  try {
+    mkdirSync(dir, { recursive: true })
+    if (existing.trim()) writeFileSync(`${file}.dsh-keyrule.bak`, existing, 'utf8')
+    writeFileSync(file, next, 'utf8')
+  } catch (error) {
+    return { skipped: true, reason: `write failed: ${error instanceof Error ? error.message : String(error)}`, file }
+  }
+  return { changed: true, file, keyFile }
+}
+
+/** mtime/size 缓存；提示上下文 provider 必须是同步的。 */
+function createRuleLoader(file, maxChars) {
+  let cache = { mtimeMs: -1, size: -1, text: '' }
+
+  function read() {
+    try {
+      const st = statSync(file)
+      if (st.mtimeMs === cache.mtimeMs && st.size === cache.size) return cache.text
+      let text = readFileSync(file, 'utf8').replace(/^\uFEFF/, '').trim()
+      if (text.length > maxChars) text = `${text.slice(0, maxChars).trim()}\n…（规则过长，已截断）`
+      cache = { mtimeMs: st.mtimeMs, size: st.size, text }
+    } catch {
+      if (cache.mtimeMs !== -1) cache = { mtimeMs: -1, size: -1, text: '' }
+    }
+    return cache.text
+  }
+
+  return { read }
+}
+
+function splitRuleLines(text) {
+  return text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line !== '')
+}
+
+function ensureParent(file) {
+  try {
+    mkdirSync(dirname(file), { recursive: true })
+  } catch {
+    // 目录已存在或不可写；写入时会报真正的错误
+  }
+}
+
+function appendRule(file, ruleRaw) {
+  const line = ruleRaw.startsWith('- ') || ruleRaw.startsWith('* ') ? ruleRaw : `- ${ruleRaw}`
+  ensureParent(file)
+  let existing = ''
+  try {
+    existing = readFileSync(file, 'utf8').replace(/^\uFEFF/, '')
+  } catch {
+    existing = ''
+  }
+  if (!existing.trim()) {
+    writeFileSync(file, `# 常驻钥则\n\n${line}\n`, 'utf8')
+  } else {
+    const body = existing.endsWith('\n') || existing.endsWith('\r\n') ? existing : `${existing}\n`
+    writeFileSync(file, `${body}${line}\n`, 'utf8')
+  }
+  return line
+}
+
+function removeRules(file, ruleRaw) {
+  const needle = ruleRaw.replace(/^[-*]\s+/, '').toLowerCase()
+  let target = []
+  try {
+    target = splitRuleLines(readFileSync(file, 'utf8').replace(/^\uFEFF/, '').trim())
+  } catch {
+    return 0
+  }
+  const kept = target.filter((line) => !line.replace(/^[-*]\s+/, '').toLowerCase().includes(needle))
+  const removed = target.length - kept.length
+  if (removed > 0) {
+    ensureParent(file)
+    writeFileSync(file, kept.length ? `${kept.join('\n')}\n` : '# 常驻钥则\n', 'utf8')
+  }
+  return removed
+}
+
+export function apply(ctx, config) {
+  const cfg = readConfig(config)
+  /** 换机 / 首次启动时自动补齐 ~/.ssh/config 别名；失败不影响插件其它功能。 */
+  try {
+    const sshResult = ensureSshConfig(cfg)
+    if (sshResult && sshResult.changed) console.log('[dsh-keyrule] ssh config ensured:', sshResult.file)
+  } catch (error) {
+    console.warn('[dsh-keyrule] ensureSshConfig failed:', error)
+  }
+  const globalLoader = createRuleLoader(cfg.rulesFile, cfg.maxChars)
+  /** @type {Map<string, {mtimeMs:number,size:number,text:string}>} */
+  const cache = new Map()
+
+  function readCached(file) {
+    try {
+      const st = statSync(file)
+      const hit = cache.get(file)
+      if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.text
+      let text = readFileSync(file, 'utf8').replace(/^\uFEFF/, '').trim()
+      if (text.length > cfg.maxChars) text = `${text.slice(0, cfg.maxChars).trim()}\n…（规则过长，已截断）`
+      cache.set(file, { mtimeMs: st.mtimeMs, size: st.size, text })
+      return text
+    } catch {
+      cache.delete(file)
+      return ''
+    }
+  }
+
+  function resolveSession(context) {
+    try {
+      const agent = context && context.agent
+      if (!agent) return undefined
+      if (agent.session) return agent.session
+      const sessions = ctx.sessions
+      if (sessions && typeof sessions.get === 'function') return sessions.get(agent.id)
+      return undefined
+    } catch {
+      return undefined
+    }
+  }
+
+  function isSubagentSession(session) {
+    try {
+      return Boolean(session && session.header && session.header.origin === 'subagent')
+    } catch {
+      return false
+    }
+  }
+
+  function cwdOf(session) {
+    if (!session) return ''
+    try {
+      const wd = ctx.workingDirectory
+      if (wd && typeof wd.get === 'function') {
+        const dir = wd.get(session)
+        if (typeof dir === 'string' && dir) return dir
+      }
+    } catch {
+      // fall through
+    }
+    try {
+      const cwd = session.header && session.header.cwd
+      return typeof cwd === 'string' ? cwd : ''
+    } catch {
+      return ''
+    }
+  }
+
+  function sessionIdOf(session) {
+    try {
+      return session && session.id ? String(session.id) : ''
+    } catch {
+      return ''
+    }
+  }
+
+  function sessionFile(session) {
+    const sid = sessionIdOf(session)
+    return sid ? join(cfg.sessionRulesDir, `${sid}.md`) : ''
+  }
+
+  function block(label, path, text) {
+    return [`### ${label}（${path}）`, text, ''].join('\n')
+  }
+
+  function renderContext(context) {
+    const session = resolveSession(context)
+    if (session && isSubagentSession(session) && !cfg.includeSubagents) return ''
+
+    let out = ''
+    const globalText = globalLoader.read()
+    if (globalText) out += block('全局规则', cfg.rulesFile, globalText)
+
+    if (cfg.includeWorkspaceRules) {
+      const cwd = cwdOf(session)
+      const workspacePath = resolveWorkspaceFile(cwd, cfg)
+      const workspaceText = workspacePath ? readCached(workspacePath) : ''
+      if (workspaceText) out += block('本工作区规则', workspacePath, workspaceText)
+    }
+
+    if (cfg.includeSessionRules) {
+      const file = sessionFile(session)
+      const sessionText = file ? readCached(file) : ''
+      if (sessionText) out += block('本会话规则', file, sessionText)
+    }
+
+    if (!out) return ''
+    return [
+      HEADER,
+      '以下规则来自用户的长期约定，每一步都会重新出现；与当前任务无关时也要遵守。接到新任务时先对照规则自检一遍再动手；若与用户当次明确指令冲突，以当次指令为准，并询问是否更新规则。',
+      '记录新约定用 `standing_rules` 工具：scope=global（所有会话可见）、scope=workspace（本工作区可见）、scope=session（仅本会话；删除会话时该文件会被自动清理）。',
+      '用户说“记住……”但没说范围时：通用习惯 → global；“这个会话/这次对话里” → session；“这个项目/工作区” → workspace；拿不准就先问一句“这条要全局还是只本会话？”，不要默认替用户选范围。',
+      '',
+      out,
+      '用户新提出长期约定时（“以后都…”“记住…”“别再忘…”），必须把它写进规则文件，不能只口头答应。',
+    ].join('\n')
+  }
+
+  function currentSession(exec) {
+    try {
+      const agent = exec && exec.agent
+      if (!agent) return undefined
+      if (agent.session) return agent.session
+      const sessions = ctx.sessions
+      if (sessions && typeof sessions.get === 'function') return sessions.get(agent.id)
+      return undefined
+    } catch {
+      return undefined
+    }
+  }
+
+  function fileFor(scope, exec) {
+    if (scope === 'workspace') {
+      const cwd = cwdOf(currentSession(exec))
+      if (!cwd) throw new Error('standing_rules: 无法确定当前会话的工作目录，不能用 scope=workspace')
+      return resolveWorkspaceFile(cwd, cfg)
+    }
+    if (scope === 'session') {
+      const file = sessionFile(currentSession(exec))
+      if (!file) throw new Error('standing_rules: 当前没有可用的会话，不能用 scope=session')
+      return file
+    }
+    return cfg.rulesFile
+  }
+
+  function readRules(file) {
+    try {
+      return splitRuleLines(readFileSync(file, 'utf8').replace(/^\uFEFF/, '').trim())
+    } catch {
+      return []
+    }
+  }
+
+  function safeText(file) {
+    try {
+      return readFileSync(file, 'utf8').replace(/^\uFEFF/, '').trim()
+    } catch {
+      return ''
+    }
+  }
+
+  /** 只读会话查询：优先用宿主 `sessions` 服务（活的会话），拿不到就只按 id 找会话规则文件。 */
+  let sessionLookup = () => undefined
+  try {
+    ctx.inject(['sessions'], (sessionScope) => {
+      sessionLookup = (id) => {
+        try {
+          return sessionScope.sessions.get(id)
+        } catch {
+          return undefined
+        }
+      }
+    })
+  } catch {
+    // sessions 服务不可用时保持兜底
+  }
+
+  /** 面板视图：全局规则 + 当前会话（本工作区 + 本会话）规则。 */
+  function buildViewerState(rawSessionId) {
+    const globalBlock = { path: cfg.rulesFile, exists: existsSync(cfg.rulesFile), text: safeText(cfg.rulesFile) }
+    const sid = typeof rawSessionId === 'string' && /^[A-Za-z0-9_.:-]{1,160}$/.test(rawSessionId) ? rawSessionId : ''
+    let current = null
+    if (sid) {
+      let session
+      try {
+        session = sessionLookup(sid)
+      } catch {
+        session = undefined
+      }
+      const cwd = cwdOf(session)
+      const workspaceFile = cwd ? resolveWorkspaceFile(cwd, cfg) : ''
+      const sessionFile = join(cfg.sessionRulesDir, `${sid}.md`)
+      current = {
+        sessionId: sid,
+        cwd: cwd || '',
+        workspace: workspaceFile ? { path: workspaceFile, exists: existsSync(workspaceFile), text: safeText(workspaceFile) } : null,
+        session: { path: sessionFile, exists: existsSync(sessionFile), text: safeText(sessionFile) },
+      }
+    }
+    return { ok: true, generatedAt: Date.now(), global: globalBlock, current }
+  }
+
+  // 每一步模型调用前重新注入（不随会话历史被压缩）。
+  ctx.effect(() =>
+    ctx.systemPrompt.context({
+      name: 'keyrule',
+      order: cfg.order,
+      interpolate: false,
+      text: renderContext,
+    }),
+  )
+
+  // 会话被删除时，清掉它的"本会话"规则文件，避免残留。
+  ctx.effect(() =>
+    ctx.on('session/disposed', (session) => {
+      try {
+        const sid = sessionIdOf(session)
+        if (!sid) return
+        const file = join(cfg.sessionRulesDir, `${sid}.md`)
+        if (existsSync(file)) rmSync(file, { force: true })
+      } catch {
+        // 清理失败不影响会话删除
+      }
+    }),
+  )
+
+  // 面板读取用的只读接口：GET /__dsh-keyrule/state?session=<会话id>
+  ctx.inject(['webServer'], (webScope) => {
+    webScope.effect(() =>
+      webScope.webServer.register({
+        kind: 'prefix',
+        path: '/__dsh-keyrule',
+        handler: async (req, res) => {
+          const sendJson = (status, payload) => {
+            res.statusCode = status
+            res.setHeader('content-type', 'application/json; charset=utf-8')
+            res.setHeader('cache-control', 'no-store')
+            res.end(JSON.stringify(payload))
+          }
+          try {
+            const rawUrl = String(req.url ?? '/')
+            const queryAt = rawUrl.indexOf('?')
+            const pathname = queryAt === -1 ? rawUrl : rawUrl.slice(0, queryAt)
+            let sessionId = ''
+            if (queryAt !== -1) {
+              try {
+                sessionId = new URL(rawUrl, 'http://localhost').searchParams.get('session') || ''
+              } catch {
+                sessionId = ''
+              }
+            }
+            if (pathname.endsWith('/state') && req.method === 'GET') {
+              sendJson(200, buildViewerState(sessionId))
+              return
+            }
+            if (pathname.endsWith('/secrets') && req.method === 'GET') {
+              sendJson(200, readSecrets(cfg.secretsDir))
+              return
+            }
+            sendJson(404, { ok: false, error: 'not found' })
+          } catch (error) {
+            sendJson(500, { ok: false, error: error instanceof Error ? error.message : String(error) })
+          }
+        },
+      }),
+    )
+  }, 'dsh-keyrule: viewer route')
+
+  if (cfg.enableTool) {
+    ctx.effect(() =>
+      ctx.tools.register({
+        name: 'standing_rules',
+        description:
+          `读取/增删用户的“常驻钥则”。三层文件：全局 ${cfg.rulesFile}（所有会话可见，scope=global）、` +
+          `工作区 ${cfg.workspaceRulesFile}（当前工作区可见，scope=workspace）、` +
+          `本会话 ${cfg.sessionRulesDir}\\<sessionId>.md（仅本会话，scope=session，会话删除时自动清理）。` +
+          '规则会注入每一步模型提示，不会因为会话变长或上下文压缩而丢失。' +
+          '动作：list（读取三层规则）、add（追加一条）、remove（按文本片段删除）。' +
+          '当用户说出“以后都……”“记住……”“别再忘……”这类长期要求时，必须用 add 写入文件，而不是只口头答应。',
+        parameters: {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['list', 'add', 'remove'],
+              description: 'list 读取；add 追加；remove 删除匹配的行。',
+            },
+            rule: {
+              type: 'string',
+              description: 'add / remove 时的规则文本；可以带或不带列表符号。',
+            },
+            scope: {
+              type: 'string',
+              enum: ['global', 'workspace', 'session'],
+              description: 'global=全局（默认）；workspace=当前工作区；session=仅当前会话。',
+            },
+          },
+          required: ['action'],
+          additionalProperties: false,
+        },
+        output: {
+          schema: {
+            type: 'object',
+            properties: {
+              action: { type: 'string' },
+              scope: { type: 'string' },
+              path: { type: 'string' },
+              globalPath: { type: 'string' },
+              workspacePath: { type: 'string' },
+              sessionPath: { type: 'string' },
+              rules: { type: 'array', items: { type: 'string' } },
+              added: { type: 'string' },
+              removed: { type: 'number' },
+            },
+            required: ['action'],
+          },
+          render: (_args, value) => {
+            const lines = []
+            if (value?.path) lines.push(`${value.action} → ${value.path}`)
+            if (typeof value?.added === 'string' && value.added) lines.push(`added: ${value.added}`)
+            if (typeof value?.removed === 'number') lines.push(`removed: ${value.removed} 条`)
+            if (typeof value?.globalPath === 'string') lines.push(`全局：${value.globalPath}`)
+            if (typeof value?.workspacePath === 'string') lines.push(`工作区：${value.workspacePath}`)
+            if (typeof value?.sessionPath === 'string') lines.push(`本会话：${value.sessionPath}`)
+            if (Array.isArray(value?.rules)) {
+              lines.push('', value.rules.length ? value.rules.join('\n') : '（规则文件为空）')
+            }
+            return [{ type: 'text', text: lines.join('\n') }]
+          },
+        },
+        async execute(args, exec) {
+          const action = args?.action
+          const scope = ['global', 'workspace', 'session'].includes(args?.scope) ? args.scope : 'global'
+          const ruleRaw = typeof args?.rule === 'string' ? args.rule.trim() : ''
+          const session = currentSession(exec)
+
+          if (action === 'list') {
+            const globalPath = cfg.rulesFile
+            const cwd = cwdOf(session)
+            const workspacePath = cwd ? resolveWorkspaceFile(cwd, cfg) : undefined
+            const sessionPath = sessionFile(session) || undefined
+            const rules = [
+              ...readRules(globalPath),
+              ...(workspacePath ? ['', `# ${workspacePath}`, ...readRules(workspacePath)] : []),
+              ...(sessionPath ? ['', `# ${sessionPath}`, ...readRules(sessionPath)] : []),
+            ]
+            return { action: 'list', scope, globalPath, workspacePath, sessionPath, path: globalPath, rules }
+          }
+
+          const file = fileFor(scope, exec)
+
+          if (action === 'add') {
+            if (!ruleRaw) throw new Error('standing_rules add: rule 不能为空')
+            const added = appendRule(file, ruleRaw)
+            return { action: 'add', scope, path: file, added, rules: readRules(file) }
+          }
+
+          if (action === 'remove') {
+            if (!ruleRaw) throw new Error('standing_rules remove: rule 不能为空')
+            const removed = removeRules(file, ruleRaw)
+            return { action: 'remove', scope, path: file, removed, rules: readRules(file) }
+          }
+
+          throw new Error(`standing_rules: 未知 action ${String(action)}`)
+        },
+      }),
+    )
+  }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Standing rules",
+    "description": "Re-injects the user's standing rules into the prompt on every model step so they survive long sessions and context compaction, and adds a standing_rules tool to record new ones."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "常驻钥则",
+    "description": "把用户明确说过的长期约定每步注入提示，长会话和上下文压缩后也不会忘；并提供 standing_rules 工具随时增删规则。"
+  }
+}

package/package.json

@@ -1,6 +1,51 @@
-{
-  "name": "@leiyi-works/dsh-keyrule",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+{
+  "name": "@leiyi-works/dsh-keyrule",
+  "version": "1.7.0",
+  "type": "module",
+  "description": "Keeps the user's standing rules in every model-step prompt, in three scopes (global / workspace / session), and cleans session-scoped files when the session is deleted. 常驻钥则：用户长期约定每步注入，分全局/工作区/本会话三层，删会话自动清理。",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "README.md",
+    "locale/*.json",
+    "icon.svg"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-modules",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  },
+  "license": "MIT",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-harmonyos",
+    "dsh-plugin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "leiyi-works",
+  "homepage": "https://gitee.com/leiyi-works"
 }