@zoria-lind/dsh-ecolink-adapter 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zoria Lind
+
+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,76 @@
+# dsh-ecolink-adapter
+
+dsh-ecolink 的 DSH 适配层(v1):直读本地记忆池(`~/.dsh-memory/memory.json`,只读),
+经 `agent/pre-step` 维持 DSM:memory_write 指令通道(E1),提供 `/ecolink-push` 显式写回(E4)
+与记忆 skill 按需读取(E2),打通"网页端记住 → DSH 直接用;DSH 产出 → 网页端可用"。
+
+> **v0.1.1 变更摘要(E0–E8)**:离线队列并发丢条目修复(E0,extension/core/queue.mjs);
+> 指令/内容通道分离——指令每轮幂等注入(plugin 快照消息,不改写用户消息、不碰前缀缓存),
+> 内容默认不注入、由 skill 按需 read,`contentInjectionEnabled` 为逃生舱(E1);
+> 记忆 skill `ecolink-memory` 运行时注册(E2);服务端快照/hash/diff 三端点(E3);
+> `/ecolink-push` 写回(复用 /memory/sync,source:'dsh',service 唯一写者)(E4);
+> 建议确认队列(sync 进队列、确认才入池;未确认条目不进 DSH 上下文)(E5);
+> 网页端只读面板 + chrome.alarms badge(E6);静音 + 黑名单(E7);服务默认安全(E8)。
+>
+> **v1.1(2026-09-14)**:service 自动拉起——探测到 17520 未监听就本机 spawn 拉起
+> (apply + pre-step 60s 节流;仅本地 URL;`serviceAutoStart` 默认开)。E5 设计纠正:
+> 确认点改到 DSH 侧(待实现),随仓 config.json 设 `autoConfirm: true`,网页收割直入池。
+
+## 安装(link 挂载,与 token-optimizer 同款)
+
+```bash
+dsh plugin --profile web add D:/dsh/dsh-plugins/dsh-ecolink/adapter
+```
+
+## 机制
+
+- **只读池文件**:mtime 缓存(文件变化立即重读,TTL 5s 兜底);唯一写者是 ecolink-service
+- **指令通道(E1,默认开)**:每轮 pre-step 末尾追加一条 `source.kind='plugin'` 的
+  `[dsh-ecolink 指令]` 快照消息(照抄内核 dsh-time-context 形态:prepend 注册 + await next +
+  createUserMessage;决策里的 messages 只喂本步请求、不写会话事件)。剥旧追加 → 每轮幂等不叠加
+- **内容通道(E1,默认关)**:`contentInjectionEnabled: true` 恢复旧行为——改写用户消息注入
+  记忆块(2-gram 打分 + 时间衰减 + 预算 + 长提示词缩减 + singleInjection 会话去重)
+- **`/ecolink-push`(E4)**:斜杠命令,把指定要点 POST 到 service 的 `/memory/sync`
+  (source:'dsh');token 未配置时自动读同仓 `service/config.json`;service 是唯一写者
+- **记忆 skill(E2)**:注册 `ecolink-memory`,指引模型用 read 按需读池原文(引用前必须核对)
+- **service 自动拉起(v1.1)**:apply 时与每次 pre-step(60s 节流)探测 `serviceUrl/memory/status`;
+  任何 HTTP 响应(含 401)= 已活;网络错误 = 未运行 → spawn 同仓 `service/server.mjs`
+  (detached + 无窗口)。仅对 127.0.0.1/localhost/::1 生效;service 目录缺失(独立发布包)静默跳过。
+  与登录自启任务兼容:端口已监听就不会重复起
+- **fail-open**:池不存在/读失败/任何异常 → 静默放行,绝不破坏请求
+- 只处理 `source.kind='user'` 的真实用户消息(DSH runtime-context 快照直接放行)
+
+## 配置(cordis.patch.yml)
+
+```yaml
+adapter:
+  enabled: true
+  poolPath: '~/.dsh-memory/memory.json'
+  poolTtlMs: 5000
+  injectEnabled: true            # 总开关(false = 两个通道全关)
+  singleInjection: true          # 内容通道专用(指令通道天然每轮幂等)
+  maxInjectionChars: 3000        # 内容通道注入预算
+  instructionEnabled: true       # E1 指令通道
+  contentInjectionEnabled: false # E1 内容逃生舱
+  skillName: 'ecolink-memory'    # E2 skill 注册名
+  serviceUrl: 'http://127.0.0.1:17520' # E4 写回目标
+  serviceToken: ''               # E4;留空自动读同仓 service/config.json(E8 自动生成)
+  serviceAutoStart: true         # v1.1;探测到服务未运行就自动拉起(仅本地 URL 生效)
+```
+
+## 测试
+
+```bash
+node adapter/test/smoke.mjs   # 66 项,零 API
+```
+
+## 已知限制
+
+- 会话过滤靠 `#记忆名` 显式调用;DSH CLI 的 `--resume <session>` 只接受会话 id,
+  "按命名会话自动绑定"待 DSH 提供 `--session` 能力后再做
+- 与 token-optimizer / behavior-enhancer 的联动开关(两插件中 `memory_bridge` 占位节)
+  待适配层稳定后启用
+- `inject.js` 仍是经典脚本,INSTRUCTION_PROMPT/BLOCK_RE 等与 core/*.mjs 镜像维护
+  (注释锁死);彻底消除镜像需要构建期注入(P5/0D 结论)
+- adapter npm 发布口径未解决:`src/modules/memoryInject.js` 跨目录 import `extension/core/*`,
+  npm `files` 无法引用包根之外路径(E8#5 有据缓办;Junction 挂载不受影响)

package/cordis.patch.yml

@@ -0,0 +1,19 @@
+# dsh-ecolink-adapter bundle layer:挂载适配层。
+- insert:
+    - id: ecolink-adapter
+      name: 'dsh-ecolink-adapter'
+      config:
+        adapter:
+          enabled: true
+          poolPath: '~/.dsh-memory/memory.json'
+          poolTtlMs: 5000
+          injectEnabled: true
+          singleInjection: true
+          maxInjectionChars: 3000
+          # E1 通道分离:指令每轮幂等注入;内容默认不注入(按需 read,见 skill)
+          instructionEnabled: true
+          contentInjectionEnabled: false   # 逃生舱:true 恢复旧的"改写用户消息注入记忆块"行为
+          skillName: 'ecolink-memory'      # E2 记忆 skill 注册名
+          # E4 写回:/ecolink-push 经 service 的 POST /memory/sync 落盘(唯一写者)
+          serviceUrl: 'http://127.0.0.1:17520'
+          serviceToken: ''                 # 留空自动读同仓 service/config.json 的 token(E8 自动生成)

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@zoria-lind/dsh-ecolink-adapter",
+  "version": "0.1.1",
+  "description": "dsh-ecolink DSH 适配层:直读本地记忆池、pre-step 注入(打分+预算+会话去重)、#记忆名 过滤,打通网页端记忆生态",
+  "license": "MIT",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test/smoke.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "keywords": [
+    "dsh",
+    "memory",
+    "ecolink",
+    "deepseek",
+    "dsh-plugin",
+    "deepseek-harness"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Zoria-Lind/dsh-ecolink.git",
+    "directory": "adapter"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/config.js

@@ -0,0 +1,49 @@
+// dsh-ecolink-adapter 配置。与 token-optimizer / behavior-enhancer 同款 resolveSection 模式。
+
+export const DEFAULT_CONFIG = {
+  adapter: {
+    enabled: true,
+    poolPath: '~/.dsh-memory/memory.json', // 只读;唯一写者是 ecolink-service
+    poolTtlMs: 5000,          // 池文件缓存(mtime 变化立即重读,否则 TTL 兜底)
+    injectEnabled: true,      // 总开关(false = 两个通道全关)
+    singleInjection: true,    // 内容通道专用:每 DSH 会话只注入一次(指令通道天然每轮幂等,不适用)
+    maxInjectionChars: 3000,  // 内容通道注入预算(长提示词自动缩减,与网页端同规则)
+    // E1 通道分离:指令每轮幂等注入(维持 DSM:memory_write 捕获);内容默认不再注入
+    instructionEnabled: true,       // 指令通道(pre-step 追加 plugin 快照消息)
+    contentInjectionEnabled: false, // 内容通道逃生舱(旧行为:改写用户消息注入记忆块)
+    skillName: 'ecolink-memory',    // E2 记忆 skill 的注册名(kebab-case)
+    // E4 写回:POST /memory/sync 到本机 service(service 是唯一写者,DSH 只发请求)
+    serviceUrl: 'http://127.0.0.1:17520',
+    serviceToken: '',               // 留空则自动读同仓 service/config.json 的 token(E8 自动生成)
+    serviceAutoStart: true,         // v1.1:探测到 service 未运行就自动拉起(仅本地 URL;见 serviceGuard.js)
+  },
+}
+
+const NUMERIC_KEYS = new Set(['poolTtlMs', 'maxInjectionChars'])
+
+function resolveSection(section, defaults) {
+  const out = { ...defaults }
+  if (section && typeof section === 'object') {
+    for (const [key, value] of Object.entries(section)) {
+      if (!(key in defaults)) {
+        throw new Error(`dsh-ecolink-adapter config: unknown key "${key}" (allowed: ${Object.keys(defaults).join(', ')})`)
+      }
+      if (NUMERIC_KEYS.has(key)) {
+        if (!Number.isFinite(value) || value <= 0) {
+          throw new Error(`dsh-ecolink-adapter config: ${key} (${value}) must be a positive number`)
+        }
+      } else if (typeof value !== typeof defaults[key]) {
+        throw new Error(`dsh-ecolink-adapter config: "${key}" must be ${typeof defaults[key]}`)
+      }
+      out[key] = value
+    }
+  }
+  return Object.freeze(out)
+}
+
+export function resolveConfig(config = {}) {
+  if (typeof config !== 'object' || config === null) config = {}
+  return Object.freeze({
+    adapter: resolveSection(config.adapter, DEFAULT_CONFIG.adapter),
+  })
+}

package/src/index.js

@@ -0,0 +1,77 @@
+// dsh-ecolink-adapter(E1/E2):dsh-ecolink 的 DSH 适配层。
+// 职责(PLAN §6/§8):直读 memory.json(只读,唯一写者是 ecolink-service),
+// pre-step 指令通道(每轮幂等追加 plugin 快照消息,E1)+ 可选内容注入逃生舱 +
+// 记忆 skill 运行时注册(E2:内容按需 read),与网页端记忆生态打通。
+// 与 token-optimizer / behavior-enhancer 的联动开关(memory_bridge 配置节)已
+// 在两者中占位,等适配层稳定后在各自 README 说明如何开启。
+
+import { DEFAULT_CONFIG, resolveConfig } from './config.js'
+import { createMemoryInjectModule } from './modules/memoryInject.js'
+import { createMemoryWriteModule } from './modules/memoryWrite.js'
+import { createServiceGuardModule } from './modules/serviceGuard.js'
+import { createMemoryDiffModule } from './modules/memoryDiff.js'
+
+// E2 记忆 skill 正文:指引模型按需 read 记忆池(内容不再自动注入,这里是读取入口)。
+// 引用细节前必须 read 原文核对(沿用 token-optimizer 的堵漏原则)。
+const SKILL_CONTENT = `# dsh-ecolink 跨端记忆池
+
+本机记忆池文件:\`~/.dsh-memory/memory.json\`(归档:\`~/.dsh-memory/archive.json\`)。
+网页端(chat.deepseek.com)与 DSH 共用这一份结构化池;网页端记过的事实在这里能查到。
+
+## 文件结构
+- 顶层:{ version, shared_pool: [...], session_pools: { <网页会话id>: { identity, memories: [...] } } }
+- 条目字段:id / key / content / timestamp(UTC ISO) / time_precision / source(web|dsm-import|dsh) / importance(always|called) / pinned / last_accessed
+- shared_pool 是跨会话共享记忆;session_pools 按网页会话分组,identity 是该会话的人类可读名
+
+## 何时读
+- 用户提到"我在网页端记过 / 之前说过 / 我的偏好"等跨端记忆问题时
+- 需要回忆历史偏好、项目约定、个人事实,而当前上下文没有答案时
+
+## 使用规则
+- 先运行 /ecolink-diff 命令获取记忆池自上次查看以来的新增/变化(本会话或重启后首次调用会返回全量)——多数问题只靠这个结果就能答
+- 禁止在未查询记忆池的情况下回答"不知道/不记得/没有记录":记忆池与本对话上下文是两回事,池里有而上下文没有是常态
+- 需要核对细节或完整历史时,用 read 工具读取 memory.json 原文;引用任何记忆细节前必须先读到原文,禁止凭印象回答
+- timestamp 是 UTC 存储值(例:2026-09-14T10:24Z = 本地 18:24,本机时区 UTC+8)。展示给用户时**必须先转本地时间**,再按龄降精度:2 小时内→分钟,48 小时内→小时,5 天内→日期,更早不显示时间;禁止直接把 UTC 原值当本地时间展示
+- 记忆可能过时:时间戳较旧或与当前对话矛盾时,先向用户复述该记忆并确认,不要当作当前事实直接使用
+`
+
+export function apply(ctx, config = {}) {
+  const resolved = resolveConfig(config)
+  const stats = { bump() {}, addSample() {}, dispose() {}, snapshot() { return {} } }
+  const modules = []
+  modules.push(createMemoryInjectModule(ctx, resolved.adapter, stats))
+  // E4:DSH 记忆写回(/ecolink-push 显式触发;service 是唯一写者)
+  modules.push(createMemoryWriteModule(ctx, resolved.adapter, stats))
+  // E9:记忆 diff 查看(/ecolink-diff;调用即读取事件,游标随调用推进,skill 优先走这条)
+  modules.push(createMemoryDiffModule(ctx, resolved.adapter, stats))
+  // v1.1:service 未运行时自动拉起(先探测后 spawn,已在跑就不会重复起)
+  modules.push(createServiceGuardModule(ctx, resolved.adapter, stats))
+
+  // E2:记忆 skill 运行时注册(register 返回 Cordis disposer,非 Promise;
+  // 同名重复注册是 first-wins + no-op disposer,重复挂载不会叠加)。
+  // inject 依赖缺失时本回调永不执行(插件其余部分不受影响)。
+  const skillDisposers = []
+  ctx.inject?.(['skills'], (skillCtx) => {
+    try {
+      skillDisposers.push(skillCtx.skills.register({
+        name: resolved.adapter.skillName,
+        description: '按需读取 dsh-ecolink 跨端记忆池(~/.dsh-memory/memory.json)',
+        whenToUse: '需要回忆网页端记过的偏好/事实/决策,或用户提到之前记过的内容时',
+        content: SKILL_CONTENT,
+        source: 'runtime',
+      }))
+    } catch (err) {
+      console.warn(`[dsh-ecolink-adapter] skill 注册失败(${err?.message ?? err})`)
+    }
+  })
+
+  return () => {
+    for (const cleanup of modules) cleanup()
+    for (const dispose of skillDisposers) {
+      try { dispose?.() } catch { /* noop */ }
+    }
+    stats.dispose()
+  }
+}
+
+export { DEFAULT_CONFIG, resolveConfig }

