@yolk_vat-y/dsh-project-memory 0.5.7 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "Persistent project memory for dsh agents: index docs (PDF/Markdown/text) and code symbols into a searchable per-workspace store, recall them with cited sources, and keep experience entries (problems -> solutions) searchable on demand.",
   "type": "module",
   "main": "src/index.js",
@@ -18,7 +18,7 @@
     "url": "https://github.com/00080000/dsh-project-memory.git"
   },
   "scripts": {
-    "test": "node test/run-test.mjs && node test/taskbridge.test.mjs && node test/insight-store.test.mjs && node test/reflection-pipeline.test.mjs && node test/auto-inject.test.mjs && node test/insight-actions.test.mjs && node test/host-contract.test.mjs && node test/llm-route.test.mjs && node test/doc-index.test.mjs && node test/client-hints.test.mjs && node test/recall.test.mjs && node test/readiness.test.mjs && node test/insight-derive.test.mjs && node test/readiness-eval.test.mjs && node test/ops.test.mjs && node test/injection-audit.test.mjs && node test/injection-budget.test.mjs && node test/injection-scenarios.test.mjs && node test/bugfix-0.5.7.test.mjs",
+    "test": "node test/run-test.mjs && node test/taskbridge.test.mjs && node test/insight-store.test.mjs && node test/reflection-pipeline.test.mjs && node test/auto-inject.test.mjs && node test/insight-actions.test.mjs && node test/host-contract.test.mjs && node test/llm-route.test.mjs && node test/doc-index.test.mjs && node test/client-hints.test.mjs && node test/recall.test.mjs && node test/readiness.test.mjs && node test/insight-derive.test.mjs && node test/readiness-eval.test.mjs && node test/ops.test.mjs && node test/injection-audit.test.mjs && node test/injection-budget.test.mjs && node test/injection-scenarios.test.mjs && node test/bugfix-0.5.7.test.mjs && node test/client-icons.test.mjs && node test/client-slash.test.mjs && node test/workflow-command.test.mjs && node test/client-session-id.test.mjs",
     "eval:injection": "node test/injection-scenarios.test.mjs",
     "selfcheck:triggers": "node test/injection-scenarios.test.mjs --selfcheck",
     "bench": "node scripts/bench.mjs",
@@ -92,10 +92,7 @@
     },
     "client": {
       "inject": [
-        "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-client-ui-primitives",
-        "@deepseek-ai/dsh-client-ui-slots",
-        "@deepseek-ai/dsh-client-store"
+        "@deepseek-ai/dsh-client-locale"
       ],
       "platform": "web"
     }

package/src/audit.js

@@ -14,6 +14,12 @@ import path from 'node:path'
 export const AUDIT_FILE = 'injection-audit.jsonl'
 const DEFAULT_MAX_BYTES = 256 * 1024
 
