@yolk_vat-y/dsh-project-memory 0.5.13 → 0.5.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.13",
+  "version": "0.5.14",
   "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.",
   "author": "00080000 <3388065969@qq.com>",
   "type": "module",
@@ -19,7 +19,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 && 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 && node test/task-view.test.mjs && node test/root-guards.test.mjs && node test/store-gitignore.test.mjs && node test/store-cache.test.mjs && node test/enhancer.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/client-toolview.test.mjs && node test/workflow-command.test.mjs && node test/client-session-id.test.mjs && node test/task-view.test.mjs && node test/root-guards.test.mjs && node test/store-gitignore.test.mjs && node test/atomic-write.test.mjs && node test/store-cache.test.mjs && node test/enhancer.test.mjs",
     "eval:injection": "node test/injection-scenarios.test.mjs",
     "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.client.json",
     "selfcheck:triggers": "node test/injection-scenarios.test.mjs --selfcheck",
@@ -50,12 +50,12 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-store": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-llm": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-tools": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-store": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
     "@deepseek-ai/schemastery": "^3.18.2",
     "@tsdown/css": "0.22.14",
     "@types/react": "^18.3.31",

package/src/audit.js

@@ -19,7 +19,21 @@ const DEFAULT_MAX_BYTES = 256 * 1024
 // "本该零注入"的步）完全不落痕，于是日志回答不了"换个阈值/换个判据会怎样"。影子记录每步都写，
 // 带全部候选的特征与判据结果，用来 (a) 离线重放任一阈值、(b) 攒"特征 → 该不该注入"的训练样本。
 export const SHADOW_FILE = 'admission-shadow.jsonl'