package/src/kernel.js

@@ -0,0 +1,25 @@
+// 内核模块解析(不声明为 inject 依赖,运行时经 createRequire 借道)。
+// 照抄仓库既有先例 dsh-token-optimizer/src/modules/toolTrim.js:42-58 的多锚点:
+// 插件自身位置(link 挂载时走不到 profile 依赖桥)→ DSH_ROOT →
+// DSH_HOME/.dsh 的 profiles/node_modules(CLI 安装器生成的符号链接桥)→ 全局 npm 目录。
+// 全部失败返回 undefined,调用方降级禁用对应通道,绝不抛错。
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+export function resolveKernelModule(name) {
+  const anchors = []
+  anchors.push(import.meta.url) // 插件自身位置
+  if (process.env.DSH_ROOT) anchors.push(join(process.env.DSH_ROOT, 'package.json'))
+  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  anchors.push(join(dshHome, 'profiles', 'node_modules', 'noop.js'))
+  if (process.env.APPDATA) anchors.push(join(process.env.APPDATA, 'npm', 'node_modules', 'noop.js'))
+  for (const anchor of anchors) {
+    try {
+      const req = createRequire(anchor)
+      req.resolve(name)
+      return req(name)
+    } catch { /* 下一锚点 */ }
+  }
+  return undefined
+}