+// 影子记录：与主审计**分开一个文件**。主审计只记"真的注入了"的步，静默步（包括对照组那种
+// "本该零注入"的步）完全不落痕，于是日志回答不了"换个阈值/换个判据会怎样"。影子记录每步都写，
+// 带全部候选的特征与判据结果，用来 (a) 离线重放任一阈值、(b) 攒"特征 → 该不该注入"的训练样本。
+export const SHADOW_FILE = 'admission-shadow.jsonl'
+const DEFAULT_SHADOW_MAX_BYTES = 2 * 1024 * 1024
+
 /** 审计配置：默认开（观测是这个插件唯一的仪表盘），显式 `auditLog: false` 才关。 */
 export function cfgAudit(config) {
   const c = (config && config.autoContext) || {}
@@ -27,6 +33,63 @@ export function auditFileFor(memoryDir) {
   return path.join(memoryDir, AUDIT_FILE)
 }
 
+/** 影子记录配置：默认开（它只写盘、不进 prompt、不花 token），显式 `shadowLog: false` 才关。 */
+export function cfgShadow(config) {
+  const c = (config && config.autoContext) || {}
+  return {
+    enabled: c.shadowLog !== false,
+    maxBytes: typeof c.shadowMaxBytes === 'number' && c.shadowMaxBytes > 0 ? c.shadowMaxBytes : DEFAULT_SHADOW_MAX_BYTES,
+  }
+}
+
+export function shadowFileFor(memoryDir) {
+  return path.join(memoryDir, SHADOW_FILE)
+}
+
+/**
+ * 一步的影子记录（纯函数，可单测）。与主审计的差别只有两点，但都是关键：
+ *  - **每步都写**（含零注入的静默步与对照组），所以"没注入"也留下了可复盘的事实；
+ *  - 带**全部候选**的判据特征（cov/matched/support/relative）与场景（query/ops/writes），
+ *    所以能离线回答"阈值换成 0.40 会注入什么"、并攒出"特征 → 该不该注入"的样本。
+ * @param {object} input { sessionId, root, step, query, ops, writes, reasons, candidates, silence }
+ */
+export function shadowRecordFrom(input) {
+  const reasons = Array.isArray(input.reasons) ? input.reasons : []
+  const candidates = Array.isArray(input.candidates) ? input.candidates : []
+  return {
+    at: new Date().toISOString(),
+    session: input.sessionId || null,
+    root: input.root || null,
+    step: typeof input.step === 'number' ? input.step : null,
+    // 人类消息截断保存：没有它就判不了"这次注入该不该"——标签要能回放到当时的场景。
+    query: typeof input.query === 'string' ? input.query.slice(0, 300) : '',
+    ops: (Array.isArray(input.ops) ? input.ops : []).slice(0, 12),
+    writes: (Array.isArray(input.writes) ? input.writes : []).slice(0, 12),
+    injected: reasons.map((r) => ({ id: r.id, channel: r.channel, why: r.why })),
+    candidates,
+    silence: input.silence || null,
+  }
+}
+
+/**
+ * 追加一行影子记录。返回是否写入成功（仅供测试断言）。与主审计同约定：任何异常一律吞掉，
+ * 绝不影响宿主请求。
+ */
+export function appendShadowAudit(memoryDir, record, cfg) {
+  const c = cfg || {}
+  if (c.enabled === false) return false
+  if (!memoryDir || !record) return false
+  try {
+    mkdirSync(memoryDir, { recursive: true })
+    const file = shadowFileFor(memoryDir)
+    rotateIfOversized(file, c.maxBytes || DEFAULT_SHADOW_MAX_BYTES)
+    appendFileSync(file, `${JSON.stringify(record)}\n`)
+    return true
+  } catch {
+    return false
+  }
+}
+
 /**
  * 一次注入的审计记录（纯函数，可单测）。字段刻意保持"能直接回答两个问题"：
  * 注入了什么（injected）、为什么没注入别的（dropped）。

package/src/auto-inject.js

@@ -11,16 +11,47 @@ import { ProjectMemoryStore } from './store.js'
 import { memoryRootFor } from './util/fs.js'
 import { insightMatchText, normalizedTokenOverlap } from './similarity.js'
 import { BoundedMap, SessionCache } from './util/session-cache.js'
-import { cfgInsight, GlobalStore, defaultGlobalFile } from './insight-store.js'
+import { cfgInsight, GlobalStore, defaultGlobalFile, recordHit } from './insight-store.js'
 import { projectTags } from './project-profile.js'
 import { rankEntriesMergedScored } from './util/search.js'
 import { insightToEntry, insightScoringText } from './recall.js'
 import { buildReadinessContext, hintQueryText, idfCoverage, matchTrigger, normalizeTrigger, relativeHits } from './readiness.js'
 import { activityFromCalls } from './ops.js'
-import { appendInjectionAudit, auditRecordFrom, cfgAudit } from './audit.js'
+import { appendInjectionAudit, appendShadowAudit, auditRecordFrom, cfgAudit, cfgShadow, shadowRecordFrom } from './audit.js'
 
 export const INJECT_MARK = '[Memory Inject]'
 
+/**
+ * 本插件在 `message.source` 上声明的生产者 kind。
+ *
+ * 会话格式 v4 起 `MessageSourceMap` 是「每个生产者声明自己的 kind」的可合并联合类型，
+ * **没有** `plugin` 这个兜底 kind：宿主的 `assertV4MessageSources` / `assertV4SourceRowAdmission`
+ * 会直接拒绝 `kind === 'plugin'` 的消息（`session-format-v3-to-v4/src/message-sources.ts`），
+ * 而拒绝发生在编码落盘那一刻 —— 于是整轮运行失败。
+ *
+ * 值选 `plugin:<包名>` 是因为这正是宿主自己的 v3→v4 迁移对本插件历史消息的改写结果
+ * （`rewritePluginSource`：第三方插件 → `plugin:${plugin}`，并丢弃 `plugin` 字段）。
+ * 新写的消息与迁移后的旧消息因此是**同一个生产者身份**，自激闸门（见 isOwnInjection）不需要按新旧分叉。
+ */
+export const SOURCE_KIND = 'plugin:dsh-project-memory'
+
+/**
+ * 这条消息是不是本插件自己注入的？
+ *
+ * 三种写法都要认，因为同一条历史消息在不同阶段形状不同：
+ *   - `plugin:dsh-project-memory` —— 现在写的，也是 v3→v4 迁移改写老消息的结果；
+ *   - `project-memory` —— 保留的别名：将来若再换 kind，自激闸门不会因此失效；
+ *   - `plugin: 'dsh-project-memory'` —— 迁移前内存里尚未落盘的旧形状（老宿主 / 测试夹具）。
+ * @param {object|undefined|null} source - message.source
+ * @returns {boolean}
+ */
+export function isOwnInjection(source) {
+  if (!source || typeof source !== 'object') return false
+  return source.kind === SOURCE_KIND
+    || source.kind === 'project-memory'
+    || source.plugin === 'dsh-project-memory'
+}
+
 /**
  * 注入正文的最小可用长度：预算塞不下这么多就宁可不注入（记 dropped）。
  * 与其输出 `- [ins_xxx] procedure ` 这种 stub，不如保持沉默——stub 只消耗 token 不传递信息。
@@ -67,9 +98,13 @@ export function cfgEngine(config) {
     // 每会话条目注入的上限（条数 / 字符）：预算只能是上限，不是目标。
     maxItemsPerSession: typeof c.maxItemsPerSession === 'number' && c.maxItemsPerSession >= 0 ? c.maxItemsPerSession : 12,
     maxItemCharsPerSession: typeof c.maxItemCharsPerSession === 'number' && c.maxItemCharsPerSession >= 0 ? c.maxItemCharsPerSession : 4000,
-    // 提示通道的**绝对**下限（IDF 加权覆盖率）：相对阈值分不出"有信号"和"矮子里拔将军"。
-    // null = 关闭（回到只有相对阈值的老行为）。
-    hintMinCoverage: typeof c.hintMinCoverage === 'number' && c.hintMinCoverage >= 0 ? c.hintMinCoverage : 0.3,
+    // 提示通道的**绝对**覆盖底线（IDF 加权覆盖率）：相对阈值分不出"有信号"和"矮子里拔将军"，
+    // 只有归一在 [0,1]、有真零点才谈得上下限。0.30 时的实测反例：真实 store（43 条同源洞察）上，
+    // 对照组场景「改 pptx 时间戳」以 cov 0.32~0.35 注入了 3 条无关条目——语料同源时共享词多、
+    // IDF 分辨力被拉平，"最不坏的一条"就能过 0.30。0.45 落在实测分布的空隙里（假阳性 ≤0.35、
+    // 下一个真命中 ≥0.49），合成标注集在 0.6 以前 precision/recall 也仍是 1.00。
+    // 用 `--hint-cov` 在真实 store 上重放可复核（见 test/injection-scenarios.test.mjs）。
+    hintMinCoverage: typeof c.hintMinCoverage === 'number' && c.hintMinCoverage >= 0 ? c.hintMinCoverage : 0.45,
     // 提示通道还要求至少这么多个共同词：单个通用词（"插件"）也能拿到 coverage=1.00。
     hintMinMatched: typeof c.hintMinMatched === 'number' && c.hintMinMatched >= 0 ? c.hintMinMatched : 2,
     // 通道级沉默：查询里能在语料中找到对应的词占比低于这个值时，整条提示通道本轮不出声。
@@ -98,8 +133,8 @@ export function lastUserText(messages) {
     // 上一步的注入块会变成这一步的就绪查询（自激：拿自己注入的内容再检索一遍）。
     if (m.source && m.source.kind === 'user') return t.trim()
     // 本插件注入的块同样是 role=user。无 source 的老宿主下若把它当兜底查询，
-    // 就成了"拿自己上一步注入的内容再检索一遍"的自激——正是 kind==='user' 这道闸要防的。
-    if (m.source && m.source.plugin === 'dsh-project-memory') continue
+    // 就成了"拿自己上一步注入的内容再检索一遍"的自激——正是 isOwnInjection 这道闸要防的。
+    if (isOwnInjection(m.source)) continue
     if (!fallback) fallback = t.trim() // 无 source 的消息（老宿主 / 测试）兜底
   }
   return fallback
@@ -226,7 +261,11 @@ function collectTriggered(cands, ctx) {
  */
 function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
   const hints = []
-  if (!cands.length) return hints
+  // 影子记录用：本步**全部**被评过分的候选 + 特征 + 判据结果。与 hints/dropped 分开算——
+  // 现有两类记录都只覆盖"过得了相对阈值的那部分"，恰恰缺了"因为没到阈值而从未被考虑"的候选，
+  // 而那正是离线重放阈值时需要的那批。这里只做加法，不动任何现有判据。
+  const candidates = []
+  if (!cands.length) return { hints, candidates }
   if (typeof cfg.relevanceMin === 'number') {
     // 兼容：显式 relevanceMin → 旧的绝对 overlap 判据（老 profile 行为不变）
     for (const it of cands) {
@@ -234,10 +273,10 @@ function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
       if (score >= cfg.relevanceMin) hints.push({ it, score, why: `overlap:${score.toFixed(3)}` })
     }
     hints.sort((a, b) => b.score - a.score)
-    return hints
+    return { hints, candidates } // 旧判据路径不产出影子候选（已废弃，无重放价值）
   }
   const q = hintQueryText(hintQuery)
-  if (!q) return hints
+  if (!q) return { hints, candidates }
   const byId = new Map(cands.map((it) => [it.id, it]))
   // 覆盖率语料必须与 BM25 排序同源（insightScoringText）：否则"只在 fix/solution 里有匹配"
   // 的查询词 df=0 → supportRatio=0 → 整条提示通道沉默，而排序明明给了它高分。
@@ -272,7 +311,36 @@ function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
     }
     hints.push({ it, score: r.score, why: `relative:${(r.score / (scored[0].score || 1)).toFixed(2)} cov:${ev.coverage.toFixed(2)}/${ev.matched}` })
   }
