dsh-channel-memory 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuncan050115
+
+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/PERMISSIONS.md

@@ -0,0 +1,46 @@
+# PERMISSIONS — dsh-channel-memory
+
+本文件声明插件运行时实际使用的权限面。
+
+## 总览（运行时行为）
+
+- **文件系统**：只在两个目录下读写，路径由配置决定，默认都在 DSH home 内：
+  - `~/.dsh/channel-memory/`：`memory.json`（共享记忆）、`digest.json`（自动流水）。
+    写入一律「临时文件 + `rename` 原子替换」，并带 sha256 校验和。
+  - `~/.dsh/channel-workspace/`：专属工作区目录，仅在不存在时 `mkdir`。
+    插件**不读写**该目录内的任何业务文件，它只是宿主用来归属会话的工作根。
+- **宿主服务（只读调用 + 显式挂载）**：通过 `ctx.inject(['workspaceRegistry','sessions'])`
+  与 `ctx.inject(['systemPrompt'])` 获取，不使用未声明的服务。
+  - `workspaceRegistry.resolveByPath / create / get`
+  - `Workspace.attachSession(sessionId)` —— 只在宿主校验通过时成功；
+    插件不绕过、不重试、不强改归属关系。
+  - `systemPrompt.section(...)` —— 追加一个自有分节，不替换他人分节、不使用
+    `complete: true`。
+- **事件监听**：`session/created`、`session/event`（只取 `turn/end` 一类记录）。
+  回调全程 `try/catch`，任何异常都不影响会话本身。
+- **网络**：❌ 不发起任何网络请求。
+- **进程/子进程**：❌ 不 spawn 任何子进程。
+- **凭据**：❌ 不读取 `.credentials.yaml`、不读取任何 `*_API_KEY` / `*_ACCOUNT_*`，
+  不接触 DSH 凭据服务。
+
+## 明确不做
+
+- ❌ 不读取用户业务文件、项目文件、会话正文（只记 `turn/end` 的元信息与条数）。
+- ❌ 不写入工作区以外的路径；配置里给了越界路径时由操作者自己负责，插件不做二次扩散。
+- ❌ 不修改其它插件的配置或提示词分节。
+- ❌ 无 npm 生命周期脚本（`install` / `postinstall` 等一律没有）。
+- ❌ 不上传、不同步、不外发任何记忆内容；共享仅发生在同一台机器的同一份 JSON 上。
+
+## 数据可见性提示
+
+`memory.json` 是**明文**存放在用户目录下的。任何能读该目录的进程都能读到其中的内容，
+因此不要把密码、令牌、私钥等写进记忆——工具描述里也明确只用于事实/偏好/任务口径。
+
+## 依赖
+
+| 依赖 | 用途 |
+|---|---|
+| `@deepseek-ai/dsh-tools`（宿主提供） | `defineTool` 注册模型工具 |
+| `@deepseek-ai/cordis`（peer） | 插件框架类型 |
+
+无第三方运行时依赖，仅使用 `node:fs` / `node:os` / `node:path` / `node:crypto`。

package/README.md

@@ -1,3 +1,115 @@
-# Temporary Holding Version
+# dsh-channel-memory
 