package/src/modules/memoryDiff.js

@@ -0,0 +1,120 @@
+// dsh-ecolink-adapter(E9):记忆 diff 查看模块(/ecolink-diff)。
+// 动机:skill 读取路径的 token 成本——池变大后每次 read 全量都烧上下文。
+// 语义:"自上次 /ecolink-diff 调用以来"的新增/变化条目——命令调用本身就是读取事件,
+// 游标随调用推进,无需读检测;首次调用(或 DSH 重启后)返回全量。纯模块内状态,不落盘。
+// 稳定性铁律:任何异常 → kind:'error' 文案,绝不抛出打断命令管线。
+
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const COMMAND_NAME = 'ecolink-diff'
+
+function expandHome(dir) {
+  const d = String(dir ?? '')
+  if (d === '~' || d.startsWith('~/') || d.startsWith('~\\')) return join(homedir(), d.slice(2))
+  return d
+}
+
+function contentFp(text) { const s = String(text ?? ''); return s.length + ':' + s.slice(0, 40) + ':' + s.slice(-40) }
+function entryKey(e) { return e?.id ?? 'c:' + contentFp(e?.content) }
+
+export function createMemoryDiffModule(ctx, config, stats, deps = {}) {
+  if (!config?.enabled) return () => {}
+  if (!ctx || typeof ctx.inject !== 'function') return () => {}
+
+  const readFile = typeof deps.readFile === 'function' ? deps.readFile : ((p) => readFileSync(p, 'utf8'))
+  // 响应体按内容通道预算裁剪,避免超大 diff 直接灌满上下文
+  const cap = Number.isFinite(config.maxInjectionChars) ? Math.max(200, config.maxInjectionChars) : 3000
+
+  let lastSnapshot = null // Map(entryKey → content);null = 尚未建立基线(首次调用)
+
+  function flatten(pool) {
+    const out = []
+    for (const m of pool?.shared_pool ?? []) out.push(m)
+    for (const [sid, sp] of Object.entries(pool?.session_pools ?? {})) {
+      for (const m of sp?.memories ?? []) out.push({ ...m, _identity: sp?.identity })
+    }
+    // 最新在前:模型读列表时注意力集中在头部,新记忆垫底会被漏掉(2026-09-14 实测:
+    // "今晚要干嘛"的答案就在列表最后一条,模型复述时把它丢了)
+    out.sort((a, b) => String(b?.timestamp ?? '').localeCompare(String(a?.timestamp ?? '')))
+    return out
+  }
+
+  // 渲染降精度(与网页端 renderMemoryTimestamp 同规则):2h→分钟,48h→小时,5天→日期,更早不渲染
+  function renderTs(isoTs) {
+    const d = new Date(isoTs)
+    if (!Number.isFinite(d.getTime())) return null
+    const age = Math.max(0, Date.now() - d.getTime())
+    if (age > 5 * 86400e3) return null
+    const pad = (n) => String(n).padStart(2, '0')
+    const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+    if (age > 48 * 3600e3) return date
+    if (age > 2 * 3600e3) return `${date} ${pad(d.getHours())}:00`
+    return `${date} ${pad(d.getHours())}:${pad(d.getMinutes())}`
+  }
+
+  function computeDiff(entries) {
+    if (!lastSnapshot) {
+      lastSnapshot = new Map(entries.map((e) => [entryKey(e), e.content]))
+      return { first: true, items: entries }
+    }
+    const items = entries.filter((e) => !lastSnapshot.has(entryKey(e)) || lastSnapshot.get(entryKey(e)) !== e.content)
+    lastSnapshot = new Map(entries.map((e) => [entryKey(e), e.content]))
+    return { first: false, items }
+  }
+
+  function formatItems(items) {
+    const lines = []
+    let used = 0
+    for (const it of items) {
+      const content = String(it?.content ?? '')
+      const ts = it?.timestamp ? renderTs(it.timestamp) : null
+      const line = (ts ? `(${ts}) ` : '') + (it?._identity ? `[${it._identity}] ` : '') + (it?.key ? `(${it.key}) ` : '') + (content.length > 300 ? content.slice(0, 300) + '…' : content)
+      if (used + line.length + 2 > cap && lines.length > 0) {
+        lines.push(`…(共 ${items.length} 条,超出预算已截断;其余请 read 原文)`)
+        break
+      }
+      lines.push('- ' + line)
+      used += line.length + 2
+    }
+    return lines.join('\n')
+  }
+
+  const disposers = []
+  ctx.inject(['commands'], (cmdCtx) => {
+    try {
+      disposers.push(cmdCtx.commands.register({
+        name: COMMAND_NAME,
+        description: '查看 dsh-ecolink 记忆池自上次查看以来的新增/变化条目(首次调用返回全量)',
+        input: { hint: '无需输入,直接回车查看' },
+        handler: async (invocation) => {
+          try {
+            const pool = JSON.parse(readFile(expandHome(config.poolPath)))
+            const entries = flatten(pool)
+            const { first, items } = computeDiff(entries)
+            stats?.bump?.('memoryDiff.called', 1)
+            if (first) {
+              const body = formatItems(items)
+              return { kind: 'success', text: `记忆池共 ${entries.length} 条(首次调用,返回全量):\n${body || '(空池)'}` }
+            }
+            if (items.length === 0) {
+              return { kind: 'success', text: `自上次查看以来无变化(池共 ${entries.length} 条)。需要完整上下文请用 read 工具读 memory.json。` }
+            }
+            return { kind: 'success', text: `自上次查看以来新增/变化 ${items.length} 条:\n${formatItems(items)}` }
+          } catch (err) {
+            return { kind: 'error', text: `读取记忆池失败:${err?.message ?? err}(检查 poolPath 下是否存在 memory.json)` }
+          }
+        },
+      }))
+    } catch (err) {
+      console.warn(`[dsh-ecolink-adapter] /${COMMAND_NAME} 注册失败(${err?.message ?? err})`)
+    }
+  })
+
+  return () => {
+    for (const dispose of disposers) {
+      try { dispose?.() } catch { /* noop */ }
+    }
+  }
+}

