dsh-instruction-memory 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 huangpeiyan
+
+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,92 @@
+# dsh-instruction-memory
+
+在 DSH 设置界面中维护**长期指令记忆**：保存后自动注入此后每一轮对话的系统提示词。
+
+## 只由用户本人维护
+
+**这份记忆的内容只属于用户。** 本插件刻意**不注册任何面向模型的工具**——模型没有任何
+途径自行添加、修改或删除记忆条目。写入入口只有设置页（以及用户本人直接编辑存储文件），
+因此不会出现 AI 悄悄给用户"记下"指令的情况。
+
+条目内容由用户输入并被原样注入，本插件不对其做语义判断或自动生成。
+
+## 组成
+
+| 文件 | 作用 |
+| --- | --- |
+| `lib/index.js` | Host 半：读取/保存记忆，注册 `systemPrompt` 段落，暴露同源 JSON 路由 |
+| `lib/client.js` | Client 半：在 `settings.section` 注册「指令记忆」设置页（手写模块，无需构建） |
+| `cordis.patch.yml` | bundle patch：把 Host 行插入宿主组合 |
+| `contract-test.mjs` | 契约测试：驱动真实路由，验证两半之间的响应格式 |
+| `verify.mjs` | 装载验证：按 DSH 的方式加载两半 |
+| `smoke-test.mjs` | 注入渲染逻辑的单元测试 |
+
+## 生效方式
+
+- **始终** 条目：无条件遵守。
+- **按需** 条目：由模型按相关性自行判断是否适用，不相关时忽略；可填「适用场景」辅助判断。
+- **优先级** 高 > 普通 > 低，决定注入顺序。
+- **注入字数上限**：超出时按优先级保留，被略过的条目数会在注入文本末尾注明。
+
+条目全部停用或总开关关闭时，该提示词段落**整个注销**，系统提示词与未安装本插件时逐字节一致。
+
+## 存储
+
+记忆保存在 **DSH 数据根目录**下（设置页会显示完整绝对路径）：
+
+```
+<DSH_HOME>/instruction-memory/memory.json      # DSH_HOME 默认为 ~/.dsh
+```
+
+路径优先级与官方 `@deepseek-ai/dsh-home-paths` 一致：显式 `$DSH_HOME` → `~/.dsh`。
+**空白的 `$DSH_HOME` 视为未设置**，绝不会退回当前工作目录——否则用户换个目录启动
+DSH 就会得到第二份空记忆，看起来像"记忆消失"。
+
+> 1.0.0 之前的构建曾把数据写在宿主进程 cwd 下（`.dsh-instruction-memory.json`）。
+> 首次启动新版本时会自动迁移到上述位置，并把原文件改名为 `*.migrated` 保留。
+
+该文件可手工编辑，改完点设置页的「重新载入」即可读回。
+
+## 兼容性
+
+`dsh.compatibility.dsh` 声明为 `>=0.1.5-rc.1`。
+
+**准确说明**：本插件仅在 **dsh 0.1.5-rc.1（Windows / Node 22）** 上实测通过。
+该版本下限是"已实测"的记录，不是对更高版本兼容性的验证结论。
+
+## 发布（维护者）
+
+```sh
+# 1. 替换占位符：package.json 的 repository / homepage / bugs / author，以及 LICENSE 版权行
+# 2. 自检（prepublishOnly 也会自动跑，占位符未替换会中止发布）
+npm test
+node check-metadata.mjs
+# 3. 发布（需先 npm login）
+npm publish
+```
+
+发布前自检会拒绝在 `TODO` 占位符残留时发布，避免把空仓库地址或无名版权声明发出去。
+
+## 数据格式
+
+```json
+{
+  "version": 1,
+  "enabled": true,
+  "budgetChars": 4000,
+  "entries": [
+    {
+      "id": "im-xxxx",
+      "title": "回答语言",
+      "content": "所有回答使用简体中文。",
+      "mode": "always",
+      "when": "",
+      "priority": 1,
+      "enabled": true,
+      "updatedAt": 1700000000000
+    }
+  ]
+}
+```
+
+`mode` 为 `always` | `auto`；`priority` 为 `2` 高 / `1` 普通 / `0` 低。

package/cordis.patch.yml

@@ -0,0 +1,7 @@
+# dsh-instruction-memory bundle patch: mount the Host row under its package
+# name, resolved through the profile's node_modules. The Client half is picked
+# up automatically from the package's `dsh.client` declaration.
+
+- insert:
+    - id: instruction-memory
+      name: dsh-instruction-memory

package/lib/client.js