-const DEFAULT_SHADOW_MAX_BYTES = 2 * 1024 * 1024
+// 512KB 而不是 2MB：轮转只保留 `.1` 一代，所以单项目日志的硬上限是
+// `2 × shadowMaxBytes + 2 × auditMaxBytes`，之前是 4.6MB（在小项目上比 store 本身还大，
+// 实测本插件自己的 store 里 3.1M/4.2M 是日志）。512KB 下上限降到 ≈1.5MB，
+// 而按每行 ~1.5KB 算仍有 ~680 步的历史窗口 —— 远超"离线重放最近的历史"所需。
+const DEFAULT_SHADOW_MAX_BYTES = 512 * 1024
+
+/**
+ * 一行影子记录最多保留多少个候选。
+ *
+ * 影子日志 **90.6% 的体积是 `candidates`**（实测 210 行 / 965KB，候选占 875KB），而真实 store
+ * 单步就能产生 40~60 条（中位 42）。候选按分数降序排列，`decision === 'cand'` 必然排在最前
+ * （相对阈值就是分数比），所以「**全部 cand + 按排名补足**」既保住离线重放最需要的那批，
+ * 又砍掉远处必然被 coverage/relative 拦掉的尾巴。截断量记在 `candidatesTotal`，不静默。
+ */
+const SHADOW_MAX_CANDIDATES = 16
 
 /** 审计配置：默认开（观测是这个插件唯一的仪表盘），显式 `auditLog: false` 才关。 */
 export function cfgAudit(config) {
@@ -52,11 +66,34 @@ export function shadowFileFor(memoryDir) {
  *  - **每步都写**（含零注入的静默步与对照组），所以"没注入"也留下了可复盘的事实；
  *  - 带**全部候选**的判据特征（cov/matched/support/relative）与场景（query/ops/writes），
  *    所以能离线回答"阈值换成 0.40 会注入什么"、并攒出"特征 → 该不该注入"的样本。
- * @param {object} input { sessionId, root, step, query, ops, writes, reasons, candidates, silence }
+ * @param {object} input { sessionId, root, step, query, scoreQuery, ops, writes, reasons, dropped, candidates, silence }
  */
 export function shadowRecordFrom(input) {
   const reasons = Array.isArray(input.reasons) ? input.reasons : []
   const candidates = Array.isArray(input.candidates) ? input.candidates : []
+  const dropped = Array.isArray(input.dropped) ? input.dropped : []
+  // `support` / `terms` 是**查询级**量（语料里有几个词能表示这条查询），同一个 pre-step 内
+  // 逐条恒定（实测 139/139 步）。把它们从每条候选提到行级：单候选省 ~25 B，整行省 ~23%。
+  const first = candidates[0]
+  const slim = candidates.map((c) => ({
+    id: c.id,
+    rel: c.rel,
+    coverage: c.coverage,
+    matched: c.matched,
+    // `decision` 是门槛层结论，`outcome` 是预算层结论，两者正交（见 auto-inject.js）。
+    decision: c.decision,
+    outcome: c.outcome,
+  }))
+  // 候选**只有提示通道**（trigger 的结果在 `injected` / `dropped` 里），所以不再逐条记 channel。
+  const bounded = slim.length <= SHADOW_MAX_CANDIDATES ? slim : (() => {
+    const keep = new Set()
+    for (const c of slim) if (c.decision === 'cand') keep.add(c.id)
+    for (const c of slim) {
+      if (keep.size >= SHADOW_MAX_CANDIDATES) break
+      keep.add(c.id)
+    }
+    return slim.filter((c) => keep.has(c.id))
+  })()
   return {
     at: new Date().toISOString(),
     session: input.sessionId || null,
@@ -64,10 +101,22 @@ export function shadowRecordFrom(input) {
     step: typeof input.step === 'number' ? input.step : null,
     // 人类消息截断保存：没有它就判不了"这次注入该不该"——标签要能回放到当时的场景。
     query: typeof input.query === 'string' ? input.query.slice(0, 300) : '',
+    // **实际用于评分**的查询文本（intent + 写目标的拼合）。它和 `query` 不是一回事：
+    // 写目标驱动的那些步 `query` 是空的、候选却非空。少了这一栏，判据无法离线重放。
+    scoreQuery: typeof input.scoreQuery === 'string' ? input.scoreQuery.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,
+    // 查询级支持度：语料能表示查询里多少个词（`terms` 是查询词数）—— 通道级沉默判据用的就是它。
+    support: typeof first?.support === 'number' ? first.support : null,
+    terms: typeof first?.terms === 'number' ? first.terms : null,
+    // candidates 的 `decision` 只说明"过没过门槛"，进不进上下文看 `outcome`
+    // （injected / budget / quota / idle / gate / unscheduled）。两者正交。
+    candidates: bounded,
+    // 截断前的候选总数：不静默，读日志的人能一眼看出这一步被裁掉了多少。
+    candidatesTotal: candidates.length,
+    // 触发通道的丢弃不在 candidates 里（候选只收提示通道），单列；有界，避免长候选池撑爆一行。
+    dropped: dropped.slice(0, 40),
     silence: input.silence || null,
   }
 }

package/src/auto-inject.js

@@ -17,12 +17,22 @@ import { cfgInsight, GlobalStore, defaultGlobalFile, recordHit } from './insight
 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 { buildReadinessContext, hintQueryText, corpusTermSets, idfCoveragePrepared, matchTrigger, normalizeTrigger, relativeHits } from './readiness.js'
 import { activityFromCalls } from './ops.js'
 import { appendInjectionAudit, appendShadowAudit, auditRecordFrom, cfgAudit, cfgShadow, shadowRecordFrom } from './audit.js'
 
 export const INJECT_MARK = '[Memory Inject]'
 
+/**
+ * 注入块抬头里的插件名。
+ *
+ * 消息的 `source.kind`（= {@link SOURCE_KIND}）只有宿主看得到：请求序列化只取 `role` 与
+ * `content`（provider 侧对 `.source` 零引用），所以模型从元数据里读不到"这是谁注入的"。
+ * 抬头是**唯一**能让模型（和 GUI 里的用户）看见生产者的地方。抬头不是行为契约：
+ * 客户端不解析它，判据也不读它。
+ */
+export const PLUGIN_NAME = 'dsh-project-memory'
+
 /**
  * 本插件在 `message.source` 上声明的生产者 kind。
  *
@@ -97,9 +107,14 @@ export function cfgEngine(config) {
     // 条目通道的步间隔：两次"条目注入"之间至少隔这么多步（常驻任务卡不受限——它是状态快照，
     // 内容变了就该更新）。这是"不频繁"的主要旋钮。
     gateCooldownSteps: typeof c.gateCooldownSteps === 'number' && c.gateCooldownSteps >= 0 ? c.gateCooldownSteps : 2,
-    // 每会话条目注入的上限（条数 / 字符）：预算只能是上限，不是目标。
-    maxItemsPerSession: typeof c.maxItemsPerSession === 'number' && c.maxItemsPerSession >= 0 ? c.maxItemsPerSession : 12,
-    maxItemCharsPerSession: typeof c.maxItemCharsPerSession === 'number' && c.maxItemCharsPerSession >= 0 ? c.maxItemCharsPerSession : 4000,
+    // 每会话条目注入的上限（条数 / 字符）：这是**保险丝**，不是节流阀。
+    // 节流由单轮 maxTokens 与 gateCooldownSteps 负责；这两个数的唯一职责是兜住病态的
+    // runaway，所以默认值必须远高于任何真实会话的用量。旧默认 12 条 / 4000 字符 ≈ 11 条，
+    // 实测真实日志里 11/81 个会话打满，打满之后是**永久**静默（实测 1234 步失明），
+    // 而"会话后段"恰是关键时刻概率最高的地方。实测最长会话用 35 条 / 8640 字符，故取
+    // 60 / 24000（≈1.7× 与 ≈2.8× 余量）。想复现旧行为显式配小值即可。
+    maxItemsPerSession: typeof c.maxItemsPerSession === 'number' && c.maxItemsPerSession >= 0 ? c.maxItemsPerSession : 60,
+    maxItemCharsPerSession: typeof c.maxItemCharsPerSession === 'number' && c.maxItemCharsPerSession >= 0 ? c.maxItemCharsPerSession : 24000,
     // 提示通道的**绝对**覆盖底线（IDF 加权覆盖率）：相对阈值分不出"有信号"和"矮子里拔将军"，
     // 只有归一在 [0,1]、有真零点才谈得上下限。0.30 时的实测反例：真实 store（43 条同源洞察）上，
     // 对照组场景「改 pptx 时间戳」以 cov 0.32~0.35 注入了 3 条无关条目——语料同源时共享词多、
@@ -259,7 +274,10 @@ function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
   // 现有两类记录都只覆盖"过得了相对阈值的那部分"，恰恰缺了"因为没到阈值而从未被考虑"的候选，
   // 而那正是离线重放阈值时需要的那批。这里只做加法，不动任何现有判据。
   const candidates = []
-  if (!cands.length) return { hints, candidates }
+  // 真正用于评分的查询文本。影子记录必须留下它：`query`（人类消息原文）与它不是一回事，
+  // 写目标驱动的那些步 `query` 为空、候选却非空。少了它，判据无法离线重放。
+  const q = hintQueryText(hintQuery)
+  if (!cands.length) return { hints, candidates, scoreQuery: q }
   if (typeof cfg.relevanceMin === 'number') {
     // 兼容：显式 relevanceMin → 旧的绝对 overlap 判据（老 profile 行为不变）
     for (const it of cands) {
@@ -267,10 +285,9 @@ 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, candidates } // 旧判据路径不产出影子候选（已废弃，无重放价值）
+    return { hints, candidates, scoreQuery: q } // 旧判据路径不产出影子候选（已废弃，无重放价值）
   }
-  const q = hintQueryText(hintQuery)
-  if (!q) return { hints, candidates }
+  if (!q) return { hints, candidates, scoreQuery: q }
   const byId = new Map(cands.map((it) => [it.id, it]))
   // 覆盖率语料必须与 BM25 排序同源（insightScoringText）：否则"只在 fix/solution 里有匹配"
   // 的查询词 df=0 → supportRatio=0 → 整条提示通道沉默，而排序明明给了它高分。
@@ -278,7 +295,10 @@ function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
   // 查询与被测覆盖率的文本用**同一个**过滤后的查询：否则缩写（wsl/npm）会在 BM25 里被剔除、
   // 却仍在覆盖率里计分，"至少两个共同词"就被它们凑够了。
   const scored = rankEntriesMergedScored(cands.map(insightToEntry), [q], cands.length)
-  const coverage = new Map(cands.map((it, i) => [it.id, idfCoverage(q, corpus[i], corpus)]))
+  // 语料词集合建**一次**再逐条算覆盖率。逐条调用 `idfCoverage` 会让它每次重建整个语料，
+  // 即 O(C²) 次 tokenize（实测真实 store 单步 147ms → 1.3ms，109×，结果逐字段一致）。
+  const corpusSets = corpusTermSets(corpus)
+  const coverage = new Map(cands.map((it, i) => [it.id, idfCoveragePrepared(q, corpus[i], corpusSets)]))
   const qStats = coverage.get(cands[0].id) || { supported: 0, terms: 0 }
   const supportRatio = qStats.terms > 0 ? qStats.supported / qStats.terms : 0
   // 通道级沉默：查询里绝大多数词在语料里根本没有对应 → "覆盖率 1.00"只是假象。
@@ -334,7 +354,7 @@ function scoreHints({ cands, query, humanText, hintQuery, cfg, dropped }) {
       })
     }
   }
-  return { hints, candidates }
+  return { hints, candidates, scoreQuery: q }
 }
 
 /**
@@ -378,8 +398,11 @@ 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, candidates } = scoreHints({
+  // 限流命中时**照旧评分**（只算不注入，`place()` 仍按 skipItems 跳过）：影子记录要能回答
+  // "这一步如果不限流会注入什么"——那正是限流期间最需要回答的问题。此前这里直接置空，
+  // 实测 1420 个静默步一个候选都没留下。
+  const hintCands = cands.filter((it) => !consumed.has(it.id) && it.kind !== 'procedure')
+  const { hints, candidates, scoreQuery } = scoreHints({
     cands: hintCands,
     query,
     humanText: ctx.humanText,
@@ -408,7 +431,9 @@ export function buildInjection(opts) {
       const remaining = Math.min(stepBudget - used, itemBudget - itemUsed)
       const body = fitBody(insightBody(it), remaining, minChars)
       if (body === null) {
-        dropped.push({ id: it.id, channel, reason: 'budget' })
+        // 带出数字：旧的 `budget` 没有量纲，"还剩 38 字符、这条最少要 120" 与"根本没预算"
+        // 在日志里长得一样 —— 配额逼近上限时那条永久静默的细缝因此完全不可诊断。
+        dropped.push({ id: it.id, channel, reason: 'budget', remaining, need: minChars })
         continue
       }
       used += body.length + 1
@@ -425,12 +450,33 @@ export function buildInjection(opts) {
     place('hint', hints, MIN_BODY_CHARS.hint, () => 'hint')
   }
 
+  // 预算层结局写回候选。`decision` 是**门槛层**的结论（support/coverage/thin/relative/cand），
+  // `outcome` 是**预算层**的结论——两者正交。"过了全部门槛却没注入"必须能归因，
+  // 否则日志只能证明门槛做了什么，证明不了预算拿走了什么。
+  {
+    const outcomeById = new Map()
+    for (const r of reasons) outcomeById.set(`${r.channel}\u0000${r.id}`, 'injected')
+    for (const d of dropped) {
+      const key = `${d.channel}\u0000${d.id}`
+      if (!outcomeById.has(key)) outcomeById.set(key, d.reason)
+    }
+    for (const c of candidates) {
+      c.outcome = skipItems ? 'idle'
+        : c.decision !== 'cand' ? 'gate'
+          : outcomeById.get(`hint\u0000${c.id}`) || 'unscheduled'
+    }
+  }
+
   const total = [entry, ...parts].filter(Boolean)
-  if (!total.length) return { text: '', entry, labels, reasons, dropped }
+  // 早退也必须带上 candidates/scoreQuery：空块不等于"没有候选"（无任务卡 + 全部被预算挤掉
+  // 就是这种形状），此前这里把两者一起丢了。
+  if (!total.length) {
+    return { text: '', entry, labels, reasons, dropped, candidates, scoreQuery, itemChars: itemUsed }
+  }
   // 整块只受单轮预算（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, candidates, dedupeText, itemChars: itemUsed }
+  return { text: clamp(total.join('\n')), entry, entryStable, labels, reasons, dropped, candidates, scoreQuery, dedupeText, itemChars: itemUsed }
 }
 
 // 每会话状态的会话数上限：六张表共用（旧实现把同一个 200 在五处各写一遍）。
@@ -618,6 +664,8 @@ async function injectForStep({ payload, decision, config, cfg, audit, shadow, se
     writes: readiness.targets,
     reasons: built.reasons,
     candidates: built.candidates,
+    scoreQuery: built.scoreQuery,
+    dropped: built.dropped,
     silence: silence.reason,
   }), shadow, root)
 
@@ -737,7 +785,7 @@ function recordDropped({ sessions, sessionId, dropped, budgetLog }) {
 /** 追加的注入消息：必须是带 source 的完整消息——裸 {role,content} 会让宿主读 message.source 时崩。 */
 function injectionMessage(text) {
   return createUserMessage({
-    content: [{ type: 'text', text: `\n\n${INJECT_MARK} auto-context\n${text}` }],
+    content: [{ type: 'text', text: `\n\n${INJECT_MARK} ${PLUGIN_NAME} · auto-context\n${text}` }],
     // 这一块是「同一生产者后续快照会取代的当前状态」，不是一次性通知。
     // 宿主 ContextFormed 是判别联合：snapshot 必须带 sections（notice 才需要 summary）。
     // kind 必须是生产者自有的（v4 没有 'plugin' 兜底 kind），见 SOURCE_KIND 的注释。

package/src/client/ShowTaskPanelNode.tsx

@@ -0,0 +1,51 @@
+/**
+ * `show_task_panel` 工具调用的会话内视图 —— 它的作用就是**把面板打开**。
+ *
+ * 为什么这件事必须在这里做：面板的显示状态（closed / minimized）是**浏览器侧**的
+ * （`task-ui-store.ts`），宿主进程碰不到它。宿主侧原本写的是
+ * `exec.ctx.events.emit('dsh:task-panel:show')`，而宿主契约里根本没有 `ctx`：
+ *
+ *   packages/core/tools/src/index.ts:418
+ *   export interface ToolRunContext extends ToolExecution {
+ *     deferContext(context: UserMessage): void
+ *     concludeTurn(): void
+ *   }
+ *
+ * 于是那个工具每次都只返回「无法获取上下文」，面板从来不会打开 —— 插件里唯一的
+ * 宿主命令之外，这是第二个"写了但没生效"的面（详见 CHANGELOG 0.5.14）。
+ *
+ * 正确的位置是宿主给出的扩展点：`ui-tool` 注册了 `conversation.chat.node`（key `tool-call`），
+ * 其下有个按**工具名**分发的子槽 `tool.call.toolview`（契约原文：*Any name is allowed,
+ * including tools registered by your package. Register with `key: '<tool name>'`*）。
+ * 在这里认领 `show_task_panel` 这个 key，工具结果一渲染就把面板打开。
+ */
+import { useEffect, useRef } from 'react'
+import { taskUIStore } from './task-ui-store.ts'
+
+/**
+ * 只在**现场执行**时打开面板。
+ *
+ * 历史节点在刷新 / 切换会话后挂载时会**直接**处于 `result` 阶段；现场调用则会先经过
+ * `preparing` / `start`。这与 `/tasks` 命令节点用的判据同款（见 `TaskCommandNode.tsx`
+ * 的 `live` ref）：刷新后只展示、不再开面板，否则每次打开会话都会弹一次面板。
+ */
+export function ShowTaskPanelNode(props: any) {
+  const phase = props?.phase
+  const live = useRef(phase !== 'result')
+  useEffect(() => {
+    if (phase !== 'result' || !live.current) return
+    live.current = false
+    taskUIStore.actions.open()
+  }, [phase])
+  // 不渲染任何行：认领 key 会**替换**通用工具行，而这次调用的全部意义就是开面板，
+  // 留一行"打开面板"的噪音不如让面板自己说话。
+  return null
+}
+
+/** 把 `show_task_panel` 的视图注册进宿主的 `tool.call.toolview` 槽。 */
+export function registerShowTaskPanelView(slots: any): void {
+  slots.inject('tool.call.toolview', () => slots.register(
+    { name: 'tool.call.toolview', key: 'show_task_panel' },
+    ShowTaskPanelNode,
+  ))
+}

package/src/client/TaskPanel.tsx

@@ -14,7 +14,7 @@ import {
 } 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 { useTaskUI, useTaskUIActions, PANEL_VIEWS } from './task-ui-store.ts'
 import { MiniBar, TaskCard } from './TaskComponents.tsx'
 import { MemoryView, type InsightScope } from './MemoryView.tsx'
 import { pickSessionId } from './session-id.js'
@@ -23,8 +23,8 @@ import css from './TaskPanel.module.css'
 const NS = 'dsh-project-memory'
 
 const STATUS_CYCLE = ['pending', 'in_progress', 'completed'] as const
-const VIEW_CYCLE = ['task', 'project', 'global'] as const
-type PanelView = (typeof VIEW_CYCLE)[number]
+// 视图列表的唯一事实来源在 UI store（`/` 菜单那三行也读它）；这里不再抄一份。
+const VIEW_CYCLE = PANEL_VIEWS
 
 function getT(ctx: any) {
   const locale = ctx?.locale?.getSnapshot?.()?.active === 'zh' ? zh : en
@@ -77,19 +77,19 @@ function TaskPanelView({ ctx }: { ctx: any }) {
   const [syncError, setSyncError] = useState<string | null>(null)
   // 提示信息开关落在 UI store（持久化）：关掉后面板内所有悬停 title 气泡都不再弹出。
   const showHints = ui.showHints
-  const [view, setView] = useState<PanelView>('task')
+  const dataActions = useTaskDataActions()
+  const uiActions = useTaskUIActions()
+  // 视图页同样落在 UI store：`/` 菜单的三行是"打开某一页"，它们必须能从这个组件外面切页。
+  const view = ui.view
   const cycleView = () => {
     const i = VIEW_CYCLE.indexOf(view)
-    setView(VIEW_CYCLE[(i + 1) % VIEW_CYCLE.length])
+    uiActions.setView(VIEW_CYCLE[(i + 1) % VIEW_CYCLE.length])
   }
   const viewTitle =
     view === 'task' ? t('panel.title')
       : view === 'global' ? t('view.global')
         : t('view.project')
 
-  const dataActions = useTaskDataActions()
-  const uiActions = useTaskUIActions()
-
   const tasks = Array.isArray(data.tasks) ? data.tasks : []
   const activeTasks = tasks.filter((task) => !task.archived)
   const boundTask = data.boundTaskId ? tasks.find((task) => task.id === data.boundTaskId) ?? null : null

package/src/client/client.ts

@@ -17,6 +17,8 @@
 import { createElement } from 'react'
 import { TaskPanelEntry } from './TaskPanel.tsx'
 import { TaskCommandNode } from './TaskCommandNode.tsx'
+import { registerShowTaskPanelView } from './ShowTaskPanelNode.tsx'
+import { taskUIStore } from './task-ui-store.ts'
 import { createSlashSource } from './slash.ts'
 
 const NS = 'dsh-project-memory'
@@ -26,36 +28,6 @@ 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）。
  *
@@ -79,7 +51,9 @@ function registerSlashSource(ctx: any): void {
         }
         const source = createSlashSource(scope, {
           sessions: scope.sessions,
-          run: (session, line, attachments) => runCommand(scope?.remote?.commands, session, line, attachments),
+          // 菜单行是「打开面板的某一页」：直接落到 UI store，不绕宿主命令
+          // （面板的 closed/view 是浏览器侧状态，宿主命令碰不到）。
+          openView: (view) => taskUIStore.actions.openView(view),
         })
         scope.effect(() => inputTriggers.registerSource(source), 'dsh-project-memory: slash source')
       } catch (err) {
@@ -116,6 +90,11 @@ export function apply(ctx: any): void {
           TaskCommandNode
         ))
       }
+
+      // 工具调用视图：`show_task_panel` 的唯一实际效果就是开面板，而面板状态在浏览器侧；
+      // 宿主进程碰不到它（宿主契约里 `ToolRunContext` 没有 `ctx`）。认领这个**工具名**后，
+      // 工具结果一渲染就把面板打开 —— 见 ShowTaskPanelNode.tsx。
+      registerShowTaskPanelView(slots)
     } catch (err) {
       console.warn(`[${NS}] task panel registration failed:`, err)
     }

package/src/client/slash.ts

@@ -18,11 +18,18 @@
  * 与「指令」组的重复：合并前插件注册了 /tasks、/task、/insight 三条宿主命令，菜单里就是三行
  * 去不掉的原始行 —— 宿主命令只要注册就会出现在目录里，`commands.list()` 与
  * `commands.execute()` 读同一个视图，`CommandDefinition` 也没有 hidden 字段，插件无法隐藏。
- * 现在宿主只剩一条 /tasks（见 src/commands/workflow.js），重复降到一行；那一行也是插件
- * 执行宿主侧工作的唯一通道（插件没有自己的 client→host RPC）。
+ * 现在宿主只剩一条 /tasks（见 src/commands/workflow.js），重复降到一行；那一行是插件执行
+ * 宿主侧工作的唯一通道（插件没有自己的 client→host RPC）。
+ *
+ * **这三行不发命令。** 它们是「打开面板的某一页」，而面板的 `closed` / `view` 是浏览器侧
+ * UI store 的状态 —— 宿主命令碰不到。旧实现绕了一圈 `remote.commands.execute('/tasks insight
+ * list project')`：命令确实在宿主执行了，但客户端渲染命令节点的是按**命令名**分发的
+ * `TaskCommandNode`（`name === 'tasks'`），它拿任务解析器去解记忆载荷 → 解析失败 → 面板毫无
+ * 变化。于是用户看到的就是"点了没反应"。现在直接调 `openView(view)`。
  */
 import type { ComponentType } from 'react'
 import { createTranslate, en, zh } from './locales.ts'
+import type { PanelView } from './task-ui-store.ts'
 import { IconChecklistOutline16, IconGlobeOutline16, IconLightOutline16 } from './icons.ts'
 
 /** 源的稳定标识：同一 trigger 内唯一，重复注册会抛错。 */
@@ -47,7 +54,8 @@ interface SlashRow {
   /** 额外搜索词：候选 name 是中文，拉丁输入（task / memory…）靠这些命中。 */
   readonly match: readonly string[]
   /** 点击后经 remote.commands.execute 执行的完整命令行。 */
-  readonly line: string
+  /** 点击后要打开的面板视图页。**纯客户端动作**，不绕宿主命令。 */
+  readonly view: PanelView
 }
 
 /** 菜单三行。顺序即渲染顺序；标题复用面板已有的 view.* 文案，保证与面板视图名一致。 */
@@ -57,21 +65,21 @@ const ROWS: readonly SlashRow[] = [
     descriptionKey: 'slash.tasks-desc',
     icon: IconChecklistOutline16,
     match: ['tasks', 'task'],
-    line: '/tasks',
+    view: 'task',
   },
   {
     labelKey: 'view.project',
     descriptionKey: 'slash.project-desc',
     icon: IconLightOutline16,
     match: ['memory', 'project', 'insight'],
-    line: '/tasks insight list project',
+    view: 'project',
   },
   {
     labelKey: 'view.global',
     descriptionKey: 'slash.global-desc',
     icon: IconGlobeOutline16,
     match: ['memory', 'global', 'insight'],
-    line: '/tasks insight list global',
+    view: 'global',
   },
 ]
 
@@ -79,8 +87,9 @@ const ROWS: readonly SlashRow[] = [
 export interface SlashSourceDeps {
   /** 会话服务（`sessions`）：把 sessionId 换回会话 scope，用于消费触发 token。 */
   readonly sessions: any
-  /** 执行一条完整命令行；返回 composer 认得的 SubmitOutcome 形状。 */
-  run(session: any, line: string, attachments?: readonly unknown[]): Promise<{ kind: 'success' | 'error'; text?: string }>
+  /** 打开面板并切到指定页（`taskUIStore.actions.openView`）。注入而非直接 import，
+   *  这样源本身可以在最小替身里单测，不需要真的挂一个 React 面板。 */
+  openView(view: PanelView): void
 }
 
 /** 翻译函数签名（key 来自 ROWS，不是字面量，故不做类型约束）。 */
@@ -114,7 +123,7 @@ export function buildSlashCandidates(t: Translate, req: any): readonly Record<st
       icon: row.icon,
       // 每一行都带 section → MenuView 不渲染组标题行，只渲染这个标题。
       section: t('slash.group'),
-      line: row.line,
+      // **不带 line**：这三行不是命令，是打开面板某一页；动作在 onPick 里按 name 查表得到。
       terms: [title, ...row.match].map((term) => term.toLowerCase()),
     }
   })
@@ -142,13 +151,18 @@ function consumeSpan(deps: SlashSourceDeps, pick: any): boolean {
 }
 
 /**
- * 一次菜单点击：消费掉触发 token 后立刻执行该行对应的命令行。
+ * 一次菜单点击：消费掉触发 token 后**直接打开面板的对应页**。
+ *
+ * 这三行是「打开某个视图」，不是「执行某条命令」，所以走客户端自己的 UI store：
+ * 面板的 `closed` / `view` 都是浏览器侧状态，宿主命令碰不到它们。旧实现执行
+ * `remote.commands.execute('/tasks insight list project')`，只在对话里留下一个命令节点，
+ * 而客户端渲染命令节点的是按**命令名**分发的 `TaskCommandNode`（`name === 'tasks'`），
+ * 它拿任务解析器去解记忆载荷 → 解析失败 → 对面板零影响。**这就是"点了没反应"的原因。**
  *
- * 不返回 claim（回填 `/xxx ` 再等回车）：这三行都是「打开某个视图」，claim 会多要一次回车，
- * 而且子动词（`insight list project`）也没法由一个 claim token 表达。消费失败时仍然执行，
- * 只是草稿里残留的触发文本要用户自己清掉 —— 比回填一个会执行错命令的 claim 安全。
+ * 不返回 claim（回填 `/xxx ` 再等回车）：claim 会多要一次回车，而这三行没有参数要填。
+ * 消费失败时仍然切页 —— 草稿里残留的触发文本要用户自己清掉，比"点了完全没反应"好。
  * @param t - 翻译函数（按当前语言把候选 name 映射回 ROWS）。
- * @param deps - 会话服务与命令执行通道。
+ * @param deps - 会话服务与 UI store 动作。
  * @param pick - 宿主给的点击载荷。
  * @returns PickOutcome；拿不到可用形状时返回 undefined（菜单照常关闭，草稿不动）。
  */
@@ -158,9 +172,11 @@ export function dispatchSlashPick(t: Translate, deps: SlashSourceDeps, pick: any
   const row = ROWS.find((candidate) => t(candidate.labelKey) === title)
   if (row === undefined) return undefined
   consumeSpan(deps, pick)
-  void deps.run(pick.session, row.line, []).catch((err: unknown) => {
-    console.warn(`[dsh-project-memory] ${row.line} failed:`, err)
-  })
+  try {
+    deps.openView(row.view)
+  } catch (err) {
+    console.warn(`[dsh-project-memory] open view ${row.view} failed:`, err)
+  }
   return 'handled'
 }
 

package/src/client/task-ui-store.ts

@@ -8,6 +8,19 @@ import { useSyncExternalStore } from 'react'
 
 const STORAGE_KEY = 'dsh-pm-task-panel-ui'
 
+/**
+ * 面板的三个视图页。**单一事实来源**：面板的切页按钮与 `/` 菜单的三行都读它。
+ * 两边各抄一份必然漂移 —— 实测就是这样：菜单行去执行宿主命令"开记忆页"，而面板的 view
+ * 是组件内部 state，谁也够不着它，于是点击没有任何可见效果。
+ */
+export const PANEL_VIEWS = ['task', 'project', 'global'] as const
+export type PanelView = (typeof PANEL_VIEWS)[number]
+
+/** 把任意值收敛成一个合法视图页（脏 localStorage / 外部传入都要过这一关）。 */
+export function normalizeView(value: unknown): PanelView {
+  return (PANEL_VIEWS as readonly unknown[]).includes(value) ? (value as PanelView) : 'task'
+}
+
 interface TaskUIState {
   expandedTaskIds: string[]
   panelPosition: { x: number; y: number }
@@ -16,6 +29,11 @@ interface TaskUIState {
   theme: string
   /** 是否显示悬停提示信息（title 气泡）；false 时面板内所有功能提示都不弹出。 */
   showHints: boolean
+  /**
+   * 当前视图页。放在 store 而不是 TaskPanel 的局部 state —— `/` 菜单那三行就是
+   * 「打开某一页」，它们从**组件外面**触发，必须有一个可寻址的落点。
+   */
+  view: PanelView
 }
 
 function defaultPosition(): { x: number; y: number } {
@@ -43,6 +61,8 @@ function getDefaultUIState(): TaskUIState {
           closed: true,
           theme: typeof parsed.theme === 'string' ? parsed.theme : 'native',
           showHints: parsed.showHints !== false,
+          // 视图页可恢复：它是"上次在看哪一页"，刷新后仍该停在那里（与 closed 不同）。
+          view: normalizeView(parsed.view),
         }
       }
     } catch { /* corrupt state — fall through to defaults */ }
@@ -54,6 +74,7 @@ function getDefaultUIState(): TaskUIState {
     closed: true,
     theme: 'native',
     showHints: true,
+    view: 'task',
   }
 }
 
@@ -98,6 +119,28 @@ export const taskUIStore = {
     open(): void {
       setUIState({ ...uiState, minimized: false, closed: false })
     },
+    /**
+     * 切页但不动开合状态（面板里那个循环按钮用）。
+     * 非法值一律忽略 —— 这个入口会被菜单行与脏 localStorage 碰到，静默归一比抛错合适。
+     */
+    setView(view: PanelView): void {
+      if (!(PANEL_VIEWS as readonly unknown[]).includes(view)) return
+      if (uiState.view === view) return
+      setUIState({ ...uiState, view })
+    },
+    /**
+     * 打开面板并切到指定页 —— `/` 菜单那三行的**全部**动作。
+     *
+     * 纯客户端：不再绕 `remote.commands.execute('/tasks insight list …')` 一圈。那条路
+     * 只在对话里留下一个命令节点，而客户端渲染命令节点的是按**命令名**分发的
+     * `TaskCommandNode`（`name === 'tasks'`），它拿任务解析器去解记忆载荷，解析必然失败
+     * —— 于是点菜单"开记忆页"什么都不会发生。
+     * @param view - 目标视图页；非法值直接忽略（不打开面板，避免"点了没反应还弹窗"）。
+     */
+    openView(view: PanelView): void {
+      if (!(PANEL_VIEWS as readonly unknown[]).includes(view)) return
+      setUIState({ ...uiState, view, minimized: false, closed: false })
+    },
     minimize(): void {
       setUIState({ ...uiState, minimized: true, closed: false })
     },