package/src/modules/memoryInject.js

@@ -0,0 +1,189 @@
+// dsh-ecolink-adapter v1(E1 通道分离):记忆注入模块。
+// 与网页端扩展同源的核心逻辑(复用 ../extension/core 的选择器/提示词纯函数):
+//   - 直读 memory.json(只读,mtime 缓存——唯一写者是 ecolink-service)
+//   - 【指令通道,默认开】agent/pre-step 每轮幂等追加一条 source.kind='plugin' 的
+//     快照消息承载 [dsh-ecolink 指令] 块(照抄内核 dsh-time-context 的成熟做法:
+//     prepend 注册 + await next() + 末尾 append createUserMessage;决策里的 messages
+//     只喂本步请求、不写入会话事件)。不改写用户消息 → 不碰前缀缓存。
+//   - 【内容通道,默认关(contentInjectionEnabled 逃生舱)】旧行为:改写用户消息注入
+//     记忆块(打分 + 预算 + #记忆名 + singleInjection 会话去重)。
+//   - 块标记 [dsh-ecolink 记忆] / [dsh-ecolink 指令]:幂等剥离(DSH 每 step 重发
+//     inbox 同一消息,与网页端同款防残留逻辑)
+// 稳定性铁律:任何异常 → 静默放行,不注入。
+// 内核事实(09 §A 已核实):agent/* 事件载荷由 agentEvents() 自动 {...payload, agent} 融合
+// → pre-step 载荷直接有 payload.agent(v0 的 agent/status 跟踪 hack 据此移除)。
+
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { selectMemories, effectiveBudget, parseMemoryCommand } from '../../../extension/core/selector.mjs'
+import { buildInjectedBlock, buildInstructionBlock, stripAllBlocks } from '../../../extension/core/prompt.mjs'
+import { resolveKernelModule } from '../kernel.js'
+
+const INSTRUCTION_SUMMARY = 'ecolink-instruction'
+
+function expandHome(dir) {
+  if (typeof dir !== 'string' || dir.length === 0) return dir
+  if (dir === '~' || dir.startsWith('~/') || dir.startsWith('~\\')) return join(homedir(), dir.slice(2))
+  return dir
+}
+
+export function createMemoryInjectModule(ctx, config, stats, deps = {}) {
+  if (!config?.enabled) return () => {}
+  if (!ctx || typeof ctx.on !== 'function') return () => {}
+
+  const poolPath = expandHome(deps.poolPath ?? config.poolPath)
+
+  // createUserMessage:测试经 deps 注入假实现(显式 null = 强制禁用,模拟解析失败);
+  // 生产从 @deepseek-ai/dsh-llm 解析(失败 → 指令通道静默禁用,警告一次)
+  let createUserMessage = null
+  if (deps.createUserMessage === null) {
+    // 强制禁用路径(测试用)
+  } else if (typeof deps.createUserMessage === 'function') {
+    createUserMessage = deps.createUserMessage
+  } else {
+    const llm = resolveKernelModule('@deepseek-ai/dsh-llm')
+    if (llm && typeof llm.createUserMessage === 'function') {
+      createUserMessage = llm.createUserMessage
+    } else {
+      console.warn('[dsh-ecolink-adapter] 未能解析 @deepseek-ai/dsh-llm,指令通道禁用(记忆注入不受影响)')
+    }
+  }
+
+  // 池读取:mtime 缓存(TTL 兜底 + 文件变化立即重读);失败返回 null → 不注入
+  let poolCache = { mtimeMs: 0, at: 0, data: null }
+  function readPool() {
+    try {
+      if (!existsSync(poolPath)) return null
+      const st = statSync(poolPath)
+      const now = Date.now()
+      if (poolCache.data && st.mtimeMs === poolCache.mtimeMs && now - poolCache.at < config.poolTtlMs) {
+        return poolCache.data
+      }
+      const data = JSON.parse(readFileSync(poolPath, 'utf8'))
+      poolCache = { mtimeMs: st.mtimeMs, at: now, data }
+      return data
+    } catch {
+      return poolCache.data // 读失败:用旧缓存或 null
+    }
+  }
+
+  // 指令消息识别(幂等剥旧用:summary 唯一属于本插件的指令快照)
+  const isOwnInstruction = (m) => m?.source?.kind === 'plugin'
+    && m?.source?.plugin === 'ecolink-adapter'
+    && m?.source?.summary === INSTRUCTION_SUMMARY
+
+  // 指令快照消息(与内核 dsh-time-context 同款形状:form='snapshot' + sections)
+  // E9.1:指令块内追加"读路径"指引——旧版只教写不教读,模型不知道池可查,
+  // "你还记得吗"类问题零工具调用凭印象回答(2026-09-14 实测)。
+  // E9.2:从"建议"升级为"硬规则"——查池是回答记忆类问题的前提,查之前禁止
+  // 答"不知道/不记得"(模型常因"当前上下文没有"而诚实地说不知道,但池是另一回事)
+  const READ_HINT = '跨端记忆查询(强制规则):当用户询问或提及"之前记过什么/你还记得吗/我的偏好/日程安排/考试安排/习惯/计划"等任何可能与历史记忆有关的问题时,第一步必须先运行 /ecolink-diff 命令查询记忆池(本会话首次调用返回全量),需要细节时再用 read 工具读 ~/.dsh-memory/memory.json 核对。禁止在未查询记忆池的情况下回答"不知道/不记得/没有记录"——记忆池与本对话上下文是两回事,池里有而上下文没有是常态。'
+  function buildInstructionMessage() {
+    const text = buildInstructionBlock().replace('[/dsh-ecolink 指令]', READ_HINT + '\n[/dsh-ecolink 指令]')
+    return createUserMessage({
+      content: [{ type: 'text', text }],
+      source: { kind: 'plugin', plugin: 'ecolink-adapter', form: 'snapshot', summary: INSTRUCTION_SUMMARY, sections: [{ name: 'ecolink-instruction', text }] },
+    })
+  }
+
+  // 内容通道(E1 逃生舱):旧行为的按消息改写注入
+  function injectContentIntoMessages(messages) {
+    const sk = String(currentAgent?.session?.id ?? currentAgent?.id ?? 'default')
+    if (config.singleInjection && injectedSessions.has(sk)) return { messages, changed: false }
+
+    const pool = readPool()
+    if (!pool) return { messages, changed: false }
+    const shared = pool.shared_pool ?? []
+    const sessionPools = pool.session_pools ?? {}
+
+    const out = []
+    let changed = false
+    for (const message of messages) {
+      const srcKind = message?.source?.kind
+      if (srcKind !== undefined && srcKind !== 'user') { out.push(message); continue }
+      const content = message?.content
+      const text = typeof content === 'string' ? content
+        : Array.isArray(content) ? content.filter((b) => b?.type === 'text').map((b) => b.text).join('\n')
+        : ''
+      if (!text || text.trim().length === 0) { out.push(message); continue }
+
+      // #记忆名 显式调用 → 只注入该会话记忆;否则共享池 + 全部会话池
+      const cmd = parseMemoryCommand(text, sessionPools)
+      let items
+      let sessionName = null
+      if (cmd) {
+        const sp = sessionPools[cmd]
+        items = (sp?.memories ?? []).map((m) => ({ ...m, identity: sp?.identity }))
+        sessionName = sp?.identity
+      } else {
+        items = [
+          ...shared,
+          ...Object.entries(sessionPools).flatMap(([, sp]) => (sp?.memories ?? []).map((m) => ({ ...m, identity: sp?.identity }))),
+        ]
+      }
+      const budget = effectiveBudget(text, config.maxInjectionChars)
+      const { memories } = selectMemories(items, text, budget)
+      if (memories.length === 0) { out.push(message); continue }
+
+      const clean = stripAllBlocks(text)
+      const composed = buildInjectedBlock(memories, sessionName) + '\n\n' + clean
+      if (composed === text) { out.push(message); continue }
+      out.push({ ...message, content: typeof content === 'string' ? composed : [{ type: 'text', text: composed }] })
+      changed = true
+      stats?.bump('ecolinkAdapter.injected', 1)
+    }
+    if (changed) injectedSessions.add(sk)
+    return { messages: out, changed }
+  }
+
+  // 当前 agent(pre-step 载荷自带 agent,内核 agentEvents() 融合;保底用上次 running 状态)
+  let currentAgent
+  const onStatus = (payload) => {
+    if (payload?.status === 'running' && payload?.agent) currentAgent = payload.agent
+  }
+  ctx.on?.('agent/status', onStatus)
+
+  const injectedSessions = new Set()
+
+  const handler = async (payload, next) => {
+    const decision = await next()
+    try {
+      if (!decision || decision.kind !== 'enter') return decision
+      if (payload?.signal?.aborted) return decision
+      if (!config.injectEnabled) return decision
+      const messages = Array.isArray(decision.messages) ? decision.messages : []
+      if (messages.length === 0) return decision
+
+      currentAgent = payload?.agent ?? currentAgent
+      let out = messages
+      let changed = false
+
+      // ① 指令通道(默认开):剥旧指令快照 → 末尾追加新指令(每轮幂等,不改写用户消息)
+      if (config.instructionEnabled && createUserMessage) {
+        const kept = out.filter((m) => !isOwnInstruction(m))
+        out = [...kept, buildInstructionMessage()]
+        changed = true
+        stats?.bump('ecolinkAdapter.instructed', 1)
+      }
+
+      // ② 内容通道(默认关):改写用户消息注入记忆块
+      if (config.contentInjectionEnabled) {
+        const r = injectContentIntoMessages(out)
+        out = r.messages
+        changed = changed || r.changed
+      }
+
+      return changed ? { ...decision, messages: out } : decision
+    } catch (err) {
+      console.warn(`[dsh-ecolink-adapter] 注入失败,静默放行(${err?.message ?? err})`)
+      return decision
+    }
+  }
+
+  ctx.on('agent/pre-step', handler, { prepend: true })
+  return () => {
+    ctx.off('agent/pre-step', handler)
+    ctx.off?.('agent/status', onStatus)
+  }
+}