@@ -0,0 +1,427 @@
+/**
+ * dsh-instruction-memory — Client half.
+ *
+ * Hand-authored in the browser module-loader format the web shell expects
+ * (`window.__ModuleLoader__.load` + `require`), so the package needs no build
+ * step. Contributes one settings page; all data lives host-side and is reached
+ * through the same-origin route the Host half registers.
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-instruction-memory',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+
+    const React = require('react')
+    const h = React.createElement
+
+    const API = '/instruction-memory/api'
+
+    const CSS = `
+.im-root { display:flex; flex-direction:column; gap:16px; padding:6px 2px 56px; max-width:860px;
+  color:var(--dsw-alias-label-primary,#1f2329); font-size:13px; line-height:1.6; }
+.im-h { margin:0; font-size:14px; font-weight:600; }
+.im-sub { margin:3px 0 0; font-size:12px; color:var(--dsw-alias-label-secondary,#8a9099); }
+.im-card { display:flex; flex-direction:column; gap:11px; padding:15px; border-radius:12px;
+  border:1px solid var(--dsw-alias-border-l1,rgba(0,0,0,.1)); background:var(--dsw-alias-bg-layer-1,#fff); }
+.im-row { display:flex; align-items:center; justify-content:space-between; gap:12px; }
+.im-row-wrap { display:flex; align-items:center; gap:8px; flex-wrap:wrap; }
+.im-grid2 { display:grid; grid-template-columns:1fr 1fr; gap:10px; }
+.im-spacer { flex:1; }
+.im-btn { 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:8px; padding:5px 12px; font-size:12px; font-family:inherit; cursor:pointer; }
+.im-btn:hover:not(:disabled) { background:var(--dsw-alias-bg-layer-2,rgba(0,0,0,.05)); }
+.im-btn:disabled { opacity:.5; cursor:not-allowed; }
+.im-btn-primary { background:var(--dsw-alias-brand-primary,#3b6cff); border-color:transparent; color:#fff; }
+.im-btn-danger { color:var(--dsw-alias-state-error-primary,#d94838); }
+.im-input, .im-textarea, .im-select { width:100%; box-sizing:border-box; border-radius:8px; padding:7px 10px;
+  border:1px solid var(--dsw-alias-border-l2,rgba(0,0,0,.18)); background:var(--dsw-alias-bg-base,#fff);
+  color:inherit; font-size:13px; font-family:inherit; line-height:1.55; }
+.im-textarea { resize:vertical; min-height:92px; }
+.im-input:focus, .im-textarea:focus, .im-select:focus { outline:none; border-color:var(--dsw-alias-brand-primary,#3b6cff); }
+.im-label { display:block; margin-bottom:5px; font-size:12px; color:var(--dsw-alias-label-secondary,#8a9099); }
+.im-list { display:flex; flex-direction:column; gap:8px; }
+.im-item { display:flex; flex-direction:column; gap:6px; padding:12px 14px; border-radius:10px;
+  border:1px solid var(--dsw-alias-border-l1,rgba(0,0,0,.1)); background:var(--dsw-alias-bg-layer-1,#fff); }
+.im-item-off { opacity:.5; }
+.im-item-head { display:flex; align-items:center; gap:8px; flex-wrap:wrap; }
+.im-title { font-size:13px; font-weight:600; }
+.im-body { font-size:12px; color:var(--dsw-alias-label-secondary,#6b7280);
+  white-space:pre-wrap; word-break:break-word; max-height:96px; overflow:hidden; }
+.im-tag { padding:1px 8px; border-radius:999px; font-size:11px; white-space:nowrap;
+  border:1px solid var(--dsw-alias-border-l1,rgba(0,0,0,.14)); color:var(--dsw-alias-label-secondary,#6b7280); }
+.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-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); }
+.im-ok { font-size:12px; color:var(--dsw-alias-state-success-primary,#18a058); }
+.im-meta { font-size:11.5px; color:var(--dsw-alias-label-secondary,#8a9099); word-break:break-all; }
+.im-pre { margin:0; padding:12px 14px; border-radius:8px; font-size:11.5px; line-height:1.65;
+  background:var(--dsw-alias-bg-layer-2,rgba(0,0,0,.04)); color:var(--dsw-alias-label-secondary,#4b5563);
+  white-space:pre-wrap; word-break:break-word; max-height:340px; overflow:auto;
+  font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; }
+.im-switch { display:inline-flex; align-items:center; gap:6px; font-size:12px; cursor:pointer; user-select:none; }
+.im-switch input { width:15px; height:15px; margin:0; cursor:pointer; accent-color:var(--dsw-alias-brand-primary,#3b6cff); }
+.im-divider { height:1px; background:var(--dsw-alias-border-l1,rgba(0,0,0,.08)); }
+.im-status { display:flex; align-items:center; gap:7px; font-size:12px; }
+.im-dot { width:7px; height:7px; border-radius:50%; flex:none; background:var(--dsw-alias-label-secondary,#8a9099); }
+.im-dot-on { background:var(--dsw-alias-state-success-primary,#18a058); }
+.im-dot-off { background:var(--dsw-alias-state-warn-primary,#d97706); }
+.im-dot-err { background:var(--dsw-alias-state-error-primary,#d94838); }
+@media (max-width:640px) { .im-grid2 { grid-template-columns:1fr; } }
+`
+
+    function cloneEntry(entry) {
+      return {
+        id: entry.id,
+        title: entry.title,
+        content: entry.content,
+        mode: entry.mode,
+        when: entry.when,
+        priority: entry.priority,
+        enabled: entry.enabled,
+        updatedAt: entry.updatedAt,
+      }
+    }
+
+    function blankDraft() {
+      return { id: '', title: '', content: '', mode: 'always', when: '', priority: 1, enabled: true, updatedAt: 0 }
+    }
+
+    /**
+     * Accept both response shapes the Host can produce: the
+     * `{ ok, message, snapshot }` envelope used by the mutating methods, and a
+     * bare snapshot. Returns null only when no usable snapshot is present.
+     */
+    function normalizeResult(result) {
+      if (result === null || typeof result !== 'object') return null
+      const snapshot = result.snapshot !== undefined && result.snapshot !== null ? result.snapshot : result
+      if (snapshot === null || typeof snapshot !== 'object' || snapshot.data === undefined) return null
+      return {
+        snapshot,
+        ok: result.ok !== false,
+        message: typeof result.message === 'string' ? result.message : '',
+      }
+    }
+
+    async function callHost(method, args) {
+      const response = await fetch(API, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ method, args: args === undefined ? null : args }),
+      })
+      if (!response.ok) throw new Error('宿主返回 HTTP ' + response.status)
+      return await response.json()
+    }
+
+    function EntryEditor(props) {
+      const draft = props.draft
+      const set = (patch) => props.onChange(Object.assign(cloneEntry(draft), patch))
+      const children = [
+        h('h3', { className: 'im-h', key: 'title' }, draft.id === '' ? '新增指令' : '编辑指令'),
+        h('div', { key: 't' },
+          h('label', { className: 'im-label' }, '标题'),
+          h('input', {
+            className: 'im-input',
+            value: draft.title,
+            placeholder: '例如：回答语言',
+            onChange: (ev) => set({ title: ev.target.value }),
+          })),
+        h('div', { key: 'c' },
+          h('label', { className: 'im-label' }, '指令内容'),
+          h('textarea', {
+            className: 'im-textarea',
+            value: draft.content,
+            placeholder: '例如：所有回答使用简体中文；不确定需求时先提问再动手。',
+            onChange: (ev) => set({ content: ev.target.value }),
+          })),
+        h('div', { className: 'im-grid2', key: 'g' },
+          h('div', null,
+            h('label', { className: 'im-label' }, '生效方式'),
+            h('select', {
+              className: 'im-select',
+              value: draft.mode,
+              onChange: (ev) => set({ mode: ev.target.value }),
+            },
+              h('option', { value: 'always' }, '始终生效（无条件遵守）'),
+              h('option', { value: 'auto' }, '按需生效（按相关性自动判断）'))),
+          h('div', null,
+            h('label', { className: 'im-label' }, '优先级'),
+            h('select', {
+              className: 'im-select',
+              value: String(draft.priority),
+              onChange: (ev) => set({ priority: Number(ev.target.value) }),
+            },
+              h('option', { value: '2' }, '高'),
+              h('option', { value: '1' }, '普通'),
+              h('option', { value: '0' }, '低')))),
+      ]
+      if (draft.mode === 'auto') {
+        children.push(h('div', { key: 'w' },
+          h('label', { className: 'im-label' }, '适用场景（可选，帮助模型判断何时生效）'),
+          h('input', {
+            className: 'im-input',
+            value: draft.when,
+            placeholder: '例如：编写或修改代码时',
+            onChange: (ev) => set({ when: ev.target.value }),
+          })))
+      }
+      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 ? '保存中…' : '保存'),
+        h('button', { className: 'im-btn', disabled: props.busy, onClick: props.onCancel }, '取消'),
+        h('span', { className: 'im-spacer' }),
+        h('span', { className: 'im-meta' }, '保存后对下一轮对话立即生效')))
+      return h('div', { className: 'im-card' }, children)
+    }
+
+    function InstructionPanel() {
+      const [view, setView] = React.useState(null)
+      const [error, setError] = React.useState('')
+      const [notice, setNotice] = React.useState('')
+      const [busy, setBusy] = React.useState(false)
+      const [draft, setDraft] = React.useState(null)
+      const [budgetText, setBudgetText] = React.useState('')
+      const [showPreview, setShowPreview] = React.useState(false)
+
+      function absorb(result) {
+        const normalized = normalizeResult(result)
+        if (normalized === null) {
+          // Never fail silently: the previous version returned here, leaving the
+          // panel on its loading state forever with no error to act on.
+          setError('宿主返回了无法识别的数据')
+          return
+        }
+        setView(normalized.snapshot)
+        setBudgetText(String(normalized.snapshot.data.budgetChars))
+        if (!normalized.ok && normalized.message) {
+          setError(normalized.message)
+          setNotice('')
+        } else {
+          setError('')
+          setNotice(normalized.message)
+        }
+      }
+
+      async function send(method, args) {
+        setBusy(true)
+        try {
+          const result = await callHost(method, args)
+          absorb(result)
+          return result
+        } catch (err) {
+          setError(String(err && err.message ? err.message : err))
+          return null
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      React.useEffect(() => {
+        let alive = true
+        callHost('state', null).then(
+          (result) => { if (alive) absorb(result) },
+          (err) => { if (alive) setError(String(err && err.message ? err.message : err)) },
+        )
+        return () => { alive = false }
+      }, [])
+
+      if (view === null) {
+        return h('div', { className: 'im-root' },
+          h('div', { className: 'im-empty' }, error === '' ? '正在读取指令记忆…' : error))
+      }
+
+      if (draft !== null) {
+        return h('div', { className: 'im-root' },
+          h(EntryEditor, {
+            draft,
+            busy,
+            onChange: setDraft,
+            onCancel: () => { setDraft(null); setError('') },
+            onSave: () => {
+              if (draft.title.trim() === '' && draft.content.trim() === '') {
+                setError('请至少填写标题或指令内容')
+                return
+              }
+              send('save-entry', { entry: draft }).then((result) => {
+                if (result && result.ok === true) { setDraft(null); setError('') }
+              })
+            },
+          }))
+      }
+
+      const data = view.data
+      const storage = view.storage
+      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
+
+      const dotClass = injection.error
+        ? 'im-dot im-dot-err'
+        : (injection.registered ? 'im-dot im-dot-on' : 'im-dot im-dot-off')
+      const dotText = injection.error
+        ? injection.error
+        : (injection.registered
+          ? '已挂载到系统提示词——后续每轮对话自动生效（' + injection.chars + ' 字符）'
+          : (activeCount === 0 ? '未挂载：当前没有启用中的指令' : '未挂载'))
+
+      const header = h('div', { className: 'im-card', key: 'head' },
+        h('div', { className: 'im-row' },
+          h('div', null,
+            h('h3', { className: 'im-h' }, '指令记忆'),
+            h('p', { className: 'im-sub' }, '保存后自动写入系统提示词，对此后所有对话、问答与任务执行生效。')),
+          h('label', { className: 'im-switch' },
+            h('input', {
+              type: 'checkbox',
+              checked: data.enabled === true,
+              disabled: busy,
+              onChange: () => send('set-options', { enabled: !data.enabled }),
+            }),
+            '总开关')),
+        h('div', { className: 'im-status' },
+          h('span', { className: dotClass }),
+          h('span', { className: injection.error ? 'im-err' : 'im-meta' }, dotText)),
+        h('div', { className: 'im-grid2' },
+          h('div', null,
+            h('label', { className: 'im-label' }, '注入字数上限'),
+            h('input', {
+              className: 'im-input',
+              type: 'number',
+              min: view.limits.minBudget,
+              max: view.limits.maxBudget,
+              step: 100,
+              value: budgetText,
+              disabled: busy,
+              onChange: (ev) => setBudgetText(ev.target.value),
+              onBlur: () => {
+                const parsed = Number(budgetText)
+                if (!Number.isFinite(parsed) || parsed < view.limits.minBudget || parsed > view.limits.maxBudget) {
+                  setBudgetText(String(data.budgetChars))
+                  setError('上限需在 ' + view.limits.minBudget + ' ~ ' + view.limits.maxBudget + ' 之间')
+                  return
+                }
+                send('set-options', { budgetChars: parsed })
+              },
+            })),
+          h('div', null,
+            h('label', { className: 'im-label' }, '生效规则'),
+            h('div', { className: 'im-meta' },
+              '「始终」无条件生效；「按需」由模型按相关性自动判断。超出上限时按优先级保留，其余暂不注入。'))),
+        h('div', { className: 'im-row-wrap' },
+          h('button', {
+            className: 'im-btn im-btn-primary',
+            disabled: busy,
+            onClick: () => { setDraft(blankDraft()); setError('') },
+          }, '＋ 新增指令'),
+          h('button', { className: 'im-btn', disabled: busy, onClick: () => send('reload', null) }, '重新载入'),
+          h('button', {
+            className: 'im-btn',
+            disabled: busy,
+            onClick: () => setShowPreview(!showPreview),
+          }, showPreview ? '收起注入内容' : '查看实际注入内容'),
+          h('span', { className: 'im-spacer' }),
+          h('span', { className: 'im-meta' }, '共 ' + entries.length + ' 条，生效 ' + activeCount + ' 条')),
+        h('div', { className: 'im-divider' }),
+        h('div', { className: 'im-meta' }, '存储文件：' + (storage.path ? storage.path : '（未写入磁盘）')),
+        h('div', { className: 'im-meta' },
+          storage.savedAt ? '最近保存：' + new Date(storage.savedAt).toLocaleString() : '尚未保存到磁盘'),
+        storage.migratedFrom
+          ? h('div', { className: 'im-ok' }, '已从旧位置迁移：' + storage.migratedFrom + '（原文件保留为 *.migrated）')
+          : null,
+        error !== '' ? h('div', { className: 'im-err' }, error) : null,
+        error === '' && notice !== '' ? h('div', { className: 'im-ok' }, notice) : null,
+        error === '' && notice === '' && storage.error ? h('div', { className: 'im-err' }, storage.error) : null,
+        showPreview ? h('div', null,
+          h('label', { className: 'im-label' }, '当前注入到每轮系统提示词的内容'),
+          h('pre', { className: 'im-pre' }, view.preview === '' ? '（当前没有生效中的指令）' : view.preview)) : null)
+
+      const items = entries.map((entry) => {
+        const tags = [
+          h('span', {
+            className: 'im-tag ' + (entry.mode === 'always' ? 'im-tag-always' : 'im-tag-auto'),
+            key: 'mode',
+          }, entry.mode === 'always' ? '始终' : '按需'),
+        ]
+        if (entry.priority === 2) tags.push(h('span', { className: 'im-tag im-tag-high', key: 'p' }, '高'))
+        else if (entry.priority === 0) tags.push(h('span', { className: 'im-tag', key: 'p' }, '低'))
+        return h('div', {
+          className: 'im-item' + (entry.enabled ? '' : ' im-item-off'),
+          key: entry.id,
+        },
+          h('div', { className: 'im-item-head' },
+            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,
+                disabled: busy,
+                onChange: () => {
+                  const next = cloneEntry(entry)
+                  next.enabled = !entry.enabled
+                  send('save-entry', { entry: next })
+                },
+              }),
+              '启用'),
+            h('button', {
+              className: 'im-btn',
+              disabled: busy,
+              onClick: () => { setDraft(cloneEntry(entry)); setError('') },
+            }, '编辑'),
+            h('button', {
+              className: 'im-btn im-btn-danger',
+              disabled: busy,
+              onClick: () => send('delete-entry', { id: entry.id }),
+            }, '删除')),
+          h('div', { className: 'im-body' }, entry.content),
+          entry.mode === 'auto' && entry.when !== ''
+            ? h('div', { className: 'im-meta' }, '适用场景：' + entry.when)
+            : null)
+      })
+
+      const list = entries.length === 0
+        ? h('div', { className: 'im-empty', key: 'empty' },
+          '还没有指令记忆。点击「＋ 新增指令」添加第一条，例如“所有回答使用简体中文”。')
+        : h('div', { className: 'im-list', key: 'list' }, items)
+
+      return h('div', { className: 'im-root' }, header, list)
+    }
+
+    function apply(ctx) {
+      // `slots` is a declared injection (see exports.inject below), so the
+      // runtime holds this plugin until the slot service exists. The fallback
+      // covers a runtime that resolves injections lazily instead.
+      const slots = ctx.slots !== undefined ? ctx.slots : ctx.get('slots')
+      if (slots === undefined) {
+        console.error('[instruction-memory] slots service unavailable; settings page not registered')
+        return
+      }
+
+      // Own stylesheet: one <style> element created and removed with this fiber.
+      const styleEl = document.createElement('style')
+      styleEl.setAttribute('data-dsh-plugin', 'instruction-memory')
+      styleEl.textContent = CSS
+      document.head.appendChild(styleEl)
+      ctx.effect(() => () => {
+        if (styleEl.parentNode) styleEl.parentNode.removeChild(styleEl)
+      })
+
+      ctx.effect(() => slots.inject('settings.section', () => slots.register(
+        { name: 'settings.section', id: 'instruction-memory', order: 26, label: '指令记忆' },
+        () => h(InstructionPanel, null),
+      )))
+    }
+
+    exports.name = 'instruction-memory'
+    // Without this the runtime calls apply() immediately, before the slot
+    // service is published, and the settings page silently never registers.
+    exports.inject = ['slots']
+    exports.apply = apply
+    // Exposed for the contract test in verify.mjs.
+    exports.__normalizeResult = normalizeResult
+    return module.exports
+  },
+})

