dsh-skill-tag 0.1.13 → 0.1.16

package/README.md

@@ -67,9 +67,16 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 <img src="https://cdn.jsdelivr.net/gh/aawef/dsh-skill-manager-tags@main/images/workspace-filter.png" width="900" alt="工作区管理标签双列界面">
 
 左列是标签条件，下面实时显示**解析结果**和状态「有条件筛选（严格子集）」；
-右列 `技能 (54)` 就是该工作区下发给模型的全部技能，每行可以「查看 tag」「禁用」，
-📁 直接打开技能所在文件夹。列表顶部的**搜索框**只过滤显示（标题会变成 `技能 (匹配/总数)`），
-不改动实际下发的技能集合。底部还能「+ 精细化添加技能」「查看被禁用的技能」。
+右列标题是 `技能 (54) · 模型可见 48`：前一个数是命中表达式的**全部技能**，
+后一个数是其中**真正下发给模型**的那些。两者不等时标题下方会多出橙色说明，
+列出差额的去向——`X 个只能 /名字 手动调用`（SKILL.md 里写了 `disable-model-invocation: true`）
+和 `Y 个宿主没注册`（扫描到了但宿主没装），对应行也会带 `仅手动` / `未注册` 徽标并置灰。
+还有第三种状态 `暂不可判定`：这一趟没拿到完整的宿主视角（比如该会话没在运行，
+宿主的 skill registry 只给了全局层），此时"没返回"不等于"没注册"，这些技能带灰色虚线徽标、
+**不置灰**，也不计入 `模型可见 N`。**这三种状态的区别与成因见下一节。**
+每行都可以「查看 tag」「禁用」，📁 直接打开技能所在文件夹。列表顶部的**搜索框**只过滤显示
+（标题会变成 `技能 (匹配/总数)`），不改动实际下发的技能集合。底部还能「+ 精细化添加技能」
+「查看被禁用的技能」。
 
 ### 图 6 · 对话「管理标签（对话）」：可以有自己的一份
 
@@ -78,6 +85,56 @@ office * plugin       # 只要 office 包带来的、且是插件相关
 同一个工作区下的某个对话想单独收窄，就在这里改：它会记下**继承来源**与时间
 （`改动不影响工作区`），左下角一键「继承工作区配置」覆盖回来。
 
+## 技能注册的三种状态：已注册 / 未注册 / 暂不可判定
+
+界面右列标题 `技能 (全部) · 模型可见 N` 里的 N，只数**已被宿主确认注册**的技能。
+而"未注册"和"暂不可判定"是两件完全不同的事，别把它们读成一句：
+
+| 状态 | 判据 | 界面表现 | 是否计入 `模型可见 N` |
+| --- | --- | --- | --- |
+| **已注册** | 这一趟宿主快照里**返回了这个名字** | 正常显示 | ✅ 计入 |
+| **未注册** | 宿主视角**完整**，但没返回这个名字 | 置灰 + 橙色「未注册」 | ❌ 不计入 |
+| **暂不可判定** | 这次没取到完整的宿主视角 | 灰色虚线徽标，**不置灰** | ❌ 不计入 |
+
+### 「宿主快照」是什么
+
+插件判断一个技能"模型能不能看到"，是去问宿主："这条技能你注册了吗？" ——
+宿主对这个问题的一次完整回答，就是一次**宿主快照**（宿主 `ctx.skills.snapshot()`
+返回的技能清单）。**没取到快照**＝这一问没有得到一个可信的完整回答，
+于是那批技能既不该标"已注册"（没证据），也不该标"未注册"（更没有证据）。
+
+### 为什么会取不到完整快照
+
+宿主的技能注册表是**分层**的：`global` 层 + 按 agent / preset 展开的层。
+不带 `scope` 去问时，宿主**只回 `global` 层**。而覆盖用户级技能根
+（`~/.dsh/skills`、`~/.agents/skills`）的那些 provider 恰好注册在 agent 层里 ——
+一旦 `scope` 传不下去，这些名字就**整段不在回答里**，"没返回"于是被误当成"没注册"。
+
+这是 0.1.15 修掉的缺陷（issue #1）：此前同一份本机文件，在有 live agent 的对话里是
+"已注册"，在没在跑的对话里就变成"宿主没注册，模型侧根本不存在"——仅仅换一个对话，
+结论就翻转。
+
+可能的触发原因，按实际出现频率排序：
+
+1. **该会话没有在运行**——历史对话、已关闭的标签页、或刚切过来还没起 agent。
+   `agents.list()` 里找不到它，`scope` 传不下去，宿主只给 global 层。这时列表顶部会
+   标注「该会话未运行，以下为全局视角」。
+2. **会话 ID 对不上**——浮层传的是 `session-<uuid>`，宿主 agent 暴露的 id 若是另一个
+   字符串（宿主侧依次取 `session.id` / `session.header.id` / `agent.id`），同样等于取不到 agent。
+3. **宿主自己报 `complete: false`**——宿主明确说这一趟没收集全（某个 provider 还在加载、
+   某个根扫描失败）。插件直接采用宿主的结论，整批降级为不可判定。
+4. **快照抛错或并发守卫被占**——`snapshotSkills()` 返回 null，插件退回纯文件系统自扫描；
+   这时它更没资格断言"宿主没注册"。
+5. **宿主确实没注册**——这种情况"暂不可判定"是保守过头了。但只要拿到完整视角，
+   插件就会给出明确的「未注册」，不会一直挂着。
+
+### 想看确定结论怎么办
+
+- 把对话切到**正在运行**的那个会话再看——它能拿到完整视角，用户级技能会恢复成"已注册"。
+- 设置页那种不带 `conversationId` 的口径本身就是全局视角，出现"暂不可判定"是预期行为。
+- 视角不完整时，`POST /skill-tag/api/skills/purge-stale` 会直接返回 `409 INCOMPLETE_VIEW`
+  而拒绝执行——因为它要靠"未注册"这个结论去删关联记录，视角不可信时删了就是误删。
+
 ## 安装
 
 这是一个 DSH（DeepSeek Harness）**插件**，装进 profile 后随宿主启动加载。
@@ -177,7 +234,8 @@ node tools/auto-tag.mjs ... --domain ./my-domain-map.json --apply # 连领域轴
 - **对话**：会话行的「…」菜单（图 1），或聊天框左下角「+」→「管理对话标签」（图 2）
 
 左列写标签条件表达式，右列是命中结果（可手动添加 / 禁用 / 恢复）。改完立刻生效：
-该对话下发给模型的技能列表就是右列那一份。两张双列界面见「图 5」「图 6」。
+该对话下发给模型的技能列表就是右列里**模型可见**的那一份（标题的第二段数字）。
+两张双列界面见「图 5」「图 6」。
 
 ### 3. 表达式语法
 