-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.
+DeepSeek Harness 插件：**手机通道专属工作区** + **跨会话互通记忆**。
+
+零运行时依赖（只用 node 内置模块 + 宿主自带的 `@deepseek-ai/dsh-tools`），
+兼容 DSH `0.2.1-rc.5` / cordis `4.0.5`。
+
+## 解决什么
+
+用 wxbridge 这类手机通道时，实测到两个问题：
+
+1. **会话散落**：每从微信发一句话，桥就可能新起一条 DSH 会话，全落在默认工作区里。
+   桌面侧栏被"手机会话"淹没，也没有一个地方能把它们归档、回看。
+2. **记忆不通**：换一条会话（或桥重启）就不知道之前交代过什么。用户只能反复重述
+   身份资料、求职口径、偏好——而这些本该是一次交代、长期复用。
+
+## 做法
+
+- **专属工作区**：`~/.dsh/channel-workspace`（可配）。用宿主的
+  `workspaceRegistry.resolveByPath()` 先查，缺失才 `create()`。
+- **归属判定不自己猜**：不同宿主版本暴露会话 cwd 的方式不一样，猜错就会静默跳过一切。
+  这里改用宿主自己的不变量 —— `Workspace.attachSession()` 会校验会话 header 的 cwd
+  是否等于工作区路径，不等就抛。所以「挂载成功」本身就是权威的归属证据，
+  普通桌面会话会在 `catch` 里被安静跳过，插件绝不强行挂载绕过校验。
+- **共享记忆**：`~/.dsh/channel-memory/memory.json`，原子 rename + sha256 校验和。
+  校验和不符（文件被截断/外部改坏）时退回空库，而不是拿脏数据当记忆用。
+- **自动流水**：监听 `session/event` 的 `turn/end`，只给已确认归属的通道会话记一条，
+  用于「手机侧这段时间聊过什么」的回溯。
+- **提示词注入**：`systemPrompt.section({ name, order, text })`，`text` 传**函数**
+  （宿主按 `typeof section.text === 'function' ? section.text(context)` 求值），
+  所以写入记忆后下一轮组装自动生效，不需要手动 refresh。只追加、不替换人格。
+
+## 模型工具
+
+| 工具 | 用途 |
+|---|---|
+| `memory_write` | 记一条跨会话共享记忆（`kind`/`tags`/`pinned`） |
+| `memory_search` | 子串检索正文/标签/类别 |
+| `memory_list` | 列出最近 20 条，带 id 便于删除 |
+| `memory_forget` | 按 id 删除 |
+| `channel_workspace_info` | 工作区路径/id/已归属会话数/记忆与流水条数 |
+
+`pinned: true` 的记忆常驻提示词索引，其余按 `indexLimit`（默认 12）取最近若干条。
+
+## 安装
+
+```bash
+cd %USERPROFILE%\.dsh\profiles\desktop
+node <DSH>\resources\runtime\..\..\resources\app.asar\dsh\... # 见下
+```
+
+推荐用 DSH 插件管理器，或直接：
+
+```bash
+pnpm add dsh-channel-memory
+```
+
+然后把 bundle 名加进 `package.json` 的 `dsh.profile.bundles`：
+
+```json
+"dsh": { "profile": { "bundles": [ ..., "dsh-channel-memory" ] } }
+```
+
+重启 DSH 生效。校验（不启动 GUI，只做组合干跑）：
+
+```bash
+set ELECTRON_RUN_AS_NODE=1
+"DeepSeek Harness.exe" --expose-internals <profile>\..\..\..\app.asar\dsh\node_modules\@deepseek-ai\dsh\lib\bin.js ^
+  --profile desktop --dump-config
+```
+
+## 配置
+
+`cordis.patch.yml` 里 `channel-memory` 行的 `config` 全部可选，注释掉了默认值：
+
+```yaml
+- insert:
+    - id: channel-memory
+      name: 'dsh-channel-memory'
+      config:
+        workspacePath: 'C:/Users/you/.dsh/channel-workspace'
+        workspaceTitle: '手机通道'
+        dataDir: 'C:/Users/you/.dsh/channel-memory'
+        injectIndex: true
+        indexLimit: 12
+        autoDigest: true
+```
+
+## 与手机通道配合
+
+要让微信发起的会话真的落进这个工作区，需要**桥侧的会话 cwd 指向通道工作区**。
+wxbridge 支持在 `~/.dsh/wxbridge/config.json` 里配 `cwd`（宿主半 `pick('cwd')` →
+keeper → 桥的 `--cwd`），例如：
+
+```json
+{ "cwd": "C:/Users/wujid/.dsh/channel-workspace" }
+```
+
+配完重启桥即可。不配也不会出错——插件只是没有会话可归属，记忆与工具照常工作。
+
+## 验证
+
+`plugin/contract_test.mjs` 用**宿主自己的 `defineTool`** 跑契约测试（不是 stub）：
+value-schema DSL 违规会当场抛。夹具强制宿主不变量（cwd 不符则 `attachSession` 抛），
+因此「外来会话被拒绝挂载」是被真实验证的，而不是被假 object 允许的。
+
+```
+RESULT: PASS   （5 个工具注册、1 个提示词分节、外来会话未被挂载、post-apply 写入反映进索引）
+```
+
+权限面见 `PERMISSIONS.md`。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,22 @@
+# dsh-channel-memory — installable DSH profile bundle layer.
+#
+# The loader reads this file as `dsh.bundle.patch`, so it must exist even when
+# the plugin needs no config: an insert entry is what actually mounts the bundle
+# into the composed profile tree. `name` is the full npm package name — the
+# client-modules registry resolves the browser bundle by the loader entry name,
+# and the host resolves the package from the profile's node_modules.
+#
+# Every key below is optional; the plugin supplies its own defaults, so an
+# operator can uncomment only what they want to change. Paths are under the DSH
+# home (~/.dsh) by default and honour $DSH_HOME automatically.
+- insert:
+    - id: channel-memory
+      name: 'dsh-channel-memory'
+      config:
+        {}
+        # workspacePath: 'C:/Users/you/.dsh/channel-workspace'   # 手机通道专属工作区目录
+        # workspaceTitle: '手机通道'                              # 侧栏显示名
+        # dataDir: 'C:/Users/you/.dsh/channel-memory'            # 记忆与流水的存放目录
+        # injectIndex: true          # 是否把记忆索引追加进系统提示词（默认 true）
+        # indexLimit: 12             # 索引里最多展示多少条最近记忆
+        # autoDigest: true           # 是否为通道会话的每轮结束记一条流水（默认 true）

