@michengai/dsh-skills-manager 0.1.33 → 0.1.34

package/CHANGELOG.md

@@ -6,6 +6,16 @@ The five most recent published versions are listed below.
 
 ## Unreleased
 
+## 0.1.34 — 2026-09-02
+
+- Made direct Skill entries the canonical owner when the same real bundle is also exposed through Agent distribution links. The canonical provider candidate inherits the strongest distribution rank, so disabling CC Switch cannot fall back to a linked public-Agent copy.
+- Required discovered real bundle and document paths for both user and project Provider candidates, revalidated both paths at load time, and aligned policy toggles with real-document reads.
+- Scanned user roots concurrently and reused one resolved set of trusted read-only roots per scan without caching external filesystem state across requests.
+- Preserved a per-Skill disable while its current distribution entry changes ownership to a canonical source. A canonical source's explicit policy still takes precedence over inherited distribution-link policies.
+- Made detail visibility reproduce the same user-root deduplication as state snapshots from the requested entry's physical owner, avoiding unrelated Skill document reads; entry resolution, detail reads, and Provider reads fail closed when files disappear during a filesystem race.
+
+Published package: [`@michengai/dsh-skills-manager@0.1.34`](https://www.npmjs.com/package/@michengai/dsh-skills-manager/v/0.1.34).
+
 ## 0.1.33 — 2026-09-02
 
 - Added an enabled-by-default, read-only `CC Switch` source at `~\.cc-switch\skills` with source-wide and per-Skill local policy toggles. Legacy state files gain the new source without failing closed.

package/CHANGELOG.zh-CN.md

@@ -6,6 +6,16 @@
 
 ## 未发布
 
+## 0.1.34 — 2026-09-02
+
+- 同一真实 Skill 同时存在直接条目和 Agent 分发链接时，改为由直接条目归属；规范候选继承所有分发入口中的最强 rank，停用 CC Switch 后不会回流到公共 Agent 链接副本。
+- 用户级与项目级 Provider 候选必须携带扫描时发现的真实 bundle 和文档路径，加载时同时复验；启停读取也统一使用真实文档路径。
+- 用户根改为并发扫描，并在单次扫描内复用已解析的受信只读根；不跨请求缓存外部文件系统状态。
+- 当前分发条目归属迁移到规范来源时，保留原来源的逐 Skill 停用；规范来源自身的显式策略优先于继承的分发链接策略。
+- 详情接口按被请求条目的物理所有者复现状态快照的用户根去重结果，避免读取无关 Skill 文档；文件在扫描后消失时，条目解析、详情读取和 Provider 读取均失败关闭。
+
+发布包：[`@michengai/dsh-skills-manager@0.1.34`](https://www.npmjs.com/package/@michengai/dsh-skills-manager/v/0.1.34)。
+
 ## 0.1.33 — 2026-09-02
 
 - 新增默认开启的只读 `CC Switch` 来源，固定读取 `~\.cc-switch\skills`，支持来源级与逐 Skill 本地启停；旧状态文件自动补齐新来源，不会因缺少新键失败关闭。

package/lib/core.js

@@ -77,7 +77,7 @@ export function userRoots() {
 }
 
 function projectIdentity(path) {
-  const canonical = process.platform === "win32" ? resolve(path).toLowerCase() : resolve(path);
+  const canonical = pathIdentity(path);
   return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 
@@ -127,7 +127,7 @@ export async function projectRoots(projectCwds = [], diagnostics) {
       }
       continue;
     }
-    const identity = process.platform === "win32" ? found.root.toLowerCase() : found.root;
+    const identity = pathIdentity(found.root);
     const existing = projects.get(identity) || { root: found.root, cwds: new Set() };
     existing.cwds.add(found.cwd);
     projects.set(identity, existing);
@@ -350,11 +350,26 @@ async function lstatOrNull(path) {
   }
 }
 
+/** 预解析可作为用户级链接目标的只读根，供一次扫描中的所有链接复用。 */
+async function resolvedReadonlyUserRoots() {
+  const roots = userRoots().filter((root) => !root.mutable && root.scope !== "project");
+  const resolvedRoots = await Promise.all(roots.map(async (root) => {
+    const stat = await lstatOrNull(root.path);
+    if (!stat || !stat.isDirectory() || stat.isSymbolicLink()) return null;
+    try {
+      return { root, realPath: await fs.realpath(root.path) };
+    } catch {
+      return null;
+    }
+  }));
+  return resolvedRoots.filter(Boolean);
+}
+
 /**
  * 只接受用户级只读来源中的顶层目录链接，且目标必须是另一个已知只读 Skills 根的直接子目录。
  * 这样可以兼容 CC Switch 的分发链接，同时不把任意文件系统路径扩展成技能来源。
  */
-async function resolveTrustedLinkedBundle(root, bundlePath) {
+async function resolveTrustedLinkedBundle(root, bundlePath, trustedReadonlyRoots = resolvedReadonlyUserRoots()) {
   const sourceRoot = rootDefinition(root);
   if (!sourceRoot || sourceRoot.mutable || sourceRoot.scope === "project") return null;
 
@@ -367,19 +382,13 @@ async function resolveTrustedLinkedBundle(root, bundlePath) {
   const realEntryStat = await lstatOrNull(realEntryPath);
   if (!realEntryStat || !realEntryStat.isDirectory() || realEntryStat.isSymbolicLink()) return null;
 
-  let sourceRootReal;
-  try {
-    sourceRootReal = await fs.realpath(sourceRoot.path);
-  } catch {
-    return null;
-  }
+  const resolvedRoots = await trustedReadonlyRoots;
+  const resolvedSourceRoot = resolvedRoots.find((candidate) => pathIdentity(candidate.root.path) === pathIdentity(sourceRoot.path));
+  if (!resolvedSourceRoot) return null;
   let trusted = false;
-  for (const targetRoot of userRoots().filter((candidate) => !candidate.mutable && candidate.scope !== "project")) {
-    const targetRootStat = await lstatOrNull(targetRoot.path);
-    if (!targetRootStat || !targetRootStat.isDirectory() || targetRootStat.isSymbolicLink()) continue;
-    const targetRootReal = await fs.realpath(targetRoot.path);
-    if (pathIdentity(targetRootReal) === pathIdentity(sourceRootReal)) continue;
-    const acceptedTarget = entryPath(targetRootReal, basename(realEntryPath));
+  for (const targetRoot of resolvedRoots) {
+    if (pathIdentity(targetRoot.realPath) === pathIdentity(resolvedSourceRoot.realPath)) continue;
+    const acceptedTarget = entryPath(targetRoot.realPath, basename(realEntryPath));
     if (acceptedTarget && pathIdentity(acceptedTarget) === pathIdentity(realEntryPath)) {
       trusted = true;
       break;
@@ -573,32 +582,37 @@ export function parseBoolValue(raw) {
 
 /** 按名称解析条目（bundle 优先，其次 flat）。找不到返回 null。 */
 export async function resolveEntry(root, name) {
-  const bundlePath = entryPath(root, name);
-  if (bundlePath === null) return null;
-  const rootPath = resolve(root);
-  const rootStat = await lstatOrNull(rootPath);
-  if (!rootStat || !rootStat.isDirectory() || rootStat.isSymbolicLink()) return null;
-  const rootReal = await resolvedPath(rootPath);
-  const bundleStat = await lstatOrNull(bundlePath);
-  if (bundleStat && bundleStat.isDirectory() && !bundleStat.isSymbolicLink()) {
-    const bundleDoc = join(bundlePath, "SKILL.md");
-    const docStat = await lstatOrNull(bundleDoc);
-    if (docStat && docStat.isFile() && !docStat.isSymbolicLink() && await isInsideResolvedRoot(rootReal, bundleDoc)) {
-      return { kind: "bundle", docPath: bundleDoc, entryPath: bundlePath, realDocPath: await fs.realpath(bundleDoc), realEntryPath: await fs.realpath(bundlePath), linked: false };
+  try {
+    const bundlePath = entryPath(root, name);
+    if (bundlePath === null) return null;
+    const rootPath = resolve(root);
+    const rootStat = await lstatOrNull(rootPath);
+    if (!rootStat || !rootStat.isDirectory() || rootStat.isSymbolicLink()) return null;
+    const rootReal = await resolvedPath(rootPath);
+    const bundleStat = await lstatOrNull(bundlePath);
+    if (bundleStat && bundleStat.isDirectory() && !bundleStat.isSymbolicLink()) {
+      const bundleDoc = join(bundlePath, "SKILL.md");
+      const docStat = await lstatOrNull(bundleDoc);
+      if (docStat && docStat.isFile() && !docStat.isSymbolicLink() && await isInsideResolvedRoot(rootReal, bundleDoc)) {
+        return { kind: "bundle", docPath: bundleDoc, entryPath: bundlePath, realDocPath: await fs.realpath(bundleDoc), realEntryPath: await fs.realpath(bundlePath), linked: false };
+      }
     }
+    if (bundleStat && bundleStat.isSymbolicLink()) {
+      const linked = await resolveTrustedLinkedBundle(rootPath, bundlePath);
+      if (linked) return { kind: "bundle", docPath: join(bundlePath, "SKILL.md"), entryPath: bundlePath, ...linked, linked: true };
+    }
+    const flatDoc = resolve(rootPath, `${name}.md`);
+    if (!isSameOrDescendant(rootPath, flatDoc) || rootPath === flatDoc) return null;
+    const flatStat = await lstatOrNull(flatDoc);
+    if (flatStat && flatStat.isFile() && !flatStat.isSymbolicLink() && await isInsideResolvedRoot(rootReal, flatDoc)) {
+      const realDocPath = await fs.realpath(flatDoc);
+      return { kind: "flat", docPath: flatDoc, entryPath: flatDoc, realDocPath, realEntryPath: realDocPath, linked: false };
+    }
+    return null;
+  } catch {
+    // lstat 与 realpath/readFile 之间允许来源变化，调用方统一按不存在处理。
+    return null;
   }
-  if (bundleStat && bundleStat.isSymbolicLink()) {
-    const linked = await resolveTrustedLinkedBundle(rootPath, bundlePath);
-    if (linked) return { kind: "bundle", docPath: join(bundlePath, "SKILL.md"), entryPath: bundlePath, ...linked, linked: true };
-  }
-  const flatDoc = resolve(rootPath, `${name}.md`);
-  if (!isSameOrDescendant(rootPath, flatDoc) || rootPath === flatDoc) return null;
-  const flatStat = await lstatOrNull(flatDoc);
-  if (flatStat && flatStat.isFile() && !flatStat.isSymbolicLink() && await isInsideResolvedRoot(rootReal, flatDoc)) {
-    const realDocPath = await fs.realpath(flatDoc);
-    return { kind: "flat", docPath: flatDoc, entryPath: flatDoc, realDocPath, realEntryPath: realDocPath, linked: false };
-  }
-  return null;
 }
 
 function entryOf(name, kind, docPath, doc) {
@@ -632,7 +646,7 @@ function entryOf(name, kind, docPath, doc) {
 }
 
 /** 扫描一个技能根（只扫一层）。返回 { exists, entries }。 */
-export async function scanEntries(root) {
+export async function scanEntries(root, options = {}) {
   const rootStat = await lstatOrNull(resolve(root));
   if (!rootStat || !rootStat.isDirectory() || rootStat.isSymbolicLink()) return { exists: false, entries: [] };
   let items;
@@ -643,12 +657,14 @@ export async function scanEntries(root) {
   }
   const byName = new Map();
   const rootReal = await resolvedPath(root);
+  let trustedReadonlyRoots = options.trustedReadonlyRoots;
   for (const it of items) {
     try {
       if (it.isSymbolicLink()) {
         const bundlePath = entryPath(root, it.name);
         if (bundlePath === null) continue;
-        const linked = await resolveTrustedLinkedBundle(root, bundlePath);
+        trustedReadonlyRoots ||= resolvedReadonlyUserRoots();
+        const linked = await resolveTrustedLinkedBundle(root, bundlePath, trustedReadonlyRoots);
         if (!linked) continue;
         const doc = parseSkillDoc(await fs.readFile(linked.realDocPath, "utf8"));
         byName.set(it.name, { ...entryOf(it.name, "bundle", join(bundlePath, "SKILL.md"), doc), entryPath: bundlePath, ...linked, linked: true });
@@ -677,23 +693,53 @@ export async function scanEntries(root) {
   return { exists: true, entries };
 }
 
-/** 同一真实技能可能被 CC Switch 分发到多个 Agent 根；按来源 rank 只保留一份。 */
+/** 同一真实技能优先归属直接 SSOT；同类条目再按来源 rank 决胜。 */
 async function scanDeduplicatedUserRoots(roots = userRoots()) {
+  const trustedReadonlyRoots = resolvedReadonlyUserRoots();
+  const results = await Promise.all(roots.map(async (root) => [root, await scanEntries(root.path, { trustedReadonlyRoots })]));
   const scans = new Map();
-  for (const root of roots) scans.set(root.key, await scanEntries(root.path));
-  const claimed = new Set();
-  for (const root of [...roots].sort((left, right) => left.rank - right.rank)) {
-    const scan = scans.get(root.key);
-    scan.entries = scan.entries.filter((entry) => {
+  const groups = new Map();
+  for (const [root, scan] of results) {
+    scans.set(root.key, scan);
+    for (const entry of scan.entries) {
       const identity = pathIdentity(entry.realEntryPath || entry.entryPath || entry.docPath);
-      if (claimed.has(identity)) return false;
-      claimed.add(identity);
-      return true;
-    });
+      const group = groups.get(identity) || [];
+      group.push({ root, entry });
+      groups.set(identity, group);
+    }
+  }
+  const winners = new Set();
+  for (const group of groups.values()) {
+    group.sort((left, right) => Number(left.entry.linked) - Number(right.entry.linked) || left.root.rank - right.root.rank);
+    const winner = group[0];
+    winner.entry.providerRank = Math.min(...group.map((item) => item.root.rank));
+    winner.entry.policyRootKeys = group.map((item) => item.root.key);
+    winners.add(winner.entry);
+  }
+  for (const scan of scans.values()) {
+    scan.entries = scan.entries.filter((entry) => winners.has(entry));
   }
   return scans;
 }
 
+/**
+ * 详情只解析被请求的条目，再从物理路径确定其直接所有者。
+ * 受信链接只能指向已知只读根的顶层目录，故无需扫描并读取全部技能文档即可复现去重归属。
+ */
+async function visibleEntryForRoot(root, name) {
+  if (root.scope === "project") return resolveEntry(root.path, name);
+  const entry = await resolveEntry(root.path, name);
+  if (!entry) return null;
+  const identity = pathIdentity(entry.realEntryPath || entry.entryPath || entry.docPath);
+  const owners = (await resolvedReadonlyUserRoots())
+    .filter((candidate) => {
+      const expected = entryPath(candidate.realPath, basename(entry.realEntryPath || entry.entryPath || entry.docPath));
+      return expected !== null && pathIdentity(expected) === identity;
+    })
+    .sort((left, right) => left.root.rank - right.root.rank);
+  return owners.length === 0 || owners[0].root.key === root.key ? entry : null;
+}
+
 // ── Manager 本地策略（外部源只读，启停状态写入 DSH_HOME）────────────────────
 
 function defaultManagerState() {
@@ -747,7 +793,7 @@ function validManagerStateDocument(value) {
   return true;
 }
 
-/** v0.1.32 及更早状态尚无 CC Switch 键；只补充新增字段，其余损坏仍然失败关闭。 */
+/** 仅对可识别的 version 1 状态补齐 CC Switch 键，其余结构仍交由严格校验失败关闭。 */
 function migrateManagerStateDocument(value) {
   if (!value || typeof value !== "object" || Array.isArray(value) || value.version !== 1) return value;
   if (value.sources && typeof value.sources === "object" && !Array.isArray(value.sources) && value.sources.ccswitch === undefined) value.sources.ccswitch = true;
@@ -799,14 +845,21 @@ async function writeManagerState(value) {
   await writeFileAtomically(managerStatePath(), `${JSON.stringify(normalizeManagerState(value), null, 2)}\n`);
 }
 
-function managerSkillOverride(policy, rootKey, name) {
+function managerSkillOverride(policy, rootKey, name, policyRootKeys = []) {
   if ((policy.enabledSkills[rootKey] || []).includes(name)) return true;
   if ((policy.disabledSkills[rootKey] || []).includes(name)) return false;
+  let inheritedEnable = false;
+  for (const key of policyRootKeys) {
+    if (key === rootKey) continue;
+    if ((policy.disabledSkills[key] || []).includes(name)) return false;
+    if ((policy.enabledSkills[key] || []).includes(name)) inheritedEnable = true;
+  }
+  if (inheritedEnable) return true;
   return undefined;
 }
 
 function effectiveSkillPolicy(policyResult, root, entry) {
-  const override = managerSkillOverride(policyResult.state, root.key, entry.name);
+  const override = managerSkillOverride(policyResult.state, root.key, entry.name, entry.policyRootKeys);
   const sourceEnabled = root.key === "dsh" || root.scope === "project" || policyResult.state.sources[root.key] !== false;
   if (policyResult.writable === false || !sourceEnabled || override === false) {
     return { override, sourceEnabled, modelInvocable: false, userInvocable: false, enabled: false };
@@ -865,7 +918,12 @@ async function setPolicySkillEnabled(root, name, enabled, log) {
   if (!definition) return readonlyError("toggle");
   const resolved = await resolveEntry(definition.path, name);
   if (resolved === null) return { ok: false, error: `技能不存在: ${name}`, code: "error.skill.notFound", params: { name } };
-  const summary = entryOf(name, resolved.kind, resolved.docPath, parseSkillDoc(await fs.readFile(resolved.docPath, "utf8")));
+  let summary;
+  try {
+    summary = entryOf(name, resolved.kind, resolved.docPath, parseSkillDoc(await fs.readFile(resolved.realDocPath || resolved.docPath, "utf8")));
+  } catch {
+    return { ok: false, error: `技能不存在: ${name}`, code: "error.skill.notFound", params: { name } };
+  }
   if (!summary.hasFrontmatter) {
     return { ok: false, error: `技能缺少完整 frontmatter，无法${enabled ? "启用" : "停用"}: ${name}`, code: "error.skill.noFrontmatter", params: { name, action: enabled ? "enable" : "disable" } };
   }
@@ -982,8 +1040,8 @@ async function restoreRootDefinition(metadata, options = {}) {
     || !isAbsolute(metadata.root.projectRoot)
   ) return { ok: false, error: `回收站条目来源非法: ${metadata.id}`, code: "error.trash.invalid", params: { id: metadata.id } };
   const roots = await projectRoots(options.projectCwds);
-  const normalizedProjectRoot = process.platform === "win32" ? resolve(metadata.root.projectRoot).toLowerCase() : resolve(metadata.root.projectRoot);
-  const root = roots.find((item) => item.key === metadata.root.key && item.kind === "project-dsh" && (process.platform === "win32" ? resolve(item.projectRoot).toLowerCase() : resolve(item.projectRoot)) === normalizedProjectRoot);
+  const normalizedProjectRoot = pathIdentity(metadata.root.projectRoot);
+  const root = roots.find((item) => item.key === metadata.root.key && item.kind === "project-dsh" && pathIdentity(item.projectRoot) === normalizedProjectRoot);
   if (!root) {
     return {
       ok: false,
@@ -1536,9 +1594,14 @@ export async function skillDetail(key, name, options = {}) {
   const scopedRoots = await projectRoots(options.projectCwds);
   const root = rootByKey(key) || scopedRoots.find((item) => item.key === key);
   if (!root) return { ok: false, error: `未知技能来源: ${key}`, code: "error.root.unknown", params: { root: key } };
-  const entry = await resolveEntry(root.path, name);
+  const entry = await visibleEntryForRoot(root, name);
   if (!entry) return { ok: false, error: `技能不存在: ${name}`, code: "error.skill.notFound", params: { name } };
-  const raw = await fs.readFile(entry.realDocPath || entry.docPath, "utf8");
+  let raw;
+  try {
+    raw = await fs.readFile(entry.realDocPath || entry.docPath, "utf8");
+  } catch {
+    return { ok: false, error: `技能不存在: ${name}`, code: "error.skill.notFound", params: { name } };
+  }
   const doc = parseSkillDoc(raw);
   const summary = entryOf(name, entry.kind, entry.docPath, doc);
   return {
@@ -1575,7 +1638,7 @@ export async function listProviderCandidates(options = {}) {
         invocation: { modelInvocable: policy.modelInvocable, userInvocable: policy.userInvocable },
         provider: "dsh-skills-manager-external",
         source: root.key === "dsh" ? "user-dsh" : `agent-${root.key}`,
-        rank: root.key === "dsh" ? USER_DSH_POLICY_RANK : root.rank,
+        rank: root.key === "dsh" ? USER_DSH_POLICY_RANK : entry.providerRank ?? root.rank,
         locator: { rootKey: root.key, entryName: entry.name, path: entry.docPath, realEntryPath: entry.realEntryPath, realDocPath: entry.realDocPath },
         resourceBase: { kind: "directory", path: entry.kind === "bundle" ? entry.realEntryPath : root.path },
         path: entry.docPath,
@@ -1601,8 +1664,8 @@ export async function listProviderCandidates(options = {}) {
           provider: "dsh-skills-manager-external",
           source: root.kind,
           rank: root.rank - 1,
-          locator: { rootKey: root.key, entryName: entry.name, path: entry.docPath },
-          resourceBase: { kind: "directory", path: entry.kind === "bundle" ? dirname(entry.docPath) : root.path },
+          locator: { rootKey: root.key, entryName: entry.name, path: entry.docPath, realEntryPath: entry.realEntryPath, realDocPath: entry.realDocPath },
+          resourceBase: { kind: "directory", path: entry.kind === "bundle" ? entry.realEntryPath : root.path },
           path: entry.docPath,
           metadata: { dshSkillsManager: { root: root.key, readOnly: !root.mutable, sourceReadOnly: !root.mutable, policyOnly: true } },
         });
@@ -1614,30 +1677,34 @@ export async function listProviderCandidates(options = {}) {
 
 export async function getProviderSkill(candidate, options = {}) {
   const locator = candidate && candidate.locator;
-  if (!locator || typeof locator.path !== "string" || typeof locator.rootKey !== "string") return undefined;
+  if (!locator || typeof locator.path !== "string" || typeof locator.rootKey !== "string" || typeof locator.realEntryPath !== "string" || typeof locator.realDocPath !== "string") return undefined;
   let root = rootByKey(locator.rootKey);
   if (!root && PROJECT_ROOT_KEY_RE.test(locator.rootKey) && typeof options.cwd === "string") {
     root = (await projectRoots([options.cwd])).find((item) => item.key === locator.rootKey);
   }
   if (!root) return undefined;
-  const entry = await resolveEntry(root.path, String(locator.entryName || ""));
-  if (!entry || resolve(entry.docPath) !== resolve(locator.path)) return undefined;
-  if (locator.realEntryPath && pathIdentity(entry.realEntryPath) !== pathIdentity(locator.realEntryPath)) return undefined;
-  if (locator.realDocPath && pathIdentity(entry.realDocPath) !== pathIdentity(locator.realDocPath)) return undefined;
-  const doc = parseSkillDoc(await fs.readFile(entry.realDocPath || entry.docPath, "utf8"));
-  const summary = entryOf(locator.entryName, entry.kind, entry.docPath, doc);
-  if (!summary.loadable || summary.declaredName !== candidate.name) return undefined;
-  return {
-    name: candidate.name,
-    description: candidate.description,
-    invocation: candidate.invocation,
-    provider: candidate.provider,
-    source: candidate.source,
-    resourceBase: candidate.resourceBase,
-    path: candidate.path,
-    metadata: candidate.metadata,
-    content: doc.body.trim(),
-  };
+  try {
+    const entry = await resolveEntry(root.path, String(locator.entryName || ""));
+    if (!entry || resolve(entry.docPath) !== resolve(locator.path)) return undefined;
+    if (pathIdentity(entry.realEntryPath) !== pathIdentity(locator.realEntryPath)) return undefined;
+    if (pathIdentity(entry.realDocPath) !== pathIdentity(locator.realDocPath)) return undefined;
+    const doc = parseSkillDoc(await fs.readFile(entry.realDocPath || entry.docPath, "utf8"));
+    const summary = entryOf(locator.entryName, entry.kind, entry.docPath, doc);
+    if (!summary.loadable || summary.declaredName !== candidate.name) return undefined;
+    return {
+      name: candidate.name,
+      description: candidate.description,
+      invocation: candidate.invocation,
+      provider: candidate.provider,
+      source: candidate.source,
+      resourceBase: candidate.resourceBase,
+      path: candidate.path,
+      metadata: candidate.metadata,
+      content: doc.body.trim(),
+    };
+  } catch {
+    return undefined;
+  }
 }
 
 // ── 状态快照 ────────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michengai/dsh-skills-manager",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "NPM-installable DSH Web plugin for safely loading and managing skills across DSH and common local Agents.",
   "license": "Apache-2.0",
   "repository": {