package/src/modules/memoryWrite.js

@@ -0,0 +1,91 @@
+// dsh-ecolink-adapter v1(E4):DSH 记忆写回模块。
+// 原则:DSH 侧只发 HTTP 请求,写盘由 ecolink-service 完成(P7 唯一写者)。
+// 端点复用既有 POST /memory/sync(07 F3 推荐①),条目带 source:'dsh',不新增端点。
+// 触发方式:斜杠命令 /ecolink-push(P6 形状)——默认不自动推送,必须显式调用。
+// token 来源:config.serviceToken 显式配置优先;为空时读取同仓 service/config.json
+// (E8 默认安全:服务启动自动生成 token 并写回该文件;浏览器读不到本地文件,不破坏鉴权边界)。
+// 稳定性铁律:任何异常 → 返回 kind:'error' 文案,绝不抛出打断命令管线。
+
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const COMMAND_NAME = 'ecolink-push'
+// 同仓服务配置(仅当 serviceToken 未显式配置时读 token 字段;每次推送热读,容忍失败)
+const SERVICE_CONFIG = join(dirname(fileURLToPath(import.meta.url)), '../../../service/config.json')
+
+function resolveServiceToken(config) {
+  if (config.serviceToken) return config.serviceToken
+  try {
+    if (existsSync(SERVICE_CONFIG)) {
+      return String(JSON.parse(readFileSync(SERVICE_CONFIG, 'utf8'))?.token ?? '')
+    }
+  } catch { /* 读不到就不带头,由服务端 401 提示 */ }
+  return ''
+}
+
+export function createMemoryWriteModule(ctx, config, stats, deps = {}) {
+  if (!config?.enabled) return () => {}
+  if (!ctx || typeof ctx.inject !== 'function') return () => {}
+
+  const fetchImpl = typeof deps.fetchImpl === 'function' ? deps.fetchImpl : ((...a) => fetch(...a))
+
+  // POST /memory/sync:响应形状 { ok, added, replaced, archived } 是现存硬依赖(07 F1)
+  async function pushMemories(contents) {
+    const base = String(config.serviceUrl ?? 'http://127.0.0.1:17520').replace(/\/$/, '')
+    const headers = { 'Content-Type': 'application/json' }
+    const token = resolveServiceToken(config)
+    if (token) headers['X-Ecolink-Token'] = token
+    const resp = await fetchImpl(`${base}/memory/sync`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ memories: contents.map((content) => ({ content, importance: 'called', source: 'dsh' })) }),
+    })
+    if (!resp.ok) {
+      const detail = await resp.text().catch(() => '')
+      throw new Error(`ecolink-service HTTP ${resp.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`)
+    }
+    return resp.json()
+  }
+
+  const disposers = []
+  ctx.inject(['commands'], (cmdCtx) => {
+    try {
+      disposers.push(cmdCtx.commands.register({
+        name: COMMAND_NAME,
+        description: '把指定要点推送到 dsh-ecolink 记忆池(网页端与 DSH 共用)',
+        input: { hint: '要记住的要点(一行一条,可多条)' },
+        handler: async (invocation) => {
+          try {
+            const raw = String(invocation?.rawInput ?? '').trim()
+            if (!raw) {
+              return { kind: 'error', text: '用法:/ecolink-push <要点>。要推送的内容不能为空,一行一条可写多条。' }
+            }
+            const contents = raw.split('\n').map((s) => s.trim()).filter(Boolean)
+            const result = await pushMemories(contents)
+            stats?.bump?.('memoryWrite.pushed', contents.length)
+            if (result?.queued) {
+              return { kind: 'success', text: `已提交 ${result.queued} 条到建议确认队列,请在网页端 popup 确认后入池。` }
+            }
+            const added = result?.added ?? 0
+            const replaced = result?.replaced ?? 0
+            if (added + replaced === 0) {
+              return { kind: 'success', text: '服务端判定无新增(与现有记忆重复),未写入。' }
+            }
+            return { kind: 'success', text: `已写入记忆池:新增 ${added} 条,覆盖 ${replaced} 条(来源标记 dsh)。` }
+          } catch (err) {
+            return { kind: 'error', text: `推送失败:${err?.message ?? err}(service 未运行会由 adapter 下一轮自动拉起;仍失败请检查 token 是否一致)` }
+          }
+        },
+      }))
+    } catch (err) {
+      console.warn(`[dsh-ecolink-adapter] /${COMMAND_NAME} 注册失败(${err?.message ?? err})`)
+    }
+  })
+
+  return () => {
+    for (const dispose of disposers) {
+      try { dispose?.() } catch { /* noop */ }
+    }
+  }
+}