package/lib/index.js

@@ -0,0 +1,344 @@
+/**
+ * dsh-channel-memory — 手机通道专属工作区 + 跨会话互通记忆
+ *
+ * 解决两个实测到的问题：
+ *  1. 每次从微信发起对话都会新起一条 DSH 会话，散落在默认工作区里，桌面侧栏
+ *     被"手机会话"淹没，也无处归档。
+ *  2. 手机侧会话之间没有共享记忆：换会话或桥重启后不知道之前交代过什么。
+ *
+ * 形态说明（都按宿主 0.2.1-rc.5 的实际契约来，不凭直觉）：
+ *  - 服务依赖用 ctx.inject([...names], cb) 声明；根 ctx 上直接取不到
+ *    workspaceRegistry / systemPrompt，所以全部在注入回调里完成。
+ *  - 专属工作区：workspaceRegistry.resolveByPath() 先查，缺失才 create()。
+ *    create 对同一 realpath 幂等，但显式先查可保证"绝不改动既有 title"。
+ *  - 会话归属：attachSession() 由宿主校验 header.cwd 是否等于工作区路径，
+ *    不匹配会抛；因此只在确实属于通道时才挂，失败静默跳过，绝不伪造归属。
+ *  - 提示词注入：systemPrompt.section({ name, order, text })，text 传函数
+ *    （宿主按 `typeof section.text === 'function' ? section.text(context)` 求值），
+ *    所以记忆变化会随下次组装自动生效，不需要手动 refresh。
+ *  - 自动流水：监听 session/event 的 turn/end（payload 明确为 (session, event)），
+ *    不用 agent/turn-stopping —— 后者是 scope-filtered serial 事件，回调里
+ *    拿不到稳定的 agent 标识。
+ *  - 存储：~/.dsh/channel-memory/*.json，原子 rename + sha256 校验和；校验和
+ *    不符时退回空库而不是把脏数据当记忆用。
+ *
+ * 零运行时依赖：node 内置模块 + 宿主提供的 @deepseek-ai/dsh-tools。
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { createHash, randomUUID } from 'node:crypto'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+export const name = 'channel-memory'
+// `tools` 是每 agent 的调度服务，根 ctx 上直接读取会抛
+// "cannot get property tools without inject"。声明式 inject 才能拿到可用的
+// 服务句柄，且注册落在本插件的 fiber 上（与 modlens 等可用插件同一形态）。
+export const inject = ['tools']
+
+const NL = String.fromCharCode(10)
+const MAX_MEMORIES = 400
+const MAX_DIGESTS = 300
+const MAX_TEXT = 4000
+const SECTION_ORDER = 3200
+
+const dshHome = () => process.env.DSH_HOME || join(homedir(), '.dsh')
+const clamp = (s, n) => String(s == null ? '' : s).replace(/[\r\n]+/g, ' ').trim().slice(0, n)
+
+/** 原子写 + 校验和：坏文件绝不覆盖好文件。 */
+function writeJson(file, value) {
+  const { checksum, ...rest } = value
+  const body = JSON.stringify(rest, null, 1)
+  const tmp = file + '.tmp'
+  writeFileSync(tmp, JSON.stringify({ ...rest, checksum: createHash('sha256').update(body).digest('hex') }, null, 1) + NL, 'utf8')
+  renameSync(tmp, file)
+}
+
+function readJson(file, initial) {
+  if (!existsSync(file)) return structuredClone(initial)
+  let doc
+  try { doc = JSON.parse(readFileSync(file, 'utf8')) } catch { return structuredClone(initial) }
+  if (!doc || typeof doc !== 'object' || Array.isArray(doc)) return structuredClone(initial)
+  const { checksum, ...rest } = doc
+  if (checksum) {
+    const expect = createHash('sha256').update(JSON.stringify(rest, null, 1)).digest('hex')
+    if (expect !== checksum) return structuredClone(initial)   // 截断/外部改坏：退回空库
+  }
+  return { ...structuredClone(initial), ...rest }
+}
+
+const MEM0 = { version: 1, items: [] }
+const DIG0 = { version: 1, items: [] }
+
+export function apply(ctx, config) {
+  const cfg = {
+    workspacePath: config.workspacePath || join(dshHome(), 'channel-workspace'),
+    dataDir: config.dataDir || join(dshHome(), 'channel-memory'),
+    workspaceTitle: config.workspaceTitle || '手机通道',
+    injectIndex: config.injectIndex !== false,
+    indexLimit: Number.isInteger(config.indexLimit) && config.indexLimit > 0 ? config.indexLimit : 12,
+    autoDigest: config.autoDigest !== false,
+  }
+
+  try { mkdirSync(cfg.dataDir, { recursive: true }) } catch { /* 只读环境下仍可运行 */ }
+  const MEM_FILE = join(cfg.dataDir, 'memory.json')
+  const DIG_FILE = join(cfg.dataDir, 'digest.json')
+  const mem = readJson(MEM_FILE, MEM0)
+  const dig = readJson(DIG_FILE, DIG0)
+  if (!Array.isArray(mem.items)) mem.items = []
+  if (!Array.isArray(dig.items)) dig.items = []
+
+  const saveMem = () => { try { writeJson(MEM_FILE, { version: 1, items: mem.items.slice(-MAX_MEMORIES) }) } catch (e) { ctx.logger?.warn?.('channel-memory: save failed ' + String(e?.message).slice(0, 80)) } }
+  const saveDig = () => { try { writeJson(DIG_FILE, { version: 1, items: dig.items.slice(-MAX_DIGESTS) }) } catch { } }
+
+  const addMemory = (input) => {
+    const text = clamp(input.text, MAX_TEXT)
+    if (!text) return { ok: false, reason: 'text 为空' }
+    const item = {
+      id: randomUUID().slice(0, 8),
+      text,
+      kind: clamp(input.kind, 24) || 'note',
+      tags: (Array.isArray(input.tags) ? input.tags : []).map((t) => clamp(t, 40)).filter(Boolean).slice(0, 8),
+      pinned: input.pinned === true,
+      source: clamp(input.source, 40) || 'agent',
+      at: new Date().toISOString(),
+    }
+    mem.items.push(item)
+    saveMem()
+    return { ok: true, item, total: mem.items.length }
+  }
+
+  const search = (q, limit) => {
+    const needle = clamp(q, 200).toLowerCase()
+    const pool = mem.items.slice().reverse()
+    const hit = needle
+      ? pool.filter((m) => (m.text + ' ' + (m.tags || []).join(' ') + ' ' + m.kind).toLowerCase().includes(needle))
+      : pool
+    return hit.slice(0, Math.max(1, Math.min(Number(limit) || cfg.indexLimit, 100)))
+  }
+
+  const buildIndex = () => {
+    const pinned = mem.items.filter((m) => m.pinned)
+    const recent = mem.items.slice(-cfg.indexLimit)
+    const seen = new Set()
+    const lines = [...pinned, ...recent].filter((m) => !seen.has(m.id) && (seen.add(m.id), true))
+    if (!lines.length) return ''
+    return [
+      '<channel_memory scope="shared-across-sessions">',
+      '「手机通道」共享记忆，所有会话可读（memory_write 记录 / memory_search 检索 / memory_forget 删除）：',
+      ...lines.map((m) => `- [${m.id}]${m.pinned ? '[置顶]' : ''} (${m.kind}) ${m.text.slice(0, 220)}`),
+      '</channel_memory>',
+    ].join(NL)
+  }
+
+  // ---- 宿主服务：workspaceRegistry / sessions ----------------------------
+  // 归属判定不自己猜会话的 cwd 字段形状（不同宿主版本暴露方式不同，猜错就会
+  // 静默跳过一切）。改用宿主自己的不变量：attachSession() 会校验会话 header 的
+  // cwd 是否等于工作区路径，不等就抛。所以"尝试挂载成功"本身就是权威的归属证据。
+  const state = { workspaceId: '', workspacePath: '', reg: null }
+  const channelSessions = new Set()
+
+  ctx.inject(['workspaceRegistry', 'sessions'], (host) => {
+    const reg = host.workspaceRegistry
+    if (!reg) { ctx.logger?.warn?.('channel-memory: workspaceRegistry 不可用'); return }
+    state.reg = reg
+
+    const ensureWorkspace = async () => {
+      try {
+        if (!existsSync(cfg.workspacePath)) mkdirSync(cfg.workspacePath, { recursive: true })
+        const found = await reg.resolveByPath(cfg.workspacePath)
+        const ws = found || await reg.create(cfg.workspacePath, cfg.workspaceTitle)
+        state.workspaceId = ws.id; state.workspacePath = ws.path
+        for (const id of ws.sessionIds || []) channelSessions.add(id)   // 重启后续用
+        if (!found) ctx.logger?.info?.(`channel-memory: workspace ${ws.id} -> ${ws.path}`)
+        return ws
+      } catch (e) {
+        ctx.logger?.warn?.('channel-memory: workspace ensure failed: ' + String(e?.message ?? e).slice(0, 160))
+        return undefined
+      }
+    }
+
+    const attach = async (session) => {
+      const id = session?.id
+      if (!state.workspaceId || !id || channelSessions.has(id)) return
+      let ws
+      try { ws = reg.get(state.workspaceId) } catch { return }
+      if (!ws) return
+      try {
+        await ws.attachSession(id)          // host validates cwd === workspace path
+        channelSessions.add(id)
+        ctx.logger?.info?.(`channel-memory: attached ${String(id).slice(0, 12)}`)
+      } catch {
+        // 普通桌面会话会在这里被宿主拒绝——这是预期路径，不是错误，
+        // 所以保持静默，绝不强行挂载绕过宿主校验。
+      }
+    }
+
+    ctx.effect(async () => { await ensureWorkspace() })
+
+    ctx.on('session/created', (session) => { Promise.resolve(attach(session)).catch(() => { }) })
+
+    // 自动流水：只记已确认归属的通道会话的 turn/end。
+    if (cfg.autoDigest) {
+      ctx.on('session/event', (session, event) => {
+        try {
+          if (!event || event.type !== 'turn/end') return
+          if (!channelSessions.has(session?.id)) return
+          dig.items.push({
+            id: randomUUID().slice(0, 8),
+            session: clamp(session?.id, 60),
+            reason: clamp(event?.data?.reason?.kind ?? event?.data?.reason, 24),
+            at: new Date().toISOString(),
+          })
+          saveDig()
+        } catch { /* 流水失败绝不影响会话本身 */ }
+      })
+    }
+  })
+
+  // ---- 提示词注入 --------------------------------------------------------
+  if (cfg.injectIndex) {
+    ctx.inject(['systemPrompt'], (host) => {
+      const sp = host.systemPrompt
+      if (!sp || typeof sp.section !== 'function') { ctx.logger?.warn?.('channel-memory: systemPrompt 不可用'); return }
+      try {
+        sp.section({ name: 'channel-memory:index', order: SECTION_ORDER, text: buildIndex })
+      } catch (e) {
+        ctx.logger?.warn?.('channel-memory: section failed: ' + String(e?.message ?? e).slice(0, 140))
+      }
+    })
+  }
+
+  // ---- 模型工具 ----------------------------------------------------------
+  // output.schema 是"值节点"：只写 type/properties/additionalProperties，
+  // 不写 required（该 DSL 里 required 只在参数槽位合法，写进 output.schema 会被拒）。
+  const OUT = (extra = {}) => ({
+    schema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: { ok: { type: 'boolean' }, result: { type: 'string' }, ...extra },
+    },
+    render: (_args, value) => [{ type: 'text', text: String(value?.result ?? '') }],
+  })
+
+  const tools = [
+    {
+      name: 'memory_write',
+      description:
+        '写入一条跨会话共享记忆（手机通道与桌面端都能读到）。用于用户明确交代、以后还要用的事实：' +
+        '身份资料、求职口径、偏好、正在推进的事项与结论。不要记一次性闲聊或能从文件读到的内容。' +
+        'pinned=true 会常驻提示词索引。',
+      parameters: {
+        text: { type: 'string', required: true, description: '记忆正文，一条只说一件事，≤4000 字。' },
+        kind: { type: 'string', description: '类别：fact / pref / task / decision / contact。默认 note。' },
+        tags: { type: 'array', items: { type: 'string' }, description: '可选标签，最多 8 个。' },
+        pinned: { type: 'boolean', description: '是否置顶进提示词索引。' },
+      },
+      execute: async (args) => {
+        const r = addMemory({ ...args, source: 'tool' })
+        return { ok: r.ok, result: r.ok ? `已记录 [${r.item.id}]（共 ${r.total} 条）` : `✗ ${r.reason}` }
+      },
+    },
+    {
+      name: 'memory_search',
+      description: '在共享记忆里检索（子串匹配正文/标签/类别）。不传 query 返回最近若干条。',
+      parameters: {
+        query: { type: 'string', description: '检索词，中文可用。' },
+        limit: { type: 'integer', description: '最多返回几条，默认 12。' },
+      },
+      execute: async (args) => {
+        const hits = search(args.query, args.limit)
+        if (!hits.length) return { ok: true, result: '（无匹配记忆）' }
+        return { ok: true, result: hits.map((m) => `[${m.id}] (${m.kind})${m.pinned ? '[置顶]' : ''} ${m.text}`).join(NL) }
+      },
+    },
+    {
+      name: 'memory_list',
+      description: '列出共享记忆（最近 20 条，带 id 便于删除）。',
+      parameters: {
+        include_digests: { type: 'boolean', description: '是否一并给出自动流水条数（默认否）。' },
+      },
+      execute: async (args) => {
+        const lines = mem.items.slice(-20).map((m) => `[${m.id}] (${m.kind})${m.pinned ? '[置顶]' : ''} ${m.text.slice(0, 160)}`)
+        let out = `共享记忆 ${mem.items.length} 条（显示最近 ${lines.length}）：` + NL + (lines.join(NL) || '（空）')
+        if (args.include_digests) out += NL + `自动流水 ${dig.items.length} 条。`
+        return { ok: true, result: out }
+      },
+    },
+    {
+      name: 'memory_forget',
+      description: '按 id 删除一条共享记忆。id 来自 memory_search / memory_list。',
+      parameters: { id: { type: 'string', required: true, description: '记忆 id，如 a1b2c3d4。' } },
+      execute: async (args) => {
+        const id = clamp(args.id, 20)
+        const before = mem.items.length
+        mem.items = mem.items.filter((m) => m.id !== id)
+        if (mem.items.length === before) return { ok: false, result: `✗ 未找到 [${id}]` }
+        saveMem()
+        return { ok: true, result: `已删除 [${id}]，剩余 ${mem.items.length} 条` }
+      },
+    },
+    {
+      name: 'channel_workspace_info',
+      description: '查看「手机通道」专属工作区状态：路径、id、已归属会话数、记忆与流水条数。',
+      parameters: {},
+      execute: async () => {
+        let count = 0
+        try {
+          const ws = state.reg?.get?.(state.workspaceId)
+          count = (ws?.sessionIds || []).length
+        } catch { }
+        return {
+          ok: Boolean(state.workspaceId),
+          result: [
+            `工作区 id : ${state.workspaceId || '(未就绪)'}`,
+            `路径      : ${state.workspacePath || cfg.workspacePath}`,
+            `已归属会话: ${count}`,
+            `共享记忆  : ${mem.items.length} 条（置顶 ${mem.items.filter((m) => m.pinned).length}）`,
+            `自动流水  : ${dig.items.length} 条`,
+            `数据目录  : ${cfg.dataDir}`,
+          ].join(NL),
+        }
+      },
+    },
+  ]
+
+  const diag = { toolsService: 'ok', defineTool: typeof defineTool, errors: [], registered: [] }
+  const registerAll = (toolsSvc) => {
+    if (!toolsSvc || typeof toolsSvc.register !== 'function') { diag.toolsService = 'unavailable'; return }
+    for (const t of tools) {
+      try {
+        toolsSvc.register(defineTool({ ...t, output: OUT() }))
+        diag.registered.push(t.name)
+      } catch (e) {
+        const msg = `${t.name}: ` + String(e?.message ?? e).slice(0, 160)
+        diag.errors.push(msg)
+        ctx.logger?.warn?.(`channel-memory: tool ${msg}`)
+      }
+    }
+  }
+
+  // inject 声明保证了 ctx.tools 可用；注册同步完成后才落快照，
+  // 不会再出现 "toolsService absent / registered 0" 的时序假象。
+  registerAll(ctx.tools)
+
+  // Observability: without this, a silent registration failure is indistinguishable
+  // from "plugin not installed" when looking at the profile from the outside.
+  // Tool registration is synchronous above, but the workspace is created by an
+  // async effect, so a single snapshot here always shows workspace:null. Re-write
+  // after the effect has had time to land, otherwise the file contradicts
+  // channel_workspace_info and looks like a mount failure.
+  const writeStatus = () => {
+    try {
+      writeJson(join(cfg.dataDir, 'status.json'), {
+        version: 1, at: new Date().toISOString(), registered: diag.registered.length, total: tools.length,
+        diag, workspace: state.workspaceId || null, memories: mem.items.length,
+      })
+    } catch { }
+  }
+  writeStatus()
+  setTimeout(writeStatus, 2000)
+  setTimeout(writeStatus, 10000)
+
+  ctx.logger?.info?.(`channel-memory ready: tools=${diag.registered.length}/${tools.length} memories=${mem.items.length} ws=${cfg.workspacePath}`)
+}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "dsh-channel-memory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "微信通道专属工作区 + 跨会话互通记忆：把手机发起的 DSH 会话归到一个独立工作区，并让所有会话共享一份可检索的长期记忆。",
+  "license": "MIT",
+  "type": "module",
+  "main": "./lib/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Yuncan050115/dsh-channel-memory.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Yuncan050115/dsh-channel-memory/issues"
+  },
+  "homepage": "https://github.com/Yuncan050115/dsh-channel-memory#readme",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "PERMISSIONS.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-tools": ">=0.2.1-rc.5"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "wechat",
+    "memory",
+    "workspace"
+  ]
+}