@@ -275,6 +333,7 @@ images/              README 用的界面截图（不进 npm 包）
 | [docs/对话管理标签.md](https://github.com/aawef/dsh-skill-manager-tags/blob/main/docs/%E5%AF%B9%E8%AF%9D%E7%AE%A1%E7%90%86%E6%A0%87%E7%AD%BE.md) | 对话级配置与继承 |
 | [docs/技能发现与宿主对齐.md](https://github.com/aawef/dsh-skill-manager-tags/blob/main/docs/%E6%8A%80%E8%83%BD%E5%8F%91%E7%8E%B0%E4%B8%8E%E5%AE%BF%E4%B8%BB%E5%AF%B9%E9%BD%90.md) | 为什么"插件看到的技能数"曾经少于宿主，以及怎么对齐 |
 | [docs/deny-shadow-覆盖率.md](https://github.com/aawef/dsh-skill-manager-tags/blob/main/docs/deny-shadow-%E8%A6%86%E7%9B%96%E7%8E%87.md) | 为什么包带来的技能会**静默漏网**（`path` 为 null 的那批），以及宿主对影子候选的强校验、层/rank 语义 |
+| [docs/修复指南.md](https://github.com/aawef/dsh-skill-manager-tags/blob/main/docs/%E4%BF%AE%E5%A4%8D%E6%8C%87%E5%8D%97.md) | **「打了标签技能却没出现」的排查手册**：三层判定树、transcript 逐帧解压取证、预设关闭默认技能根（A 层）、已知假阳性、升级回归清单 |
 | [docs/skill联系tag与打开文件夹.md](https://github.com/aawef/dsh-skill-manager-tags/blob/main/docs/skill%E8%81%94%E7%B3%BBtag%E4%B8%8E%E6%89%93%E5%BC%80%E6%96%87%E4%BB%B6%E5%A4%B9.md) | 两个方向编辑 + 📁 按钮 |
 | [CHANGELOG.md](https://github.com/aawef/dsh-skill-manager-tags/blob/main/CHANGELOG.md) | 按日期倒序的完整开发记录 |
 

package/docs//344/277/256/345/244/215/346/214/207/345/215/227.md

@@ -0,0 +1,214 @@
+# 修复指南：标签打对了，会话里却没有那个技能
+
+> 面向维护者。写于 2026-11-02，对应 CHANGELOG 尚未收录的一次线上排查（v0.1.13）。
+> 适用场景：**用户在某个会话上打了标签、或给某个工作区配了标签，但模型侧技能目录里
+> 根本没有那些名字**。本文给出判定树、逐项取证命令、以及三种可比选的修法。
+
+## 1. 先分清三种"没有"
+
+同样是"看不见"，根因完全不同。**在动手之前必须先定位到哪一层断的**，
+否则会去修一个没坏的地方（0.1.13 之后最常踩的坑）。
+
+| 层 | 断了的典型表现 | 判定依据 |
+| --- | --- | --- |
+| **A. 发现层**（技能根本没被扫到） | 该技能不在会话的技能目录里，且也不在 `/skill-tag/api/skills` 里 | 该技能的任何标签规则都不可能命中 |
+| **B. 匹配层**（扫到了，但被 deny） | 在 `/skills` 里出现，描述被加上 `[blocked by skill-tag]` | 标签条件没覆盖它，或被 `disabledSkills` 点了 |
+| **C. 生效层**（匹配了，标签压根没写进去） | `skill_tag.json` 里对话 `own.config` 不含那个标签 | 用户打到了工作区，但对话是冻结快照 |
+
+历史上 0.1.x 修过的 bug 几乎全在 B（`deny-shadow-覆盖率.md`）和"对话冻结"（`对话管理标签.md` §继承）。
+**A 这一层几乎没有文档**，而它恰恰是"我打了标签为什么没反应"最常见的答案。
+
+## 2. 判定树
+
+```
+模型侧技能目录里没有技能 X
+├─ X 在 GET /skill-tag/api/skills 里吗？
+│   ├─ 不在 → A 发现层。可能：该会话的预设/插件根本没扫描 X 所在目录
+│   └─ 在  → 继续
+│       ├─ X 的 description 以 "[blocked by skill-tag]" 开头吗？
+│       │   ├─ 是 → B 匹配层。看 effective.config 是否覆盖 X，看 disabledSkills
+│       │   └─ 否 → C 生效层。看该会话 own 是否真的写了标签
+```
+
+## 3. 取证命令（只读，按顺序打）
+
+端口每台机器不同，**不要猜**：用运行时上下文里的 Web GUI URL，或
+`Get-NetTCPConnection -State Listen | Where OwningProcess -eq <dsh pid>`。
+
+```powershell
+$b = "http://127.0.0.1:<PORT>/skill-tag/api"
+$cid = "session-xxxxxxxx-..."     # 用户报的那个会话 id
+
+# ① 全域技能表（不带 hint）：本插件认为自己"能看见"的全部技能
+curl.exe -s "$b/skills"                              > $env:TEMP\sk-all.json
+# ② 带会话 hint：等同该会话代理看到的集合
+curl.exe -s "$b/skills?conversationId=$cid"          > $env:TEMP\sk-conv.json
+# ③ 该会话的生效配置 + view + catalog
+curl.exe -s "$b/conversations/config?conversationId=$cid" > $env:TEMP\cfg.json
+# ④ 最终候选（走对话四区口径）
+curl.exe -s "$b/conversations/candidates?conversationId=$cid"
+```
+
+读 ① / ② 里的 `description` 前缀判 B 层；读 ③ 的 `config.orTags` 判 C 层；
+**① 和 ② 里都没有该名字**就是 A 层。
+
+### 3.1 模型侧到底看到了什么（唯一权威口供）
+
+`~/.dsh/storages/skill_tag.json` 和 `/conversations/config` 都是**本插件的口径**，
+可能和模型真实收到的不一致（见 §6.1 的假阳性）。真正的口供在会话 transcript 里：
+
+```powershell
+$f = "$env:USERPROFILE\.dsh\sessions\<编码后的cwd>\<sessionId>\session.v4.jsonl.zstd"
+$out = "$env:TEMP\sess.jsonl"
+node -e "const z=require('zlib'),fs=require('fs');
+  const b=fs.readFileSync(process.argv[1]);
+  const magic=Buffer.from([0x28,0xB5,0x2F,0xFD]); let idx=[],p=0;
+  while((p=b.indexOf(magic,p))!==-1){idx.push(p);p+=4;}
+  const parts=[]; for(let k=0;k<idx.length;k++){
+    const s=idx[k], e=(k+1<idx.length?idx[k+1]:b.length);
+    try{parts.push(z.zstdDecompressSync(b.subarray(s,e)).toString('utf8'))}catch{}
+  } fs.writeFileSync(process.argv[2], parts.join(''));" $f $out
+```
+
+然后 grep `<available_skills>`。那一条 user 消息就是模型收到的**完整技能目录** ——
+比对它的名字列表与 `/skills` 的差集，就能立刻分清"插件以为可见"和"模型真的可见"。
+
+> transcript 是**分帧 zstd**（一条消息一帧），整文件 `zstdDecompressSync` 只会解出第一帧
+> （通常只有 219 字节的 `{"type":"session"...}` header）。必须按 magic 逐帧解压，见上面的脚本。
+
+同一条 transcript 里还有 `agent-preset/selected` 事件，能看出该会话用的是哪个预设 ——
+A 层问题九成出在这里。
+
+## 4. A 层：发现层（最常见，也最容易被误判成插件 bug）
+
+### 4.1 根因：预设可以整体关闭默认技能根
+
+`@deepseek-ai/dsh-skill-filesystem` 的默认根（详见运行时文档 "Roots and priority"）：
+
+| Rank | Source | Path |
+| --- | --- | --- |
+| 100 | `project-dsh` | `<projectRoot>/.dsh/skills` |
+| 200 | `project-agents` | `<projectRoot>/.agents/skills` |
+| 300 | `custom` | `Config.customSkillDirs` |
+| 400 | `user-dsh` | `<dshHome>/skills` |
+| 500 | `user-agents` | `<agentsHome>/skills` |
+
+`includeDefaultRoots: false` 会把 100/200/400/500 **整排删掉**，只剩 `customSkillDirs`。
+
+于是任何写了这行的预设（本机实测：StudyMate 的「学习模式」、`@tt-a1i/archify-dsh` 的隔离根）
+都把 `~/.dsh/skills` 挡在门外。用户在那类会话上打 `来自:dsh-home` 之类的标签，
+**规则算得再对也没有对象可匹配** —— 因为早在发现阶段就没了。
+
+取证：
+
+```powershell
+# 1) 找该会话用的预设
+Select-String -Path "$env:USERPROFILE\.dsh\sessions\...\session.v4.jsonl" -Pattern "agent-preset/selected"
+# 2) 看那个预设有没有关默认根
+Select-String -Path "$env:USERPROFILE\.dsh\profiles\desktop\node_modules\<pkg>\preset\**\agent.cordis.yml" -Pattern "includeDefaultRoots"
+```
+
+### 4.2 三种修法
+
+| 方案 | 做法 | 代价 |
+| --- | --- | --- |
+| **A1** 全局放开 | 在 profile 的 `cordis.patch.yml` insert 一条独立 `dsh-skill-filesystem`（`providerName` 唯一、`includeDefaultRoots: true`） | 所有预设都吃到 `~/.dsh/skills`，预设原本的隔离设计被削弱 |
+| **A2** 追加额外根 | 在**该预设**的 `customSkillDirs` 末尾追加一个独立目录 | 改的是包目录，`pnpm update` 会覆盖 |
+| **A3** 换预设 | 让用户在该会话切到不隔离的预设 | 隔离带来的专属技能随之消失，可能整条流程跑不动 |
+
+**推荐 A2**，并且把"额外根"做成**用户自己的目录 + junction**，而不是往别人包里塞文件：
+
+```powershell
+# 1) 建一个自己的额外技能根，用 junction 指回真实技能（升级自动跟随，不会两份内容打架）
+$extra = "$env:USERPROFILE\.dsh\studymate-extra-skills"
+New-Item -ItemType Directory -Force -Path $extra | Out-Null
+foreach ($n in @('obsidian-markdown','obsidian-bases','obsidian-cli','json-canvas','defuddle','knap')) {
+  cmd /c mklink /J "$extra\$n" "$env:USERPROFILE\.dsh\skills\$n" | Out-Null
+}
+```
+
+```yaml
+# 2) 在目标预设的 skill-filesystem 行追加一条（保留原有占位符那行）
+- id: skill-filesystem
+  name: '@deepseek-ai/dsh-skill-filesystem'
+  config:
+    includeDefaultRoots: false
+    customSkillDirs:
+      - '__STUDYMATE_SKILLS__'
+      - 'C:\Users\ThinkPad\.dsh\studymate-extra-skills'   # 本地追加（非官方）
+```
+
+要点：
+
+- **路径用反斜杠**。YAML 单引号里 `\` 不转义，写正斜杠在 Windows 上也能被 Node 接受，
+  但和包内既有写法保持一致更省排查成本。
+- **预设是启动时装配的**，改完必须**重启桌面进程**（不是刷新页面）。
+- 改的是 `node_modules` 里的文件：`pnpm update <pkg>` 会把它整个换掉，那行会消失。
+  **升级后必须复查**（见 §7 回归清单）。备份文件名建议带时间戳：
+  `agent.cordis.yml.bak-before-extra-skills-<ISO>`。
+
+> 为什么 native 加载不会被启动流程覆盖：`bin/studymate.mjs` 的 `installPayload`
+> 把 `preset/<id>` 拷到临时目录后**在副本上**替换 `__STUDYMATE_SKILLS__`，
+> 包目录本身是只读材料（源码注释明确写了"原生加载也不写包目录"）。
+> 但它读的是包目录里的**当前内容**，所以手工改动会带进下次启动 —— 这点是好事，
+> 也是 A2 可行的前提。
+
+## 5. B 层：匹配层（0.1.x 已修过多轮，改动前先读旧文档）
+
+先读 `deny-shadow-覆盖率.md` 与 `技能发现与宿主对齐.md`。这里只列**判据**：
+
+- 运行时拒绝集 = `computeRuntimeDeniedSkillIds(effective, {universe, candidates, linkedSkillIds})`（`lib/index.js`）；
+- `effective` 只来自 **own**，永不回退工作区实时配置（2026-10-31 定的口径，见 `recomputeDenials` 注释）；
+- `own === null` = 从未配置 = 空条件 = 掌握全部技能。
+
+改这块之前先确认：**别把"own 为 null = 全部"这条改掉**。它是"看一眼就被冻结"那类老 bug 的解药。
+
+## 6. 已知缺陷
+
+> 0.1.14 修掉的是另一类错位：「界面按标签算命中、模型按 invocation 算下发」，
+> 现在右列标题会同时给出两个数，见 CHANGELOG 0.1.14。
+> 0.1.15 修掉了下面 6.1（issue #1），本条保留作历史缺陷记录；6.2 仍未修。
+
+### 6.1 对话面板假阳性：没有活跃 agent 时退回全局技能表（**0.1.15 已修**）
+
+`src/api.js` 的 `contextForConfig` 只把 `{conversationId}` 当 hint 传给
+`createSkillDiscoverer`，而后者在 `agentFor(conversationId)` 返回 null 时**直接退化成
+不带 `scope` 的宿主快照**（`lib/index.js` 的 `snapshotSkills`）：
+
+```js
+const scope = agentFor(hint?.conversationId);
+const snap = await hostRegistry.snapshot({ ...(cwd ? { cwd } : {}), ...(scope ? { scope } : {}) });
+```
+
+后果：会话没有在跑时打开「对话 → 管理标签」，面板展示的是**全局技能表**
+（例如 128 条，含 14 条标签命中），而该会话真实只有 10 条。用户看到"面板里明明有、
+模型里明明没有"，就是这个错位。
+
+修法（0.1.15 已实施）：`agentFor` 查不到 agent 时不再静默去掉 `scope`，而是把这一趟
+快照标记成**视角不完整**（发现器数组上的 `VIEW_COMPLETE` Symbol + 逐条 `registered: null`），
+界面把那一批标成「暂不可判定」并给对话入口加一句「该会话未运行，以下为全局视角」，
+「模型可见 N」也不再把它们算进去。判据与取舍见 CHANGELOG 0.1.15。
+
+### 6.2 `/workspaces/skills` 与 `/conversations/skills` 不存在
+
+客户端 `manageScope()` 会拼出 `skillsPrefix = "/conversations/skills"`，
+但服务端只有 `/conversations/skills/{add,remove,disable,enable}`。
+拿到裸前缀会 404（`{"ok":false,"error":"not found: /conversations/skills"}`）。
+这是良性的（客户端不请求裸前缀），但排查时容易被误导 —— 用它做健康检查会误判成插件没起来。
+
+## 7. 升级 / 重启后的回归清单
+
+`dsh-skill-tag` 或任何"提供技能根"的插件升级之后，按这个顺序跑一遍（5 分钟）：
+
+1. `GET /skill-tag/api/skills` 条数与升级前对比，突变超过 ±10 就该查。
+2. 目标会话的 `GET /conversations/config?conversationId=...` —
+   `expression` 是否还在、`expressionIssue.ok` 是否为 true（`false` = 引用了已删除/改名的标签）。
+3. 自建额外技能根是否还在：`Test-Path ~/.dsh/studymate-extra-skills`，
+   以及目标预设的 `customSkillDirs` 里那行是否被 update 冲掉。
+4. 拉一次目标会话 transcript，确认 `<available_skills>` 里有该有的名字（§3.1 脚本）。
+5. 重启桌面进程后重复 1-4（预设装配发生在启动时，不重启看不到变化）。
+
+## 8. 一句话总结
+
+> 标签只决定"匹配"，**不决定"发现"**。
+> 打上标签仍然看不见，先问：这个会话的技能根里，到底有没有这个技能。

package/lib/client.js

@@ -1149,14 +1149,18 @@ window.__ModuleLoader__.load({
 
 		/**
 		 * 判断一份菜单是不是宿主的工作区行菜单。
-		 * 宿主源码里它就是 [{id:"rename"},{id:"delete",danger:true}] 两项；
-		 * 会话行菜单项更多，且不含"删除工作区"。
+		 * 宿主源码里原本是 [{id:"rename"},{id:"delete",danger:true}] 两项，但项数会变：
+		 * 0.2.x 起中间插了「在文件夹显示」，于是 `labels.length !== 2` 把这份菜单整个漏掉，
+		 * 「管理标签」入口跟着消失（用户报告的 bug）。
+		 * 所以改成语义匹配，不绑项数：首项是「重命名」，且后面存在一项含「删除」。
+		 * 会话行菜单首项是「置顶」、且只有「归档」没有「删除」，仍会被排除。
 		 * @param {string[]} labels 各 menuitem 的可见文本
 		 */
 		function isWorkspaceMenu(labels) {
-			if (!Array.isArray(labels) || labels.length !== 2) return false;
-			const [first, second] = labels.map((s) => String(s ?? "").trim());
-			return /^(rename|重命名)$/i.test(first) && /(delete|删除)/i.test(second);
+			if (!Array.isArray(labels) || labels.length < 2) return false;
+			const first = String(labels[0] ?? "").trim();
+			if (!/^(rename|重命名)$/i.test(first)) return false;
+			return labels.slice(1).some((s) => /(delete|删除)/i.test(String(s ?? "")));
 		}
 
 		/** 「管理标签」菜单项按钮（内联样式模拟宿主菜单项，不依赖 CSS Module 类名） */
@@ -1504,7 +1508,7 @@ window.__ModuleLoader__.load({
 			const tags = base?.tags ?? [];
 			const links = base?.skillLinks ?? [];
 			const templates = base?.templates ?? [];
-			const view = ws?.view ?? { hasFilter: false, visible: [], manual: [], disabled: [] };
+			const view = ws?.view ?? { hasFilter: false, visible: [], manual: [], disabled: [], modelVisible: [], userOnly: [], unregistered: [], undeterminable: [] };
 			const expr = ws?.expression ?? "";
 			// 空表达式 = 无条件（不能说成 ∅，否则与"掌握全部技能"矛盾）
 			const parsed = !view.hasFilter ? "无条件（掌握全部技能）" : configDisplay({ tags }, ws?.config);
@@ -1512,12 +1516,28 @@ window.__ModuleLoader__.load({
 			const visibleSet = new Set(view.visible ?? []);
 			const disabledSet = new Set(ws?.disabledSkills ?? []);
 
+			// ── 两套口径（2026-11-02 用户报的 64 vs 48）─────────────────────────
+			// visible      = 标签选出来的（本插件自己的语义）
+			// modelVisible = visible 里模型真能看到的 = 去掉「只能 /name 手动调用」
+			//                与「宿主根本没注册」两类。右列标题只报这一份，
+			//                因为用户问的永远是"模型到底拿到几条"。
+			const modelVisible = view.modelVisible ?? view.visible ?? [];
+			const userOnlyMap = new Map((view.userOnly ?? []).map((r) => [r.name, r.reason ?? "disable-model-invocation"]));
+			const unregisteredSet = new Set(view.unregistered ?? []);
+			// 2026-11-03（#1）：宿主这一趟没拿到足够视角时，注册状态是**未知**。
+			// 它既不是"已注册"也不是"没注册"，界面上不能共用「未注册」那套断言措辞。
+			const undeterminableSet = new Set(view.undeterminable ?? []);
+
 			/** 可添加的技能：排除已有（可见）与被禁用的 */
 			const addable = (ws?.universe ?? []).filter((n) => !visibleSet.has(n) && !disabledSet.has(n));
 
 			// 右列搜索：仅过滤显示，不影响「技能 (总)」这个语义数字
 			const skillQuery = skillSearch.trim().toLowerCase();
 			const shownSkills = (view.visible ?? []).filter((n) => !skillQuery || String(n).toLowerCase().includes(skillQuery));
+			const modelVisibleCount = modelVisible.length;
+			const userOnlyCount = userOnlyMap.size;
+			const unregisteredCount = unregisteredSet.size;
+			const undeterminableCount = undeterminableSet.size;
 
 			// 技能名 → SKILL.md 路径（服务端把扫描结果的 path 一并带回来了）
 			const catalog = ws?.catalog ?? [];
@@ -1587,8 +1607,25 @@ window.__ModuleLoader__.load({
 					react.createElement("div", { key: "right", style: colStyle }, [
 						react.createElement("div", { key: "h", style: { fontWeight: 600, marginBottom: "8px" } },
 							skillQuery
-								? `技能 (${shownSkills.length}/${(view.visible ?? []).length})`
-								: `技能 (${(view.visible ?? []).length})`),
+								? `技能 (${shownSkills.length}/${(view.visible ?? []).length}) · 模型可见 ${modelVisibleCount}`
+								: `技能 (${(view.visible ?? []).length}) · 模型可见 ${modelVisibleCount}`),
+						// 两套口径不一致时必须讲清差在哪，否则用户只会看到"数字对不上"。
+						(userOnlyCount > 0 || unregisteredCount > 0 || undeterminableCount > 0) && react.createElement("div", {
+							key: "gap",
+							style: { color: "#e67e22", fontSize: "11px", marginBottom: "6px", lineHeight: "1.5" },
+						}, [
+							userOnlyCount > 0 && react.createElement("div", { key: "u" },
+								`其中 ${userOnlyCount} 个只能 /名字 手动调用（disable-model-invocation），模型不会自己看到`),
+							unregisteredCount > 0 && react.createElement("div", { key: "r" },
+								`其中 ${unregisteredCount} 个本机有、但宿主没注册，模型侧根本不存在`),
+							// 2026-11-03（#1）：三种状态各说各话，绝不共用「宿主没注册」这句断言。
+							undeterminableCount > 0 && react.createElement("div", {
+								key: "ud", style: { color: "#888" },
+								title: "这一趟没拿到宿主技能的完整快照（会话未运行 / 拿不到 agent 视角），注册状态未知",
+							}, scope.isConv
+								? `该会话未运行，以下为全局视角：${undeterminableCount} 个本次未取到宿主快照，暂不可判定（不代表没注册）`
+								: `其中 ${undeterminableCount} 个本次未取到宿主快照，暂不可判定（不代表没注册）`),
+						]),
 						// 搜索框：放列表顶部，只过滤显示（不改变实际下发的技能集合）
 						react.createElement("div", { key: "search", style: { display: "flex", gap: "6px", alignItems: "center", marginBottom: "6px" } }, [
 							react.createElement("input", {
@@ -1605,9 +1642,31 @@ window.__ModuleLoader__.load({
 								"没有技能。可在下方「+ 精细化添加技能」手动加入，或清空标签条件回到全部技能。"),
 							(view.visible ?? []).length > 0 && shownSkills.length === 0 && react.createElement("div", { key: "nf", style: { color: "#888", fontSize: "12px" } },
 								`没有匹配「${skillSearch.trim()}」的技能。`),
-							...shownSkills.map((name) => react.createElement("div", { key: name, style: { ...listRow, flexWrap: "wrap" } }, [
-								react.createElement("span", { key: "n", style: { flex: 1 } }, name),
+							...shownSkills.map((name) => {
+								const onlyManual = userOnlyMap.has(name);
+								const notRegistered = unregisteredSet.has(name);
+								// 未知 ≠ 未注册：不知道该不该置灰，就不置灰（2026-11-03 #1）。
+								const undetermined = undeterminableSet.has(name);
+								return react.createElement("div", { key: name, style: { ...listRow, flexWrap: "wrap" } }, [
+								react.createElement("span", { key: "n", style: { flex: 1, color: (onlyManual || notRegistered) ? "#888" : "inherit" } }, name),
+								// 逐行标注它为什么不在「模型可见」那一份里，避免用户以为插件少发了。
+								notRegistered && react.createElement("span", {
+									key: "nr",
+									style: { color: "#e67e22", fontSize: "10px", border: "1px solid rgba(230,126,34,0.5)", borderRadius: "4px", padding: "0 4px" },
+									title: "宿主 skills 注册表里没有这个名字：本机文件存在，但模型侧看不到（插件范围外）",
+								}, "未注册"),
+								!notRegistered && undetermined && react.createElement("span", {
+									key: "ud",
+									style: { color: "#888", fontSize: "10px", border: "1px dashed rgba(136,136,136,0.6)", borderRadius: "4px", padding: "0 4px" },
+									title: "这一趟没拿到宿主技能的完整快照（会话未运行 / 拿不到 agent 视角），它到底注没注册还不知道",
+								}, "暂不可判定"),
+								!notRegistered && !undetermined && onlyManual && react.createElement("span", {
+									key: "uo",
+									style: { color: "#9b59b6", fontSize: "10px", border: "1px solid rgba(155,89,182,0.5)", borderRadius: "4px", padding: "0 4px" },
+									title: "SKILL.md 写了 disable-model-invocation: true：模型不会自动看到，只能由你用 /名字 手动调用",
+								}, "仅手动"),
 								manualSet.has(name) && react.createElement("span", { key: "m", style: { color: "#3498db", fontSize: "11px" } }, "手动"),
+								// 说明这一行到底进没进"下发给模型"那一份。
 								react.createElement(RevealButton, { key: "rev", skillName: name, path: pathOf(name), label: "📁" }),
 								react.createElement("button", {
 									key: "t", style: { ...btn, padding: "1px 7px", fontSize: "11px" },
@@ -1619,7 +1678,8 @@ window.__ModuleLoader__.load({
 								}, "禁用"),
 								tagOfSkill === name && react.createElement("div", { key: "tags", style: { flexBasis: "100%", color: "#888", fontSize: "11px", padding: "2px 0 2px 8px" } },
 									(tagsOf(name).length ? "tag: " + tagsOf(name).join(", ") : "该技能没有任何 tag")),
-							])),
+							]);
+							}),
 						]),
 						react.createElement("div", { key: "f", style: { display: "flex", gap: "8px", flexWrap: "wrap", paddingTop: "8px", borderTop: "1px solid var(--theme-border,#222)" } }, [
 							react.createElement("button", { key: "add", style: btn, disabled: busy, onClick: () => setPickOpen(true) }, "+ 精细化添加技能"),

package/lib/index.js

@@ -18,7 +18,10 @@ import { skillTagDomain } from "../src/storage/schema.js";
 import { createDshRepository, serializeConversation, deserializeConversation } from "../src/storage/repository.js";
 import { createServices } from "../src/service.js";
 import { groupIdOf } from "../src/domain/model.js";
-import { workspaceDeniedSkills, workspaceSkillView, normalizeWorkspacePath, activeTagsOf } from "../src/domain/workspace.js";
+import { workspaceDeniedSkills, workspaceSkillView, normalizeWorkspacePath, activeTagsOf, attachView, viewIsComplete, mergeRegistered } from "../src/domain/workspace.js";
+
+// 供调用方/测试读「这一趟宿主视角可不可信」。实现落在 src/domain/workspace.js（纯函数可单测）。
+export { attachView, viewIsComplete, mergeRegistered } from "../src/domain/workspace.js";
 import { candidatesFor } from "../src/domain/match.js";
 import { mountApi } from "../src/api.js";
 import { scanSkillRoots } from "../src/skill-scan.js";
@@ -451,7 +454,15 @@ export function createSkillDiscoverer({ hostRegistry, rootsScan, agents = null,
 					...(cwd ? { cwd } : {}),
 					...(scope ? { scope } : {}),
 				});
-				return Array.isArray(snap?.skills) ? snap.skills : [];
+				const skills = Array.isArray(snap?.skills) ? snap.skills : [];
+				// 视角是否可信（2026-11-03 #1）：宿主只有拿到 scope 才会把 agent 层
+				// 并进来；没 scope 时它只给 global 层，而覆盖用户级技能根的 provider
+				// 如果注册在 agent 层，那些名字**整段不会出现**。另外宿主自己也会用
+				// complete:false 告诉我们这趟没收集全。两种情况下"没返回"≠"没注册"。
+				const scoped = Boolean(scope);
+				const complete = snap?.complete !== false;
+				attachView(skills, scoped && complete);
+				return skills;
 			} catch {
 				return null; // registry 未就绪 → 调用方退回自扫描
 			} finally { nesting.depth -= 1; }
@@ -465,32 +476,54 @@ export function createSkillDiscoverer({ hostRegistry, rootsScan, agents = null,
 	}
 	return async function discoverSkills(cwd, hint) {
 		const out = new Map();
-		const put = (s) => {
+		/**
+		 * registered 标记是本函数的核心诚实性（2026-11-02 缺陷 2）：
+		 *   true  = 这条来自宿主 skills registry，模型侧真有可能拿到它；
+		 *   false = 只有自扫描看得到，宿主压根没注册 —— 模型永远看不到。
+		 * 前端据此把后者单独列成「本机有、宿主未注册」，不再混进「下发给模型 N」。
+		 */
+		const put = (s, registered) => {
 			const name = typeof s === "string" ? s : s?.name;
 			if (!name) return;
+			const prev = out.get(name);
 			out.set(name, {
 				name,
 				description: typeof s === "string" ? "" : (s?.description ?? ""),
 				path: typeof s === "string" ? null : (s?.path ?? null),
 				source: typeof s === "string" ? null : (s?.source ?? null),
+				// 宿主给的 invocation 策略（disable-model-invocation / user-invocable）；
+				// 自扫描时由 skill-scan 从 frontmatter 解析，缺省视为可调用。
+				invocation: (typeof s === "string" ? null : s?.invocation) ?? prev?.invocation ?? null,
+				// 三态合并，优先级 true > null > false：
+				//   宿主这趟返回了 → true（唯一确凿的"模型侧确实有"）
+				//   宿主这趟没返回、但视角不完整 → null（不知道，别说成没有）
+				//   宿主视角完整且没返回 → false（真·未注册）
+				registered: mergeRegistered(registered, prev?.registered),
 			});
 		};
 		// 1) 宿主注册表（权威，与模型侧同源）
 		const key = `${cwd ?? ""}::${hint?.conversationId ?? ""}`;
 		const pending = inFlight.get(key) ?? snapshotSkills(cwd, hint, key);
 		const hostSkills = await pending;
-		if (Array.isArray(hostSkills)) for (const s of hostSkills) put(s);
+		// 这一趟宿主视角可信吗？
+		//   宿主压根没装 skills 服务 → 谁都没注册，"false" 就是字面事实，保持旧口径；
+		//   问了但抛错 / 守卫被占（null）→ 不知道，不可信；
+		//   拿到数组 → 听宿主自己的 complete 标记。
+		const complete = !hostRegistry
+			? true
+			: (Array.isArray(hostSkills) && viewIsComplete(hostSkills));
+		if (Array.isArray(hostSkills)) for (const s of hostSkills) put(s, true);
 		// 2) 自扫描补缺（不同名才补）
 		if (rootsScan) {
 			try {
 				const scanned = rootsScan({ cwd }) ?? [];
 				for (const s of scanned) {
 					const name = typeof s === "string" ? s : s?.name;
-					if (name && !out.has(name)) put(s);
+					if (name && !out.has(name)) put(s, complete ? false : null);
 				}
 			} catch { /* 扫不动就算了 */ }
 		}
-		return [...out.values()];
+		return attachView([...out.values()], complete);
 	};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-skill-tag",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "给 DSH 的技能（skill）打标签，用一条布尔表达式在「工作区 / 对话」两级选出要下发给模型的技能子集",
   "type": "module",
   "main": "lib/index.js",

package/src/api.js

@@ -6,9 +6,29 @@
 // should not 404 on POST-only clients either way).
 
 import { candidatesFor } from "./domain/match.js";
-import { activeTagsOf } from "./domain/workspace.js";
+import { activeTagsOf, viewIsComplete } from "./domain/workspace.js";
 import { revealInExplorer } from "./reveal.js";
 
+/**
+ * 把 registered 归一成三态（2026-11-03 #1）。
+ *
+ *   true  = 宿主确认注册了
+ *   false = 宿主确认没注册（只有自扫描看得见）
+ *   null  = 这趟没问到，状态未知
+ *
+ * 缺省（undefined）按 **true** 处理：没带这个字段的调用方（测试面 / 老版本
+ * discoverer / 宿主快照里的裸名字）说明它不掌握注册信息，不能因此把整个右列
+ * 误判成「宿主未注册」。这条缺省口径以前散在调用点的注释里，收进函数更安全。
+ *
+ * @param {boolean|null|undefined} value
+ * @returns {boolean|null}
+ */
+function coerceRegistered(value) {
+	if (value === false) return false;
+	if (value === null) return null;
+	return true;
+}
+
 /** 对外暴露的工作区形状（前端双列界面直接消费） */
 function wsShape(ws) {
 	return {
@@ -92,8 +112,24 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 				listed = [];
 			}
 		}
+		// 2026-11-03（#1）：这一趟宿主视角可不可信，决定 registered 能不能被当成
+		// "未注册"来读。发现器用 Symbol 挂在数组上（不进 JSON），listSkills 就是它。
+		const registryUnavailable = !viewIsComplete(listed);
+		// 2026-11-02（缺陷 1+2）：catalog 必须带两样以前被丢掉的元数据，
+		// 否则前端无法区分「标签可见」与「模型可见」——
+		//   invocation: 宿主/扫描解析出的 {modelInvocable, userInvocable}
+		//   registered: 是否来自宿主 skills registry（自扫描兜底的 = false）
 		const catalog = listed
-			.map((s) => (typeof s === "string" ? { name: s, path: null, source: null } : { name: s?.name, path: s?.path ?? null, source: s?.source ?? null }))
+			.map((s) => (typeof s === "string"
+				? { name: s, path: null, source: null, invocation: null, registered: false }
+				: {
+					name: s?.name,
+					path: s?.path ?? null,
+					source: s?.source ?? null,
+					invocation: s?.invocation ?? null,
+					// 三态透传，归一规则见 coerceRegistered。
+					registered: coerceRegistered(s?.registered),
+				}))
 			.filter((s) => Boolean(s.name));
 		const universe = catalog.map((s) => s.name);
 		const links = [...services._caches.skillLinks.values()];
@@ -102,8 +138,9 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 			config: config ?? { orTags: [], andGroups: [] },
 			active: activeTagsOf(config),
 		});
-		// catalog 让前端能把「打开技能文件夹」按钮直接接到 path（不必再扫一遍）
-		return { universe, candidates, catalog };
+		// catalog 让前端能把「打开技能文件夹」按钮直接接到 path（不必再扫一遍）；
+		// registryUnavailable 让视图层知道这趟的 registered 能不能当"没有"读。
+		return { universe, candidates, catalog, registryUnavailable };
 	}
 	async function skillContext(ws) {
 		return contextForConfig(ws?.config, workspacePathOf(ws), {
@@ -267,16 +304,21 @@ export function createApiHandler(services, log, listSkills = null, resolveWorksp
 			// 为什么不在 GET 里顺手删：关联是用户手工打的标签，插件的临时缺席不等于
 			// 用户放弃它。默认只标记，删除必须显式触发。
 			if (path === "/skills/purge-stale" && method === "POST") {
-				const live = new Set(
-					((listSkills ? await listSkills(q("cwd") ?? undefined, {
-						conversationId: q("conversationId") ?? null,
-						workspaceId: q("workspaceId") ?? null,
-					}) : []) ?? []).map((s) => (typeof s === "string" ? s : s?.name)),
-				);
+				const discovered = (listSkills ? await listSkills(q("cwd") ?? undefined, {
+					conversationId: q("conversationId") ?? null,
+					workspaceId: q("workspaceId") ?? null,
+				}) : []) ?? [];
+				const live = new Set(discovered.map((s) => (typeof s === "string" ? s : s?.name)));
 				// 发现结果为空 = 宿主没就绪，此时"全是失效"是误判，绝不动数据。
 				if (live.size === 0) {
 					return json(res, 409, { ok: false, code: "NO_SKILLS", error: "当前发现到 0 个技能，拒绝清理（可能是宿主未就绪）" });
 				}
+				// 2026-11-03（#1 的第二个出口）：发现结果**不算全**时 live 偏小、stale 偏大，
+				// 删下去会误伤还活着的关联。同一根因：没拿到 agent scope 时宿主只给 global 层。
+				// 这里不下手，让用户换到能解析 scope 的入口再点。
+				if (!viewIsComplete(discovered)) {
+					return json(res, 409, { ok: false, code: "INCOMPLETE_VIEW", error: "这趟没有拿到完整的技能视角（可能该会话未运行），拒绝清理，以免误删仍然有效的关联" });
+				}
 				const wanted = Array.isArray(body?.skillIds) ? new Set(body.skillIds.map(String)) : null;
 				const removed = [];
 				for (const link of [...services._caches.skillLinks.values()]) {

package/src/domain/workspace.js

@@ -83,6 +83,118 @@ export function workspaceSkillView({ config, manualSkills, disabledSkills, candi
 	return { hasFilter: filter, matched, manual: manualVisible, disabled, visible };
 }
 
+/**
+ * 「这一趟宿主视角可不可信」的非枚举旁注。
+ *
+ * 为什么不塞进每个 skill 对象（2026-11-03 #1）：发现器返回的是 set 出来的普通数组，
+ * 加一个 skills.undeterminable = true 这种裸属性会被 [...out] / JSON 序列化
+ * 悄悄丢掉，调用方永远读不到。用 Symbol 挂在数组上，既能随数组一起传下去，
+ * 又不会污染 JSON（REST 响应里每条技能的形状必须保持干净）。
+ */
+export const VIEW_COMPLETE = Symbol.for("dsh-skill-tag.viewComplete");
+
+/**
+ * 给技能数组打上「视角是否完整」的记号。
+ * @param {object[]} skills
+ * @param {boolean} complete  true = 宿主确认这趟看得全；false = 没问到 / 只拿到 global 层
+ */
+export function attachView(skills, complete) {
+	try {
+		Object.defineProperty(skills, VIEW_COMPLETE, { value: complete === true, enumerable: false, configurable: true });
+	} catch { /* 冻结数组之类打不上记号：退回默认口径（=完整），与没打过记号的数组一致 */ }
+	return skills;
+}
+
+/**
+ * 读 attachView 打的记号。没打过 = true（老调用方 / 测试面的默认口径）。
+ *
+ * ⚠️ 记号只在**同一个数组实例**上有效：发现器返回的数组被原样交给调用方即可，
+ * 一旦被 filter / slice / map 复制过，记号就丢了、退回默认的"完整"。
+ * 所以读它之前不要复制数组（`src/api.js` 里 listSkills 的返回值直接用）。
+ */
+export function viewIsComplete(skills) {
+	return Array.isArray(skills) ? skills[VIEW_COMPLETE] !== false : false;
+}
+
+/**
+ * 三态合并：true > null > false。
+ * 一条技能可能被 put 多次（宿主命中一次、自扫描再补一次），取"最有信息量的那个"。
+ * @param {boolean|null|undefined} incoming
+ * @param {boolean|null|undefined} prev
+ * @returns {boolean|null}
+ */
+export function mergeRegistered(incoming, prev) {
+	if (incoming === true || prev === true) return true;
+	if (incoming === null || prev === null) return null;
+	if (incoming === undefined) return prev ?? null;
+	return false;
+}
+
+/**
+ * 把「标签选出的可见集合」再按**宿主的下发口径**切一刀。
+ *
+ * 背景（2026-11-02 用户报告的 64 vs 48）：右列长期只有一层「标签过滤」，
+ * 而模型侧拿到的是 `snapshot().skills.filter(isModelInvocable)` —— 两道闸：
+ *   ​① frontmatter 的 `disable-model-invocation: true`（只能 `/name` 手动调用）
+ *   ​② 宿主根本不认识的名字（插件自扫描补进来的，宿主 registry 里没有）
+ * 于是「右列 N 条」永远大于「模型实际 N 条」。这里把口径拆开，不再让前端
+ * 把两者混成一个数字。
+ *
+ * 注意：这**只影响展示口径**。deny-shadow 的分母仍是 world universe − visible，
+ * 不能拿 modelVisible 去算，否则那些只能手动调用的技能会重新变回可见。
+ *
+ * 第三种状态（2026-11-03，#1）：「不可判定」。宿主快照这一趟**没拿到足够视角**
+ * 时（会话没有 live agent、agent scope 解析不到、registry 未就绪），宿主没返回的
+ * 名字只说明"这次没问到"，不等于"宿主没注册"。此时既不能进 unregistered
+ * （那是在断言模型侧根本不存在），也不能算模型可见 —— 单列一类，由界面说清楚。
+ *
+ * @param {string[]} visible 标签口径下的可见技能名
+ * @param {Array<{name:string, invocation?:{modelInvocable?:boolean}, registered?:boolean|null}>} [catalog]
+ *        技能目录（宿主快照 ∪ 自扫描兜底的合并结果）。registered=null 表示不可判定
+ * @param {{registryUnavailable?:boolean}} [options]
+ *        registryUnavailable=true 表示这一趟宿主快照**不完整**（没拿到 agent scope 等）。
+ *        它只让"宿主没返回"变得不可信：宿主这趟明确返回过的条目结论照旧，
+ *        其余条目（含自扫描补的 false）一律降级为不可判定。
+ * @returns {{modelVisible:string[], userOnly:{name:string,reason:string}[], unregistered:string[], undeterminable:string[]}}
+ */
+export function splitModelVisible(visible, catalog = [], options = {}) {
+	const byName = new Map();
+	for (const s of catalog ?? []) {
+		const name = typeof s === "string" ? s : s?.name;
+		if (name) byName.set(name, typeof s === "string" ? { name } : s);
+	}
+	const registryUnavailable = options?.registryUnavailable === true;
+	const modelVisible = [];
+	const userOnly = [];
+	const unregistered = [];
+	const undeterminable = [];
+	for (const name of normalizeSkillIds(visible)) {
+		const entry = byName.get(name);
+		// 宿主这趟**明确返回过**这个名字 → 视角不全也不影响这条结论，照常判（2026-11-03 复核）。
+		// 视角不全只让"没返回"变得不可信，不能让已知的事实一起变成未知。
+		if (entry && entry.registered === true) {
+			if (entry?.invocation?.modelInvocable === false) {
+				userOnly.push({ name, reason: "disable-model-invocation" });
+				continue;
+			}
+			modelVisible.push(name);
+			continue;
+		}
+		// 自扫描兜底补进来的名字：宿主 registry 里没有 → 模型侧根本不存在。
+		// 但这只在"视角完整"时成立；视角不全时它可能是"没问到"，降级为未知。
+		if (entry && entry.registered === false && !registryUnavailable) { unregistered.push(name); continue; }
+		// 显式未知，或视角不全导致"没问到"：连"宿主认不认这个名字"都没问清，
+		// 谈不上模型可见或仅手动。
+		if (registryUnavailable || (entry && entry.registered === null)) { undeterminable.push(name); continue; }
+		if (entry?.invocation?.modelInvocable === false) {
+			userOnly.push({ name, reason: "disable-model-invocation" });
+			continue;
+		}
+		modelVisible.push(name);
+	}
+	return { modelVisible, userOnly, unregistered, undeterminable };
+}
+
 /**
  * 该工作区应被 deny-shadow（真正屏蔽）的技能名集合。
  * denied = universe − visible，再并上 disabled（禁用的名字即使不在 universe 里也要屏蔽）。

package/src/service.js

@@ -19,7 +19,7 @@ import {
 	detachFromWorkspace,
 } from "./domain/sync.js";
 import { candidatesFor } from "./domain/match.js";
-import { workspaceSkillView, workspaceDeniedSkills } from "./domain/workspace.js";
+import { workspaceSkillView, workspaceDeniedSkills, splitModelVisible } from "./domain/workspace.js";
 import {
 	validateExpression, evaluateDnf, configToExpression, renameTagInExpression,
 	removeTagFromExpression,
@@ -565,13 +565,16 @@ export function createServices(repo, opts = {}) {
 		view(workspaceId, ctx = {}) {
 			const ws = workspaces.get(workspaceId);
 			const config = ws?.config ?? emptyTagConfig();
-			return workspaceSkillView({
+			const view = workspaceSkillView({
 				config,
 				manualSkills: ws?.manualSkills ?? [],
 				disabledSkills: ws?.disabledSkills ?? [],
 				candidates: ctx.candidates ?? [],
 				universe: ctx.universe ?? [],
 			});
+			// 口径拆分：visible 是「标签选出来的」，modelVisible 是「模型真能看到的」。
+			// 两者不等时（disable-model-invocation / 宿主不认识的技能），前端必须分开显示。
+			return { ...view, ...splitModelVisible(view.visible, ctx.catalog ?? [], { registryUnavailable: ctx.registryUnavailable === true }) };
 		},
 		/** 该工作区应被屏蔽的技能名集合（供 deny-shadow 使用） */
 		denied(workspaceId, ctx = {}) {
@@ -847,13 +850,14 @@ export function createServices(repo, opts = {}) {
 		/** 对话页右列数据源（与工作区共用同一份领域实现）。 */
 		ownView(conversationId, ctx = {}) {
 			const o = this.own(conversationId) ?? emptyOwnConfig();
-			return workspaceSkillView({
+			const view = workspaceSkillView({
 				config: o.config,
 				manualSkills: o.manualSkills,
 				disabledSkills: o.disabledSkills,
 				candidates: ctx.candidates ?? [],
 				universe: ctx.universe ?? [],
 			});
+			return { ...view, ...splitModelVisible(view.visible, ctx.catalog ?? [], { registryUnavailable: ctx.registryUnavailable === true }) };
 		},
 		/** 该对话应被 deny-shadow 的技能名集合。 */
 		ownDenied(conversationId, ctx = {}) {

package/src/skill-scan.js

@@ -84,10 +84,38 @@ function pushSkill(out, mdPath, root, disabled, fallbackName) {
 		description: fm?.description ?? "",
 		path: mdPath,
 		source: root,
+		invocation: invocationOf(fm),
 		...(disabled ? { disabled: true } : {}),
 	});
 }
 
+/**
+ * frontmatter → invocation 策略，与宿主 parseInvocationPolicy
+ * (dsh-skill-filesystem/lib/index.js:852-862) 同一口径：
+ *   disable-model-invocation: true  → modelInvocable = false
+ *   user-invocable: false           → userInvocable  = false
+ * 模型看不到、只能用 /name 手动调用的技能，必须在扫描结果里就带上这个标记，
+ * 否则插件会把它们算进「下发给模型的技能」（2026-11-02 的 64 vs 48）。
+ *
+ * @param {Record<string,string>|null} fm
+ * @returns {{modelInvocable:boolean, userInvocable:boolean}}
+ */
+export function invocationOf(fm) {
+	const disableModel = frontmatterFlag(fm, "disable-model-invocation");
+	const userInvocable = frontmatterFlag(fm, "user-invocable");
+	return { modelInvocable: disableModel !== true, userInvocable: userInvocable !== false };
+}
+
+/** frontmatter 布尔（宿主认 true/1/yes/on 与 false/0/no/off 两种写法） */
+function frontmatterFlag(fm, key) {
+	const raw = fm?.[key];
+	if (raw === undefined || raw === null || raw === "") return undefined;
+	const v = String(raw).trim().toLowerCase();
+	if (v === "true" || v === "yes" || v === "on" || v === "1") return true;
+	if (v === "false" || v === "no" || v === "off" || v === "0") return false;
+	return undefined;
+}
+
 function isFile(p) {
 	try { return fs.statSync(p).isFile(); } catch { return false; }
 }