package/src/modules/serviceGuard.js

@@ -0,0 +1,117 @@
+// dsh-ecolink-adapter v1.1(2026-09-14):ecolink-service 自动拉起模块。
+// 痛点:service 是网页扩展与 DSH 共享记忆池的唯一写者,但它是独立 node 进程,
+// 用户必须手动 `node service/server.mjs`。本模块让 DSH 启动时自动探测并拉起:
+// - apply 时 + 每次 agent/pre-step(60s 节流)探测 `${serviceUrl}/memory/status`;
+// - 任何 HTTP 响应(含 401)= 服务已活,绝不重复起;网络错误/超时 = 未运行 → 本机 spawn 拉起;
+// - 仅对 127.0.0.1 / localhost / ::1 生效(远程 URL 绝不 spawn);
+// - serviceAutoStart:false 或 server.mjs 不存在(独立发布包无 service 目录)时静默跳过;
+// - 与登录自启任务(scripts/install-autostart.ps1)兼容:端口已监听 → 探测即活,不会双起。
+// 稳定性铁律:全部 try/catch,任何异常最多一条 warn,绝不打断 DSH 生命周期。
+// 测试:deps 注入 fetchImpl/spawnImpl/serverPath/now,见 test/smoke.mjs「服务自动拉起」节。
+
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// 同仓 service 目录(与 memoryWrite 的 SERVICE_CONFIG 同源;独立发布包无此目录 → 跳过拉起)。
+// 两种布局都找:开发挂载(adapter 上一级的 service/)+ 独立发布包(adapter 内 service/,通常不存在)
+const HERE = dirname(fileURLToPath(import.meta.url))
+export const SERVICE_SERVER_CANDIDATES = [
+  join(HERE, '../../../service/server.mjs'),
+  join(HERE, '../../service/server.mjs'),
+]
+
+export function isLocalServiceUrl(url) {
+  try {
+    return ['127.0.0.1', 'localhost', '::1'].includes(new URL(String(url)).hostname)
+  } catch { return false }
+}
+
+export function shouldAutoStart(config) {
+  return Boolean(config?.enabled && config.serviceAutoStart && isLocalServiceUrl(config.serviceUrl))
+}
+
+export function createServiceGuardModule(ctx, config, stats, deps = {}) {
+  if (!shouldAutoStart(config)) return () => {}
+  if (!ctx || typeof ctx.on !== 'function') return () => {}
+
+  const fetchImpl = typeof deps.fetchImpl === 'function' ? deps.fetchImpl : ((...a) => fetch(...a))
+  const spawnImpl = typeof deps.spawnImpl === 'function' ? deps.spawnImpl : ((...a) => spawn(...a))
+  const serverPath = typeof deps.serverPath === 'string' ? deps.serverPath : (SERVICE_SERVER_CANDIDATES.find((p) => existsSync(p)) ?? SERVICE_SERVER_CANDIDATES[0])
+  const nowFn = typeof deps.now === 'function' ? deps.now : (() => Date.now())
+  const base = String(config.serviceUrl ?? 'http://127.0.0.1:17520').replace(/\/$/, '')
+
+  const THROTTLE_MS = 60_000
+  const READY_POLL_MS = 3_000
+  let inFlight = null
+  let lastCheck = 0
+  let warnedMissing = false
+
+  async function isAlive() {
+    try {
+      await fetchImpl(`${base}/memory/status`, { signal: AbortSignal.timeout(2000) })
+      return true // 任何 HTTP 响应(含 401)= 服务已活
+    } catch { return false } // 网络错误/超时 = 未运行
+  }
+
+  async function ensureService(reason) {
+    if (inFlight) return inFlight
+    inFlight = (async () => {
+      try {
+        if (await isAlive()) return 'already-running'
+        if (!existsSync(serverPath)) {
+          if (!warnedMissing) {
+            warnedMissing = true
+            console.warn(`[dsh-ecolink-adapter] 自动拉起跳过:${serverPath} 不存在(独立发布包无 service 目录,请手动启动服务)`)
+          }
+          return 'skipped'
+        }
+        const child = spawnImpl(process.execPath, [serverPath], {
+          detached: true,
+          stdio: 'ignore',
+          windowsHide: true,
+        })
+        child?.unref?.()
+        stats?.bump?.('serviceGuard.started')
+        // 有界就绪等待(不阻塞 DSH;未就绪也不重试,由网页端离线队列兜底)
+        const deadline = Date.now() + READY_POLL_MS
+        while (Date.now() < deadline) {
+          if (await isAlive()) {
+            console.log(`[dsh-ecolink-adapter] ecolink-service 未运行,已自动启动 (pid ${child?.pid ?? '?'}) [${reason}]`)
+            return 'started'
+          }
+          await new Promise((r) => setTimeout(r, 100))
+        }
+        console.warn(`[dsh-ecolink-adapter] ecolink-service 已启动但 ${READY_POLL_MS / 1000}s 内未就绪 (pid ${child?.pid ?? '?'})`)
+        return 'started-slow'
+      } catch (err) {
+        console.warn(`[dsh-ecolink-adapter] 自动拉起失败:${err?.message ?? err}`)
+        return 'failed'
+      } finally {
+        inFlight = null
+      }
+    })()
+    return inFlight
+  }
+
+  // apply 时探测一次(异步 fire-and-forget,不阻塞插件装配)
+  ensureService('apply').catch(() => {})
+
+  // pre-step 节流探测:服务中途被手动停止 → 下一轮请求前自动补起。
+  // ⚠ agent/pre-step 是 cordis waterfall:不调 next() 会截断整条链,决策变 undefined,
+  // 内核读 decision.kind 直接 TypeError(2026-09-14 全天 DSH 崩溃根因)。
+  // 本监听器必须原样转发 next() 结果,探测本身 fire-and-forget。
+  ctx.on('agent/pre-step', (_payload, next) => {
+    const now = nowFn()
+    if (now - lastCheck < THROTTLE_MS) return next()
+    lastCheck = now
+    ensureService('pre-step').catch(() => {})
+    return next()
+  })
+
+  // 返回 disposer 供 apply 统一清理;测试经 disposer.ensureService 显式等待
+  const dispose = () => {}
+  dispose.ensureService = ensureService
+  return dispose
+}