-  return hints
+
+  // ---- 影子候选（只读、无副作用）：重放一遍**全部**被评分的条目，标出它卡在哪一关 ----
+  // 顺序与真实判据一致（support → coverage → thin → relative），最后 'cand' = 过了全部门槛
+  // （注意 'cand' 不等于"真的注入了"：还要过去重/预算/冷却，那些写在同一行的 injected/silence）。
+  {
+    const top = scored[0]?.score || 0
+    const ratio = typeof cfg.signalMinRatio === 'number' && Number.isFinite(cfg.signalMinRatio) ? cfg.signalMinRatio : 0.5
+    for (const r of scored) {
+      const it = byId.get(r.entry.insightId)
+      if (!it || !Number.isFinite(r.score) || r.score <= 0) continue
+      const ev = coverage.get(it.id) || { coverage: 0, matched: 0, supported: 0, terms: 0 }
+      const needMatched = Math.min(typeof cfg.hintMinMatched === 'number' ? cfg.hintMinMatched : 2, ev.terms)
+      let decision = 'cand'
+      if (channelThin) decision = 'support'
+      else if (typeof cfg.hintMinCoverage === 'number' && ev.coverage < cfg.hintMinCoverage) decision = 'coverage'
+      else if (ev.matched < needMatched) decision = 'thin'
+      else if (r.score < top * Math.max(0, Math.min(1, ratio))) decision = 'relative'
+      candidates.push({
+        id: it.id,
+        channel: 'hint',
+        rel: Number((r.score / (top || 1)).toFixed(3)),
+        coverage: Number(ev.coverage.toFixed(3)),
+        matched: ev.matched,
+        support: ev.supported,
+        terms: ev.terms,
+        decision,
+      })
+    }
+  }
+  return { hints, candidates }
 }
 
 /**
@@ -317,7 +385,7 @@ export function buildInjection(opts) {
   // procedure 不进提示通道：它要过 trigger.scope（见 scoreHints 注释）。
   const consumed = new Set(triggered.map((t) => t.it.id))
   const hintCands = skipItems ? [] : cands.filter((it) => !consumed.has(it.id) && it.kind !== 'procedure')
-  const hints = scoreHints({
+  const { hints, candidates } = scoreHints({
     cands: hintCands,
     query,
     humanText: ctx.humanText,
@@ -368,7 +436,7 @@ export function buildInjection(opts) {
   // 整块只受单轮预算（maxTokens）约束；会话条目额度已在 place() 里单独扣过。
   const clamp = (t) => (t.length > stepBudget ? `${t.slice(0, stepBudget)}\n…(截断)` : t)
   const dedupeText = clamp([entryStable, ...parts].filter(Boolean).join('\n'))
-  return { text: clamp(total.join('\n')), entry, entryStable, labels, reasons, dropped, dedupeText, itemChars: itemUsed }
+  return { text: clamp(total.join('\n')), entry, entryStable, labels, reasons, dropped, candidates, dedupeText, itemChars: itemUsed }
 }
 
 // 每会话状态的会话数上限：六张表共用（旧实现把同一个 200 在五处各写一遍）。
@@ -439,6 +507,7 @@ export function installAutoInject(ctx, config) {
   const cfg = cfgEngine(config)
   // 审计配置同 cfg：安装时解析一次（与 autoContext 其余开关一致）。
   const audit = cfgAudit(config)
+  const shadow = cfgShadow(config)
   const sessions = new InjectionSessions()
 
   installCallObserver(ctx, sessions)
@@ -455,7 +524,7 @@ export function installAutoInject(ctx, config) {
     if (!decision) return fallback()
     if (decision.kind !== 'enter') return decision
     try {
-      return (await injectForStep({ payload, decision, config, cfg, audit, sessions })) || decision
+      return (await injectForStep({ payload, decision, config, cfg, audit, shadow, sessions })) || decision
     } catch (err) {
       console.error(`[dsh-project-memory] auto-inject skipped: ${err?.message || err}`)
       return decision
@@ -467,7 +536,7 @@ export function installAutoInject(ctx, config) {
  * 一个 pre-step 的注入决策：解析会话 → 排程 → 必要时构造消息。
  * 返回 null 表示本步无事可做（交回原决策）。
  */