package/lib/index.js

@@ -0,0 +1,541 @@
+/**
+ * dsh-instruction-memory — Host half.
+ *
+ * Registers one ordered `systemPrompt` section holding the user's long-lived
+ * instructions, and persists them under the harness home so they survive a
+ * process restart. Also exposes a small same-origin JSON route that the Client
+ * half uses to read and edit the same store.
+ *
+ * Lifecycle: every side effect (prompt section, web route) belongs to this
+ * plugin's fiber, so unmounting the row removes all of them.
+ */
+
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export const name = 'instruction-memory'
+
+/**
+ * Hard dependencies, declared rather than probed.
+ *
+ * This row mounts early — before the web server has published — so a one-shot
+ * `ctx.get('webServer')` at apply time resolves `undefined` and the route is
+ * lost for the life of the process. Declaring it here makes Cordis hold the row
+ * until the service exists.
+ *
+ * The harness `fs` service is deliberately NOT used. Its default base is the
+ * host process cwd, which is exactly what `@deepseek-ai/dsh-home-paths` warns
+ * against: a user relaunching DSH from another directory would silently get a
+ * second, empty store. Plugin-owned data belongs under the harness home.
+ */
+export const inject = ['systemPrompt', 'webServer']
+
+const STORE_DIR_NAME = 'instruction-memory'
+const STORE_FILE_NAME = 'memory.json'
+/** Pre-release location, kept only so existing installs can migrate off it. */
+const LEGACY_FILE_NAME = '.dsh-instruction-memory.json'
+const SECTION_NAME = 'instruction-memory'
+const SECTION_ORDER = 900
+const API_PREFIX = '/instruction-memory/api'
+
+/**
+ * Resolve this plugin's data file under the harness home.
+ *
+ * Precedence mirrors `@deepseek-ai/dsh-home-paths`: an explicit `$DSH_HOME`,
+ * then `~/.dsh`. A blank override counts as unset and must never resolve to the
+ * current working directory. Exported so tests can pin it.
+ */
+export function resolveStorePath(env = process.env, home = homedir()) {
+  const configured = typeof env.DSH_HOME === 'string' ? env.DSH_HOME.trim() : ''
+  const root = configured !== '' ? configured : join(home, '.dsh')
+  return join(root, STORE_DIR_NAME, STORE_FILE_NAME)
+}
+
+const DEFAULT_BUDGET = 4000
+const MIN_BUDGET = 800
+const MAX_BUDGET = 40000
+const MAX_ENTRIES = 200
+const MAX_TITLE = 120
+const MAX_CONTENT = 6000
+const MAX_WHEN = 200
+
+/* ------------------------------------------------------------------ *
+ * Pure helpers (no ctx, fully unit-testable)
+ * ------------------------------------------------------------------ */
+
+function clampBudget(value) {
+  const n = typeof value === 'number' && Number.isFinite(value) ? Math.round(value) : DEFAULT_BUDGET
+  if (n < MIN_BUDGET) return MIN_BUDGET
+  if (n > MAX_BUDGET) return MAX_BUDGET
+  return n
+}
+
+function cleanText(value, max) {
+  if (typeof value !== 'string') return ''
+  const trimmed = value.split('\r\n').join('\n').split('\r').join('\n').trim()
+  return trimmed.length > max ? trimmed.slice(0, max) : trimmed
+}
+
+/**
+ * Collapse a value onto a single line.
+ *
+ * A title carrying newlines breaks the injected block: the header renders as
+ * several lines and the title ends up duplicating the body. This bit the
+ * auto-title path, which took the first 40 characters of multi-line content —
+ * newlines and all. The full text always survives in `content`.
+ */
+function singleLine(value, max) {
+  return cleanText(value, max)
+    .split('\n')
+    .map((part) => part.trim())
+    .filter((part) => part !== '')
+    .join(' ')
+}
+
+function makeId() {
+  return 'im-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8)
+}
+
+function priorityLabel(value) {
+  if (value === 2) return '高'
+  if (value === 0) return '低'
+  return '普通'
+}
+
+export function sanitizeEntry(raw) {
+  if (raw === null || typeof raw !== 'object') return null
+  const title = singleLine(raw.title, MAX_TITLE)
+  const content = cleanText(raw.content, MAX_CONTENT)
+  if (title === '' && content === '') return null
+  return {
+    id: typeof raw.id === 'string' && raw.id !== '' ? raw.id.slice(0, 64) : makeId(),
+    title: title === '' ? singleLine(content, 40) : title,
+    content,
+    mode: raw.mode === 'auto' ? 'auto' : 'always',
+    when: singleLine(raw.when, MAX_WHEN),
+    priority: raw.priority === 2 || raw.priority === 0 ? raw.priority : 1,
+    enabled: raw.enabled !== false,
+    updatedAt: typeof raw.updatedAt === 'number' && Number.isFinite(raw.updatedAt) ? raw.updatedAt : Date.now(),
+  }
+}
+
+function normalizeData(raw) {
+  const out = { version: 1, enabled: true, budgetChars: DEFAULT_BUDGET, entries: [] }
+  if (raw === null || typeof raw !== 'object') return out
+  if (typeof raw.enabled === 'boolean') out.enabled = raw.enabled
+  out.budgetChars = clampBudget(raw.budgetChars)
+  const list = Array.isArray(raw.entries) ? raw.entries : []
+  const seen = new Set()
+  for (const candidate of list) {
+    if (out.entries.length >= MAX_ENTRIES) break
+    const entry = sanitizeEntry(candidate)
+    if (entry === null) continue
+    if (seen.has(entry.id)) entry.id = makeId()
+    seen.add(entry.id)
+    out.entries.push(entry)
+  }
+  return out
+}
+
+function formatEntry(entry, tag) {
+  const lines = ['[' + tag + '｜优先级 ' + priorityLabel(entry.priority) + '] ' + entry.title]
+  if (entry.mode === 'auto' && entry.when !== '') lines.push('适用场景：' + entry.when)
+  lines.push(entry.content)
+  return lines.join('\n')
+}
+
+/**
+ * Render the injected block. Deliberately deterministic: identical memory
+ * produces byte-identical text on every step, so the prompt prefix stays
+ * cacheable across a session.
+ */
+export function buildBlock(data) {
+  if (data === null || typeof data !== 'object' || data.enabled !== true) return ''
+  const active = (Array.isArray(data.entries) ? data.entries : [])
+    .filter((entry) => entry.enabled === true && entry.content !== '')
+  if (active.length === 0) return ''
+  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.
+  const HEADERS = [
+    [
+      '## 用户长期指令记忆（Instruction Memory）',
+      '以下条目由用户在 DSH 设置 →「指令记忆」中长期保存，属于本次及后续所有对话的既有要求，请在回答、推理与执行任务时遵守；它们不覆盖系统与安全规则。',
+      '· [始终] 条目必须无条件遵守。',
+      '· [按需] 条目仅在与当前问题或任务相关时生效；不相关时直接忽略，不要强行套用。',
+      '· 条目之间冲突时，优先遵守优先级更高或更具体的一条；无法判断时向用户确认。',
+      '',
+    ].join('\n'),
+    [
+      '## 用户长期指令记忆（Instruction Memory）',
+      '[始终] 条目无条件遵守；[按需] 条目仅在与当前任务相关时生效。',
+      '',
+    ].join('\n'),
+    '## 用户长期指令记忆\n',
+  ]
+  const footerFor = (count) =>
+    count === 0
+      ? ''
+      : '\n\n（另有 ' + count + ' 条指令因注入字数上限未包含，可在「设置 → 指令记忆」中提高上限或调低其优先级。）'
+
+  const MIN_ROOM = 80
+  let header = HEADERS[HEADERS.length - 1]
+  for (const candidate of HEADERS) {
+    if (candidate.length + MIN_ROOM + footerFor(1).length <= budget) {
+      header = candidate
+      break
+    }
+  }
+
+  const blocks = []
+  let used = header.length
+  let omitted = 0
+
+  const consider = (entry, tag) => {
+    const block = formatEntry(entry, tag)
+    // Reserve the footer up front so a disclosure can never be squeezed out by
+    // the very entries that caused it.
+    const reserve = footerFor(omitted + 1).length
+    if (used + block.length + 2 + reserve <= budget) {
+      used += block.length + 2
+      blocks.push(block)
+      return
+    }
+    // The first entry always gets in, truncated if the budget demands it: a
+    // memory that loads and then injects nothing is worse than a short one.
+    if (blocks.length === 0) {
+      const room = budget - used - 2 - reserve
+      const note = '\n…（本条因注入字数上限被截断）'
+      if (room > note.length + 20) {
+        const body = block.slice(0, room - note.length) + note
+        blocks.push(body)
+        used += body.length + 2
+        return
+      }
+    }
+    omitted += 1
+  }
+
+  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)
+}
+
+/* ------------------------------------------------------------------ *
+ * Plugin
+ * ------------------------------------------------------------------ */
+
+export function apply(ctx) {
+  const systemPrompt = ctx.systemPrompt
+  const webServer = ctx.get('webServer')
+
+  const state = {
+    data: { version: 1, enabled: true, budgetChars: DEFAULT_BUDGET, entries: [] },
+    storagePath: null,
+    storageDisplay: null,
+    storageError: null,
+    savedAt: null,
+    migratedFrom: null,
+    sectionRegistered: false,
+    sectionError: null,
+  }
+  let sectionDispose = null
+
+  const describeError = (err) => {
+    if (err === null || err === undefined) return '未知错误'
+    if (typeof err === 'string') return err
+    if (typeof err.message === 'string' && err.message !== '') return err.message
+    return String(err)
+  }
+
+  const sectionText = () => {
+    try {
+      return buildBlock(state.data)
+    } catch (err) {
+      console.error('[instruction-memory] render failed:', err)
+      return ''
+    }
+  }
+
+  /**
+   * Keep the registered section exactly in step with the stored data: present
+   * when something must be injected, absent otherwise. An empty memory must
+   * leave the prompt byte-identical to a deployment without this plugin.
+   */
+  const syncSection = () => {
+    const wanted = sectionText() !== ''
+    if (wanted && sectionDispose === null) {
+      try {
+        sectionDispose = systemPrompt.section({ name: SECTION_NAME, order: SECTION_ORDER, text: sectionText })
+        state.sectionRegistered = true
+        state.sectionError = null
+      } catch (err) {
+        sectionDispose = null
+        state.sectionRegistered = false
+        state.sectionError = '注入注册失败：' + describeError(err)
+        console.error('[instruction-memory] section registration failed:', err)
+      }
+      return
+    }
+    if (!wanted) {
+      if (sectionDispose !== null) {
+        const dispose = sectionDispose
+        sectionDispose = null
+        try {
+          dispose()
+        } catch (err) {
+          console.error('[instruction-memory] section dispose failed:', err)
+        }
+      }
+      state.sectionRegistered = false
+      state.sectionError = null
+    }
+  }
+
+  ctx.effect(() => () => {
+    if (sectionDispose !== null) {
+      const dispose = sectionDispose
+      sectionDispose = null
+      try {
+        dispose()
+      } catch (err) {
+        console.error('[instruction-memory] cleanup failed:', err)
+      }
+    }
+  })
+
+  /* ---------------- storage ---------------- */
+
+  const storePath = resolveStorePath()
+
+  const serialize = () => JSON.stringify(state.data, null, 2) + '\n'
+
+  const writeToDisk = async () => {
+    try {
+      await mkdir(dirname(storePath), { recursive: true })
+      await writeFile(storePath, serialize(), 'utf8')
+      state.storagePath = storePath
+      state.storageDisplay = storePath
+      state.storageError = null
+      state.savedAt = Date.now()
+      return true
+    } catch (err) {
+      state.storageError = '保存失败：' + describeError(err)
+      return false
+    }
+  }
+
+  const readStoreFile = async (path) => {
+    const text = await readFile(path, 'utf8')
+    return text.trim() === '' ? null : JSON.parse(text)
+  }
+
+  const readFromDisk = async () => {
+    state.storagePath = storePath
+    state.storageDisplay = storePath
+
+    // 1. The canonical location under the harness home.
+    try {
+      const parsed = await readStoreFile(storePath)
+      if (parsed !== null) state.data = normalizeData(parsed)
+      state.storageError = null
+      return
+    } catch (err) {
+      if (err === null || err === undefined || err.code !== 'ENOENT') {
+        // A file we cannot understand must never be silently overwritten.
+        state.storageError = err instanceof SyntaxError
+          ? '配置文件解析失败（' + describeError(err) + '），原文件已保留；你下次保存时会覆盖它'
+          : '读取失败：' + describeError(err)
+        return
+      }
+    }
+
+    // 2. Migrate the pre-release location (host process cwd). This is the only
+    //    reason the legacy name is still known to this plugin.
+    const legacyPath = join(process.cwd(), LEGACY_FILE_NAME)
+    try {
+      const parsed = await readStoreFile(legacyPath)
+      if (parsed !== null) {
+        state.data = normalizeData(parsed)
+        if (await writeToDisk()) {
+          state.migratedFrom = legacyPath
+          // Keep the original as evidence instead of deleting user data.
+          await rename(legacyPath, legacyPath + '.migrated').catch(() => {})
+        }
+        return
+      }
+    } catch (err) {
+      // A missing or unreadable legacy file must never block a fresh store.
+      if (err instanceof SyntaxError) state.storageError = '旧位置文件解析失败，已忽略：' + describeError(err)
+    }
+
+    // 3. First run: materialise an empty store so the path is real and the
+    //    settings page can show it.
+    await writeToDisk()
+  }
+
+  /* ---------------- boot ---------------- */
+
+  // Load the store, then register the section if anything must be injected.
+  // Every entry point awaits this, so a request that arrives before the disk
+  // read settles can never overwrite the file with an empty in-memory state.
+  const boot = readFromDisk()
+    .catch((err) => {
+      state.storageError = '读取失败：' + describeError(err)
+    })
+    .then(() => {
+      syncSection()
+    })
+
+  /* ---------------- snapshots ---------------- */
+
+  const snapshot = () => {
+    const preview = sectionText()
+    return {
+      data: {
+        version: 1,
+        enabled: state.data.enabled === true,
+        budgetChars: clampBudget(state.data.budgetChars),
+        entries: (Array.isArray(state.data.entries) ? state.data.entries : []).map((entry) => ({ ...entry })),
+      },
+      storage: {
+        path: state.storageDisplay !== null ? state.storageDisplay : state.storagePath,
+        error: state.storageError,
+        savedAt: state.savedAt,
+        migratedFrom: state.migratedFrom,
+      },
+      injection: {
+        registered: state.sectionRegistered,
+        available: true,
+        error: state.sectionError,
+        chars: preview.length,
+      },
+      preview,
+      limits: { minBudget: MIN_BUDGET, maxBudget: MAX_BUDGET, maxEntries: MAX_ENTRIES },
+    }
+  }
+
+  const settle = (message, saved) => {
+    if (saved !== true && state.storageError !== null) {
+      return { ok: false, saved: false, message: state.storageError, snapshot: snapshot() }
+    }
+    return { ok: true, saved: saved === true, message, snapshot: snapshot() }
+  }
+
+  /* ---------------- commands (shared by route and callers) ---------------- */
+
+  const saveEntry = async (raw) => {
+    const entry = sanitizeEntry(raw)
+    if (entry === null) return { ok: false, saved: false, message: '标题与指令内容不能同时为空', snapshot: snapshot() }
+    entry.updatedAt = Date.now()
+    const list = state.data.entries
+    const index = list.findIndex((candidate) => candidate.id === entry.id)
+    if (index >= 0) list[index] = entry
+    else {
+      if (list.length >= MAX_ENTRIES) {
+        return { ok: false, saved: false, message: '最多保存 ' + MAX_ENTRIES + ' 条指令', snapshot: snapshot() }
+      }
+      list.push(entry)
+    }
+    syncSection()
+    return settle(null, await writeToDisk())
+  }
+
+  const deleteEntry = async (id) => {
+    state.data.entries = state.data.entries.filter((entry) => entry.id !== id)
+    syncSection()
+    return settle(null, await writeToDisk())
+  }
+
+  const setOptions = async (patch) => {
+    if (patch !== null && typeof patch === 'object') {
+      if (typeof patch.enabled === 'boolean') state.data.enabled = patch.enabled
+      if (typeof patch.budgetChars === 'number' && Number.isFinite(patch.budgetChars)) {
+        state.data.budgetChars = clampBudget(patch.budgetChars)
+      }
+    }
+    syncSection()
+    return settle(null, await writeToDisk())
+  }
+
+  const dispatch = async (method, args) => {
+    await boot
+    switch (method) {
+      case 'state':
+        // Same envelope as every other method. One response shape means the
+        // Client can never again be handed a payload it silently ignores.
+        return { ok: true, saved: true, message: null, snapshot: snapshot() }
+      case 'save-entry':
+        return saveEntry(args !== null && typeof args === 'object' ? args.entry : null)
+      case 'delete-entry':
+        return deleteEntry(args !== null && typeof args === 'object' && typeof args.id === 'string' ? args.id : '')
+      case 'set-options':
+        return setOptions(args)
+      case 'reload':
+        await readFromDisk()
+        syncSection()
+        return { ok: state.storageError === null, saved: true, message: state.storageError, snapshot: snapshot() }
+      default:
+        return { ok: false, saved: false, message: '未知方法：' + String(method), snapshot: snapshot() }
+    }
+  }
+
+  /* ---------------- same-origin JSON route for the Client half ---------------- */
+
+  let routeDispose = null
+  if (webServer !== undefined && typeof webServer.register === 'function') {
+    const handler = (req, res) => {
+      if (req.method !== 'POST') {
+        res.writeHead(405, { 'content-type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify({ ok: false, message: 'only POST is supported' }))
+        return
+      }
+      let body = ''
+      req.setEncoding('utf8')
+      req.on('data', (chunk) => {
+        body += chunk
+        if (body.length > 1_000_000) req.destroy()
+      })
+      req.on('end', () => {
+        void (async () => {
+          let result
+          try {
+            const payload = body === '' ? {} : JSON.parse(body)
+            result = await dispatch(payload.method, payload.args === undefined ? null : payload.args)
+          } catch (err) {
+            result = { ok: false, saved: false, message: describeError(err), snapshot: snapshot() }
+          }
+          res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+          res.end(JSON.stringify(result))
+        })()
+      })
+    }
+    try {
+      routeDispose = webServer.register({ kind: 'prefix', path: API_PREFIX, handler })
+    } catch (err) {
+      console.error('[instruction-memory] route registration failed:', err)
+      routeDispose = null
+    }
+  } else {
+    console.error('[instruction-memory] webServer unavailable: settings page will not be able to reach the host')
+  }
+
+  ctx.effect(() => () => {
+    if (routeDispose !== null) {
+      const dispose = routeDispose
+      routeDispose = null
+      try {
+        dispose()
+      } catch (err) {
+        console.error('[instruction-memory] route dispose failed:', err)
+      }
+    }
+  })
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "dsh-instruction-memory",
+  "version": "1.0.0",
+  "description": "DSH 指令记忆：在设置界面中维护可增删改的长期指令，并自动注入此后每一轮对话的系统提示词。",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "cordis",
+    "instruction-memory",
+    "system-prompt",
+    "settings"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "huangpeiyan",
+  "scripts": {
+    "test": "node smoke-test.mjs && node contract-test.mjs && node verify.mjs",
+    "prepublishOnly": "node check-metadata.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ],
+      "platform": "web"
+    },
+    "compatibility": {
+      "dsh": ">=0.1.5-rc.1"
+    }
+  }
+}