-async function injectForStep({ payload, decision, config, cfg, audit, sessions }) {
+async function injectForStep({ payload, decision, config, cfg, audit, shadow, sessions }) {
   const session = payload && payload.agent && payload.agent.session
   const root = session && session.header && session.header.cwd
   const sessionId = session && session.id
@@ -518,6 +587,21 @@ async function injectForStep({ payload, decision, config, cfg, audit, sessions }
   // 留痕仍然记账（去重 + 上限），只是默认不外泄到用户的终端。
   recordDropped({ sessions, sessionId, dropped: built.dropped, budgetLog: cfg.budgetLog })
 
+  // 影子记录：**每步**都写一行（含零注入的静默步与对照组），带全部候选的判据特征。
+  // 主审计只在真的注入时写，静默步零痕迹 → 日志无法离线重放"换个阈值会怎样"，
+  // 也攒不出训练样本。只写盘、不进 prompt、不花 token。
+  appendShadowAudit(memoryRoot, shadowRecordFrom({
+    sessionId,
+    root,
+    step: stepNo,
+    query: query || '',
+    ops: readiness.ops,
+    writes: readiness.targets,
+    reasons: built.reasons,
+    candidates: built.candidates,
+    silence: silence.reason,
+  }), shadow)
+
   const fp = fingerprint(built.dedupeText ?? built.text)
   if (!built.text || fp === sessions.lastText.peek(sessionId)) return null
   sessions.lastText.set(sessionId, fp)
@@ -534,6 +618,19 @@ async function injectForStep({ payload, decision, config, cfg, audit, sessions }
     quota.lastStep = stepNo
   }
 
+  // 使用记账：注入进上下文 = 这条记忆被用到了。必须在这里显式落盘——注入路径不会走到
+  // 任何其它 save()，只标脏等于进程退出就丢。记账失败绝不影响注入（与审计同约定）。
+  if (built.reasons.length) {
+    try {
+      if (recordHit({ store, globalStore, ids: built.reasons.map((r) => r.id) })) {
+        store.save()
+        globalStore.commit()
+      }
+    } catch {
+      /* ignore：记账是旁路，不能拖累注入 */
+    }
+  }
+
   // S0 观测：只记真的进了上下文的那一次（dropped 单独出现不写，否则每步刷屏）。
   appendInjectionAudit(memoryRoot, auditRecordFrom({
     sessionId,
@@ -594,10 +691,9 @@ function injectionMessage(text) {
     content: [{ type: 'text', text: `\n\n${INJECT_MARK} auto-context\n${text}` }],
     // 这一块是「同一生产者后续快照会取代的当前状态」，不是一次性通知。
     // 宿主 ContextFormed 是判别联合：snapshot 必须带 sections（notice 才需要 summary）。
-    // 通道不变（仍走 agent/pre-step 追加 user 消息），只修语义。
+    // kind 必须是生产者自有的（v4 没有 'plugin' 兜底 kind），见 SOURCE_KIND 的注释。
     source: {
-      kind: 'plugin',
-      plugin: 'dsh-project-memory',
+      kind: SOURCE_KIND,
       form: 'snapshot',
       sections: [{ name: 'project-memory', text }],
     },

package/src/client/MemoryView.tsx

@@ -120,6 +120,14 @@ export function MemoryView({
   const lastRunRef = useRef(0)
 
   const refresh = useCallback(async (force = false): Promise<void> => {
+    // 没有活跃会话时不发命令、也不报错：面板顶部已经显示「还没有会话」，
+    // 再报一次"同步失败"会让人以为记忆库坏了（0.1.7 上会话快照结构变化时就是这个表象）。
+    if (!sessionId) {
+      setPayload(null)
+      setError(null)
+      setLoading(false)
+      return
+    }
     if (inflightRef.current) return
     const now = Date.now()
     if (!force && now - lastRunRef.current < 800) return
@@ -128,7 +136,7 @@ export function MemoryView({
     setLoading(true)
     setError(null)
     try {
-      const res = await runLine(`/insight list ${scope}`)
+      const res = await runLine(`/tasks insight list ${scope}`)
       if (!res.ok) {
         setError(res.text)
         setPayload(null)
@@ -152,7 +160,7 @@ export function MemoryView({
     setBusy(true)
     setError(null)
     try {
-      const line = `/insight ${action} ${scope} ${id}${action === 'demote' && scope === 'project' && boundTaskId ? ` ${boundTaskId}` : ''}`
+      const line = `/tasks insight ${action} ${scope} ${id}${action === 'demote' && scope === 'project' && boundTaskId ? ` ${boundTaskId}` : ''}`
       const res = await runLine(line)
       if (!res.ok) setError(res.text)
       else void refresh(true)
@@ -230,8 +238,8 @@ export function MemoryView({
         fields.trigger = { keywords: form.trigger.split(/[,，]/).map((s) => s.trim()).filter(Boolean) }
       }
       const line = editingId
-        ? `/insight edit ${scope} ${editingId} ${JSON.stringify(fields)}`
-        : `/insight save ${scope} ${JSON.stringify(fields)}`
+        ? `/tasks insight edit ${scope} ${editingId} ${JSON.stringify(fields)}`
+        : `/tasks insight save ${scope} ${JSON.stringify(fields)}`
       const res = await runLine(line)
       if (!res.ok) {
         setError(res.text)

package/src/client/TaskCommandNode.tsx

@@ -4,7 +4,7 @@
  * 目的：大 JSON 载荷绝不整段渲染进对话（否则切视图会刷屏）。
  */
 import { useEffect, useRef } from 'react'
-import { IconFolderOpenOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import { IconFolderOpenOutline16 } from './icons.ts'
 import { parseTaskPayloadText, taskDataStore } from './task-data-store.ts'
 import { parseInsightPayloadText } from './MemoryView.tsx'
 import { taskUIStore } from './task-ui-store.ts'

package/src/client/TaskComponents.tsx

@@ -3,14 +3,15 @@
  * 纯渲染 + 卡片局部行内编辑/拖拽状态，动作经 props 回调交给容器（TaskPanel.tsx）。
  */
 import { useEffect, useLayoutEffect, useRef, useState } from 'react'
+import { Button } from '@deepseek-ai/dsh-client-ui-primitives'
+// 图标走兼容层：0.1.5 用 IconXxx14/16，0.1.7+ 改成 IconXxxRegular + size prop
 import {
-  Button,
   IconChevronDownOutline14,
   IconChevronUpOutline14,
   IconCheckOutline16,
   IconPlayOutline16,
   IconFolderOpenOutline16,
-} from '@deepseek-ai/dsh-client-ui-primitives'
+} from './icons.ts'
 import { createTranslate } from './locales.ts'
 import { useTaskDrag } from './task-hooks.ts'
 import { type Task, type TaskInsight, type TaskStep } from './task-data-store.ts'

package/src/client/TaskPanel.tsx

@@ -4,18 +4,20 @@
  * Presentational 组件在 TaskComponents.tsx
  */
 import { Component, useEffect, useRef, useState, type ReactNode } from 'react'
+import { Button } from '@deepseek-ai/dsh-client-ui-primitives'
+// 图标走兼容层：0.1.5 用 IconXxx14/16，0.1.7+ 改成 IconXxxRegular + size prop
 import {
-  Button,
   IconChevronDownOutline14,
   IconCloseOutline16,
   IconFolderOpenOutline16,
   IconQuestionOutline14,
-} from '@deepseek-ai/dsh-client-ui-primitives'
+} from './icons.ts'
 import { createTranslate, zh, en } from './locales.ts'
 import { useTaskData, useTaskDataActions, taskDataStore, parseTaskPayloadText, type TaskStep } from './task-data-store.ts'
 import { useTaskUI, useTaskUIActions } from './task-ui-store.ts'
 import { MiniBar, TaskCard } from './TaskComponents.tsx'
 import { MemoryView, type InsightScope } from './MemoryView.tsx'
+import { pickSessionId } from './session-id.js'
 import css from './TaskPanel.module.css'
 
 const NS = 'dsh-project-memory'
@@ -36,11 +38,9 @@ function useSessionId(ctx: any): string | null {
     if (!list || typeof list.subscribe !== 'function') return
     return list.subscribe(() => force((n) => n + 1))
   }, [ctx])
-  const snap = ctx?.sessions?.list?.getSnapshot?.()
-  if (!snap) return null
-  if (snap.current) return snap.current
-  const first = Array.isArray(snap.items) ? snap.items.find((s: any) => !s.blank) ?? snap.items[0] : undefined
-  return first?.sessionId ?? null
+  // 快照结构在 dsh 0.1.7 变过（current/items → ids/byId）：解析与兼容都在 session-id.js，
+  // 那里有单测；这里只负责订阅与取值。
+  return pickSessionId(ctx?.sessions?.list?.getSnapshot?.())
 }
 
 class PanelErrorBoundary extends Component<{ children: ReactNode }, { failed: boolean }> {
@@ -134,7 +134,7 @@ function TaskPanelView({ ctx }: { ctx: any }) {
       await runLine('/tasks')
       const newBoundId = taskDataStore.getSnapshot().boundTaskId
       if (newBoundId && newBoundId !== prevBoundId) {
-        await runLine(`/task switch ${newBoundId}`)
+        await runLine(`/tasks switch ${newBoundId}`)
       }
     } finally {
       setSyncing(false)
@@ -145,7 +145,7 @@ function TaskPanelView({ ctx }: { ctx: any }) {
     if (syncing) return
     setSyncing(true)
     try {
-      await runLine(`/task ${verb} ${taskId}`)
+      await runLine(`/tasks ${verb} ${taskId}`)
     } finally {
       setSyncing(false)
     }
@@ -156,7 +156,7 @@ function TaskPanelView({ ctx }: { ctx: any }) {
     if (syncing) return
     setSyncing(true)
     try {
-      await runLine(`/insight ${action} task ${id}`)
+      await runLine(`/tasks insight ${action} task ${id}`)
       await refresh()
     } finally {
       setSyncing(false)
@@ -164,7 +164,7 @@ function TaskPanelView({ ctx }: { ctx: any }) {
   }
 
   const pushSteps = (taskId: string, steps: TaskStep[]): void => {
-    void runLine(`/task todos ${JSON.stringify(steps.map((s) => ({ content: s.content, status: s.status })))}`)
+    void runLine(`/tasks todos ${JSON.stringify(steps.map((s) => ({ content: s.content, status: s.status })))}`)
   }
 
   const cycleStatus = (taskId: string, index: number) => {
@@ -206,7 +206,7 @@ function TaskPanelView({ ctx }: { ctx: any }) {
     if (!task) return
     const same = task.title === trimmed
     if (same || !trimmed) return
-    void runLine(`/task rename ${taskId} ${JSON.stringify(trimmed)}`)
+    void runLine(`/tasks rename ${taskId} ${JSON.stringify(trimmed)}`)
   }
 
   const expand = () => {
@@ -421,7 +421,7 @@ function TaskPanelView({ ctx }: { ctx: any }) {
                 expanded={expanded}
                 onToggleExpand={() => uiActions.toggleTaskExpanded(task.id)}
                 onSwitch={() => handleAction('switch', task.id)}
-                onUnbind={() => runLine('/task unbind')}
+                onUnbind={() => runLine('/tasks unbind')}
                 onArchive={() => handleAction('archive', task.id)}
                 onRename={(value) => commitTitle(task.id, value)}
                 onEditStep={(index, value) => commitStepText(task.id, index, value)}

package/src/client/client.ts

@@ -10,10 +10,14 @@
  *
  * 只依赖宿主 seed 提供的模块（react / dsh-client-ui-primitives），
  * 数据经 remote.commands.execute 执行 /tasks 命令获取 JSON 快照。
+ *
+ * 另有一个可选增强：自建的 `/` 菜单源（slash.ts），把三条命令收进一个带图标和
+ * 小节标题的「工作流」组。它**整体是可选的**——宿主没有 slash 触发器服务时静默跳过。
  */
 import { createElement } from 'react'
 import { TaskPanelEntry } from './TaskPanel.tsx'
 import { TaskCommandNode } from './TaskCommandNode.tsx'
+import { createSlashSource } from './slash.ts'
 
 const NS = 'dsh-project-memory'
 
@@ -22,32 +26,100 @@ export const name = NS
 /** Required client services: slots registry, session scopes, commands remote (data 通道). */
 export const inject = ['slots', 'sessions', 'remote', 'remote.commands', 'locale']
 
+/**
+ * 执行一条命令行，映射成 composer 的 SubmitOutcome。
+ * 与 TaskPanel 走同一个 remote.commands.execute 通道（同样的返回信封）。
+ * @param commands - ctx.remote.commands
+ * @param session - 会话投影（只读 sessionId）
+ * @param line - 完整命令行（含前导斜杠）
+ * @param attachments - 提交附件（菜单路径恒为空）
+ * @returns {kind:'success'|'error', text?}
+ */
+async function runCommand(
+  commands: any,
+  session: any,
+  line: string,
+  attachments: readonly unknown[] = [],
+): Promise<{ kind: 'success' | 'error'; text?: string }> {
+  const sessionId = session?.sessionId
+  if (typeof sessionId !== 'string' || !commands || typeof commands.execute !== 'function') {
+    return { kind: 'error', text: `no session / commands service for ${line}` }
+  }
+  const response: any = await commands.execute(sessionId, line, [...attachments])
+  const envelope = response as { ok?: boolean; error?: any; value?: any } | null | undefined
+  if (envelope && typeof envelope === 'object' && envelope.ok === false) {
+    return { kind: 'error', text: `command.execute failed: ${envelope.error?.code ?? 'unknown'}` }
+  }
+  const execution = envelope && typeof envelope === 'object' && 'value' in envelope ? envelope.value : envelope
+  const result = execution?.result ?? execution
+  if (result?.kind === 'error') return { kind: 'error', text: result.text ?? `${line} failed` }
+  return { kind: 'success' }
+}
+
+/**
+ * 注册自建的 `/` 菜单源（见 slash.ts）。
+ *
+ * 整段都是**可选增强**：宿主没有 `inputTriggers` 服务、或该服务换了契约时，绝不能因此
+ * 让整个 client 插件挂掉——那会连任务面板一起消失。`inputTriggers` 因此不进顶层 `inject`
+ * （顶层 inject 未满足时 cordis 根本不会调用 apply），而是走嵌套 inject + 两层 try/catch。
+ * @param ctx - client 根上下文
+ */
+function registerSlashSource(ctx: any): void {
+  if (typeof ctx?.inject !== 'function') {
+    console.warn(`[${NS}] host has no ctx.inject — slash menu group disabled`)
+    return
+  }
+  try {
+    ctx.inject(['inputTriggers', 'sessions', 'remote.commands'], (scope: any) => {
+      try {
+        const inputTriggers = scope?.inputTriggers
+        if (!inputTriggers || typeof inputTriggers.registerSource !== 'function') {
+          console.warn(`[${NS}] host has no inputTriggers.registerSource — slash menu group disabled`)
+          return
+        }
+        const source = createSlashSource(scope, {
+          sessions: scope.sessions,
+          run: (session, line, attachments) => runCommand(scope?.remote?.commands, session, line, attachments),
+        })
+        scope.effect(() => inputTriggers.registerSource(source), 'dsh-project-memory: slash source')
+      } catch (err) {
+        console.warn(`[${NS}] slash source registration failed:`, err)
+      }
+    })
+  } catch (err) {
+    console.warn(`[${NS}] slash source injection failed:`, err)
+  }
+}
+
 export function apply(ctx: any): void {
   const slots = ctx?.slots
   if (!slots || typeof slots.inject !== 'function') {
     console.warn(`[${NS}] host has no slots service — task panel disabled`)
-    return
-  }
-  try {
-    slots.inject('shell.overlay', () => slots.register(
-      {
-        name: 'shell.overlay',
-        id: 'dsh-project-memory-task-panel',
-        order: 100, // 浮层顺序：低于 toast/弹窗即可，越高越靠后渲染
-      },
-      () => createElement(TaskPanelEntry, { ctx })
-    ))
-
-    // 会话内 /tasks、/task、/insight 命令节点：按命令名 key 接管渲染，
-    // 替换内置大段文本卡片（文本含 JSON 载荷，只有面板需要它），避免载荷刷屏对话。
-    const nodeKeys = ['tasks', 'task', 'insight']
-    for (const key of nodeKeys) {
-      slots.inject('conversation.chat.commandview', () => slots.register(
-        { name: 'conversation.chat.commandview', key },
-        TaskCommandNode
+  } else {
+    try {
+      slots.inject('shell.overlay', () => slots.register(
+        {
+          name: 'shell.overlay',
+          id: 'dsh-project-memory-task-panel',
+          order: 100, // 浮层顺序：低于 toast/弹窗即可，越高越靠后渲染
+        },
+        () => createElement(TaskPanelEntry, { ctx })
       ))
+
+      // 会话内命令节点：按命令名 key 接管渲染，替换内置大段文本卡片
+      // （文本含 JSON 载荷，只有面板需要它），避免载荷刷屏对话。
+      // 合并后只剩一条用户命令 /tasks（子动词都记在同一个命令名下）。
+      const nodeKeys = ['tasks']
+      for (const key of nodeKeys) {
+        slots.inject('conversation.chat.commandview', () => slots.register(
+          { name: 'conversation.chat.commandview', key },
+          TaskCommandNode
+        ))
+      }
+    } catch (err) {
+      console.warn(`[${NS}] task panel registration failed:`, err)
     }
-  } catch (err) {
-    console.warn(`[${NS}] task panel registration failed:`, err)
   }
+
+  registerSlashSource(ctx)
 }