skill-creator 2.1.0 → 2.2.0

package/dist/daemon.js

@@ -1783,28 +1783,28 @@ var init_create_prompt_CIJV_96B = __esm({
         b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
         const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
         const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
-        const z27 = r * 0.0193 + g * 0.1192 + b * 0.9505;
+        const z31 = r * 0.0193 + g * 0.1192 + b * 0.9505;
         return [
           x * 100,
           y * 100,
-          z27 * 100
+          z31 * 100
         ];
       };
       convert$1.rgb.lab = function(rgb) {
         const xyz = convert$1.rgb.xyz(rgb);
         let x = xyz[0];
         let y = xyz[1];
-        let z27 = xyz[2];
+        let z31 = xyz[2];
         x /= 95.047;
         y /= 100;
-        z27 /= 108.883;
+        z31 /= 108.883;
         x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
         y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
-        z27 = z27 > 8856e-6 ? z27 ** (1 / 3) : 7.787 * z27 + 16 / 116;
+        z31 = z31 > 8856e-6 ? z31 ** (1 / 3) : 7.787 * z31 + 16 / 116;
         return [
           116 * y - 16,
           500 * (x - y),
-          200 * (y - z27)
+          200 * (y - z31)
         ];
       };
       convert$1.hsl.rgb = function(hsl) {
@@ -2001,13 +2001,13 @@ var init_create_prompt_CIJV_96B = __esm({
       convert$1.xyz.rgb = function(xyz) {
         const x = xyz[0] / 100;
         const y = xyz[1] / 100;
-        const z27 = xyz[2] / 100;
+        const z31 = xyz[2] / 100;
         let r;
         let g;
         let b;
-        r = x * 3.2406 + y * -1.5372 + z27 * -0.4986;
-        g = x * -0.9689 + y * 1.8758 + z27 * 0.0415;
-        b = x * 0.0557 + y * -0.204 + z27 * 1.057;
+        r = x * 3.2406 + y * -1.5372 + z31 * -0.4986;
+        g = x * -0.9689 + y * 1.8758 + z31 * 0.0415;
+        b = x * 0.0557 + y * -0.204 + z31 * 1.057;
         r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
         g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
         b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
@@ -2023,17 +2023,17 @@ var init_create_prompt_CIJV_96B = __esm({
       convert$1.xyz.lab = function(xyz) {
         let x = xyz[0];
         let y = xyz[1];
-        let z27 = xyz[2];
+        let z31 = xyz[2];
         x /= 95.047;
         y /= 100;
-        z27 /= 108.883;
+        z31 /= 108.883;
         x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
         y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
-        z27 = z27 > 8856e-6 ? z27 ** (1 / 3) : 7.787 * z27 + 16 / 116;
+        z31 = z31 > 8856e-6 ? z31 ** (1 / 3) : 7.787 * z31 + 16 / 116;
         return [
           116 * y - 16,
           500 * (x - y),
-          200 * (y - z27)
+          200 * (y - z31)
         ];
       };
       convert$1.lab.xyz = function(lab) {
@@ -2042,23 +2042,23 @@ var init_create_prompt_CIJV_96B = __esm({
         const b = lab[2];
         let x;
         let y;
-        let z27;
+        let z31;
         y = (l + 16) / 116;
         x = a / 500 + y;
-        z27 = y - b / 200;
+        z31 = y - b / 200;
         const y2 = y ** 3;
         const x2 = x ** 3;
-        const z28 = z27 ** 3;
+        const z210 = z31 ** 3;
         y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
         x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
-        z27 = z28 > 8856e-6 ? z28 : (z27 - 16 / 116) / 7.787;
+        z31 = z210 > 8856e-6 ? z210 : (z31 - 16 / 116) / 7.787;
         x *= 95.047;
         y *= 100;
-        z27 *= 108.883;
+        z31 *= 108.883;
         return [
           x,
           y,
-          z27
+          z31
         ];
       };
       convert$1.lab.lch = function(lab) {
@@ -2407,15 +2407,15 @@ var init_create_prompt_CIJV_96B = __esm({
         };
       }
       function wrapConversion(toModel, graph) {
-        const path33 = [graph[toModel].parent, toModel];
+        const path39 = [graph[toModel].parent, toModel];
         let fn = conversions$1[graph[toModel].parent][toModel];
         let cur = graph[toModel].parent;
         while (graph[cur].parent) {
-          path33.unshift(graph[cur].parent);
+          path39.unshift(graph[cur].parent);
           fn = link(conversions$1[graph[cur].parent][cur], fn);
           cur = graph[cur].parent;
         }
-        fn.conversion = path33;
+        fn.conversion = path39;
         return fn;
       }
       module2.exports = function(fromModel) {
@@ -3978,18 +3978,18 @@ function parseSkillFile(filePath) {
     const issues = [];
     const suggestions$1 = [];
     for (const issue of validation$1.error.errors) {
-      const path33 = issue.path.join(".") || "frontmatter";
+      const path39 = issue.path.join(".") || "frontmatter";
       if (issue.code === "invalid_type" && issue.message === "Required") {
-        issues.push(`Missing required field '${path33}' in ${filePath}`);
-        suggestions$1.push(`Add '${path33}: <value>' to the YAML frontmatter.`);
+        issues.push(`Missing required field '${path39}' in ${filePath}`);
+        suggestions$1.push(`Add '${path39}: <value>' to the YAML frontmatter.`);
         continue;
       }
       if (issue.code === "too_small") {
-        issues.push(`${path33}: ${issue.message}`);
-        suggestions$1.push(`Provide a non-empty value for '${path33}'.`);
+        issues.push(`${path39}: ${issue.message}`);
+        suggestions$1.push(`Provide a non-empty value for '${path39}'.`);
         continue;
       }
-      issues.push(`${path33}: ${issue.message}`);
+      issues.push(`${path39}: ${issue.message}`);
     }
     if (suggestions$1.length === 0) suggestions$1.push("Ensure SKILL.md frontmatter includes non-empty 'name' and 'description' fields.");
     throw new ValidationError$2(filePath, issues, suggestions$1);
@@ -4103,9 +4103,9 @@ function builtInAgentRoots(baseDir, location, sourceKind) {
     sourcePriority: sourcePriority$1(sourceKind)
   }));
 }
-function sharedRoot(path33, location, sourceKind) {
+function sharedRoot(path39, location, sourceKind) {
   return {
-    path: path33,
+    path: path39,
     provider: "agents",
     location,
     sourceKind,
@@ -4113,9 +4113,9 @@ function sharedRoot(path33, location, sourceKind) {
   };
 }
 function legacySharedRoot(baseDir, location, sourceKind) {
-  const path33 = join(baseDir, ".agent", "skills");
-  if (!existsSync(path33)) return [];
-  return [sharedRoot(path33, location, sourceKind)];
+  const path39 = join(baseDir, ".agent", "skills");
+  if (!existsSync(path39)) return [];
+  return [sharedRoot(path39, location, sourceKind)];
 }
 function uniqueByPath(entries) {
   const seen = /* @__PURE__ */ new Set();
@@ -5360,8 +5360,8 @@ function buildPreview$1(options2, selected) {
 function promptMultiSelect(options2) {
   return promptImpl(options2);
 }
-function normalizeRepoUrl(origin, path33) {
-  let cleanPath = path33.replace(/\/+$/, "");
+function normalizeRepoUrl(origin, path39) {
+  let cleanPath = path39.replace(/\/+$/, "");
   if (cleanPath.endsWith(".git")) cleanPath = cleanPath.slice(0, -4);
   return `${origin}${cleanPath}.git`;
 }
@@ -5635,17 +5635,17 @@ function installSkillDir(skillDir, targetRoot, force = false) {
     status: alreadyExists ? "overwritten" : "installed"
   };
 }
-function buildSourceArgs(input, branch, path33, repo) {
+function buildSourceArgs(input, branch, path39, repo) {
   return {
     source: repo ?? input,
     ...branch ? { branch } : {},
-    ...path33 ? { path: path33 } : {}
+    ...path39 ? { path: path39 } : {}
   };
 }
-function formatSourceLabel(input, branch, path33, repo) {
+function formatSourceLabel(input, branch, path39, repo) {
   const pieces = [repo ?? input];
   if (branch) pieces.push(`--branch=${branch}`);
-  if (path33) pieces.push(`--path=${path33}`);
+  if (path39) pieces.push(`--path=${path39}`);
   return pieces.join(" ");
 }
 function defaultMode(source, explicit) {
@@ -5805,8 +5805,8 @@ async function selectSkills(targetDirs, argv$1, cmdBuilder) {
   };
   const source = cmdBuilder.getArg("source")[0] ?? argv$1.source;
   const branch = cmdBuilder.getArg("branch")[0];
-  const path33 = cmdBuilder.getArg("path")[0];
-  const sourceLabel = formatSourceLabel(source, branch, path33);
+  const path39 = cmdBuilder.getArg("path")[0];
+  const sourceLabel = formatSourceLabel(source, branch, path39);
   const listing = formatSkillListing(entries, sourceLabel);
   const selectors = parseSelectors(argv$1);
   if (argv$1.all) return {
@@ -6979,8 +6979,8 @@ var init_workflow_install_KvZzb83I = __esm({
     en_default = errorMap;
     overrideErrorMap = en_default;
     makeIssue = (params) => {
-      const { data, path: path33, errorMaps, issueData } = params;
-      const fullPath = [...path33, ...issueData.path || []];
+      const { data, path: path39, errorMaps, issueData } = params;
+      const fullPath = [...path39, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7070,11 +7070,11 @@ var init_workflow_install_KvZzb83I = __esm({
       errorUtil$1.toString = (message) => typeof message === "string" ? message : message?.message;
     })(errorUtil || (errorUtil = {}));
     ParseInputLazyPath = class {
-      constructor(parent, value, path33, key$1) {
+      constructor(parent, value, path39, key$1) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path33;
+        this._path = path39;
         this._key = key$1;
       }
       get path() {
@@ -18022,7 +18022,7 @@ var init_workflow_install_KvZzb83I = __esm({
       };
     }) });
     require_gray_matter = /* @__PURE__ */ __commonJS2({ "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js": ((exports2, module2) => {
-      const fs31 = __require2("fs");
+      const fs38 = __require2("fs");
       const sections = require_section_matter();
       const defaults = require_defaults$1();
       const stringify$1 = require_stringify();
@@ -18093,7 +18093,7 @@ var init_workflow_install_KvZzb83I = __esm({
         return stringify$1(file, data, options2);
       };
       matter$1.read = function(filepath, options2) {
-        const file = matter$1(fs31.readFileSync(filepath, "utf8"), options2);
+        const file = matter$1(fs38.readFileSync(filepath, "utf8"), options2);
         file.path = filepath;
         return file;
       };
@@ -23320,8 +23320,8 @@ var init_workflow_install_KvZzb83I = __esm({
         for (let i$4 = 0; i$4 < str$12.length; i$4++) if (str$12[i$4] === token) ind++;
         return ind;
       }
-      function removeDotSegments$1(path33) {
-        let input = path33;
+      function removeDotSegments$1(path39) {
+        let input = path39;
         const output = [];
         let nextSlash = -1;
         let len = 0;
@@ -23474,8 +23474,8 @@ var init_workflow_install_KvZzb83I = __esm({
           wsComponent.secure = void 0;
         }
         if (wsComponent.resourceName) {
-          const [path33, query] = wsComponent.resourceName.split("?");
-          wsComponent.path = path33 && path33 !== "/" ? path33 : void 0;
+          const [path39, query] = wsComponent.resourceName.split("?");
+          wsComponent.path = path39 && path39 !== "/" ? path39 : void 0;
           wsComponent.query = query;
           wsComponent.resourceName = void 0;
         }
@@ -36772,32 +36772,32 @@ If the user names a skill, or a task clearly matches a skill that is not already
 });
 
 // src/daemon/dsh-profile-support.ts
-import { createRequire as createRequire4 } from "node:module";
-import fs16 from "node:fs";
-import path18 from "node:path";
+import { createRequire as createRequire5 } from "node:module";
+import fs25 from "node:fs";
+import path27 from "node:path";
 function ensureDirLink(link, target) {
-  fs16.mkdirSync(path18.dirname(link), { recursive: true });
-  if (fs16.existsSync(link) && fs16.realpathSync(link) === target) return;
-  fs16.rmSync(link, { recursive: true, force: true });
-  fs16.symlinkSync(target, link, "dir");
+  fs25.mkdirSync(path27.dirname(link), { recursive: true });
+  if (fs25.existsSync(link) && fs25.realpathSync(link) === target) return;
+  fs25.rmSync(link, { recursive: true, force: true });
+  fs25.symlinkSync(target, link, "dir");
 }
 function completeTransitiveMirror(home) {
-  const mirrorRoot = path18.join(home, "profiles", "node_modules");
-  if (!fs16.existsSync(mirrorRoot)) return;
+  const mirrorRoot = path27.join(home, "profiles", "node_modules");
+  if (!fs25.existsSync(mirrorRoot)) return;
   const manifestOf = (dir) => {
     try {
-      return JSON.parse(fs16.readFileSync(path18.join(dir, "package.json"), "utf8"));
+      return JSON.parse(fs25.readFileSync(path27.join(dir, "package.json"), "utf8"));
     } catch {
       return null;
     }
   };
   const listPackages = () => {
     const names = [];
-    for (const scope of fs16.readdirSync(mirrorRoot)) {
+    for (const scope of fs25.readdirSync(mirrorRoot)) {
       if (scope.startsWith(".") || scope === ".bin") continue;
-      const scopeDir = path18.join(mirrorRoot, scope);
+      const scopeDir = path27.join(mirrorRoot, scope);
       if (scope.startsWith("@")) {
-        for (const name of fs16.readdirSync(scopeDir)) names.push(`${scope}/${name}`);
+        for (const name of fs25.readdirSync(scopeDir)) names.push(`${scope}/${name}`);
       } else {
         names.push(scope);
       }
@@ -36807,18 +36807,18 @@ function completeTransitiveMirror(home) {
   for (let round = 0; round < 8; round += 1) {
     let linked = 0;
     for (const name of listPackages()) {
-      const pkgDir = path18.join(mirrorRoot, name);
+      const pkgDir = path27.join(mirrorRoot, name);
       const manifest = manifestOf(pkgDir);
       const deps = { ...manifest?.dependencies };
       if (!deps) continue;
       for (const dep of Object.keys(deps)) {
-        const depLink = path18.join(mirrorRoot, dep);
-        if (fs16.existsSync(depLink)) continue;
+        const depLink = path27.join(mirrorRoot, dep);
+        if (fs25.existsSync(depLink)) continue;
         try {
-          const resolved = createRequire4(path18.join(realPkgDir(pkgDir), "package.json")).resolve(
+          const resolved = createRequire5(path27.join(realPkgDir(pkgDir), "package.json")).resolve(
             `${dep}/package.json`
           );
-          ensureDirLink(depLink, path18.dirname(resolved));
+          ensureDirLink(depLink, path27.dirname(resolved));
           linked += 1;
         } catch {
         }
@@ -36829,7 +36829,7 @@ function completeTransitiveMirror(home) {
 }
 function realPkgDir(pkgDir) {
   try {
-    return fs16.realpathSync(pkgDir);
+    return fs25.realpathSync(pkgDir);
   } catch {
     return pkgDir;
   }
@@ -36994,8 +36994,8 @@ __export(dsh_kernel_exports, {
   KERNEL_AGENT_TOOL_ALLOWLIST: () => KERNEL_AGENT_TOOL_ALLOWLIST,
   bootDshKernel: () => bootDshKernel
 });
-import fs17 from "node:fs";
-import path19 from "node:path";
+import fs26 from "node:fs";
+import path28 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   boot,
@@ -37021,15 +37021,15 @@ async function bootDshKernel(options2) {
     ""
   );
   const llmYaml = localLlmRouteYaml();
-  fs17.writeFileSync(path19.join(profileDir, "cordis.patch.yml"), disableYaml + llmYaml, "utf8");
-  const installAnchor = path19.join(repoRoot, "package.json");
+  fs26.writeFileSync(path28.join(profileDir, "cordis.patch.yml"), disableYaml + llmYaml, "utf8");
+  const installAnchor = path28.join(repoRoot, "package.json");
   const profile = loadProfile("skill-creator", "kernel", installAnchor, options2.home);
   await healProfilesModuleFallback({ installAnchor, profile, home: options2.home });
   completeTransitiveMirror(options2.home);
-  const presetDir = path19.join(options2.home, ".agent-presets", "skill-creator");
-  fs17.mkdirSync(presetDir, { recursive: true });
-  fs17.writeFileSync(
-    path19.join(presetDir, "preset.yml"),
+  const presetDir = path28.join(options2.home, ".agent-presets", "skill-creator");
+  fs26.mkdirSync(presetDir, { recursive: true });
+  fs26.writeFileSync(
+    path28.join(presetDir, "preset.yml"),
     [
       "name: Skill Creator Agent",
       "description: \u4EA7\u54C1\u4F1A\u8BDD\u9884\u8BBE\u2014\u2014Manager \u80FD\u529B\u9762 + ask-user\uFF0C\u65E0\u901A\u7528 fs/shell \u5DE5\u5177\u3002",
@@ -37038,8 +37038,8 @@ async function bootDshKernel(options2) {
     ].join("\n"),
     "utf8"
   );
-  fs17.writeFileSync(
-    path19.join(presetDir, "agent.cordis.yml"),
+  fs26.writeFileSync(
+    path28.join(presetDir, "agent.cordis.yml"),
     [
       "# skill-creator \u4EA7\u54C1 preset\uFF1A\u7531 skill-creator kernel boot \u5199\u5165\uFF08user root\uFF09\u3002",
       "- id: persona",
@@ -37056,7 +37056,7 @@ async function bootDshKernel(options2) {
     ].join("\n"),
     "utf8"
   );
-  const configPath = path19.join(profileDir, "cordis.yml");
+  const configPath = path28.join(profileDir, "cordis.yml");
   const mcpRow = options2.mcp ? [
     "- id: mcp-skill-creator\n",
     "  name: '@deepseek-ai/dsh-mcp-client'\n",
@@ -37067,7 +37067,7 @@ async function bootDshKernel(options2) {
     "    headers:\n",
     "      Authorization: !!js '`Bearer ${process.env.SKILL_CREATOR_MCP_TOKEN}`'\n"
   ].join("") : "";
-  fs17.writeFileSync(
+  fs26.writeFileSync(
     configPath,
     [
       "- id: agent-presets\n",
@@ -37164,8 +37164,8 @@ var init_dsh_kernel = __esm({
     init_dsh_profile_support();
     init_agent_roles2();
     modulePath = fileURLToPath2(import.meta.url);
-    sourceMode = path19.basename(modulePath) === "dsh-kernel.ts";
-    repoRoot = sourceMode ? path19.resolve(path19.dirname(modulePath), "../../..") : path19.resolve(path19.dirname(modulePath), "..");
+    sourceMode = path28.basename(modulePath) === "dsh-kernel.ts";
+    repoRoot = sourceMode ? path28.resolve(path28.dirname(modulePath), "../../..") : path28.resolve(path28.dirname(modulePath), "..");
     KERNEL_DISABLED_TOOL_ROWS = [
       "tool-pwsh",
       "tool-fs",
@@ -37196,8 +37196,8 @@ function resolveDaemonAppLaunch(daemonModuleUrl, runtimeExecutable = process.exe
 }
 
 // src/daemon/index.ts
-import fs29 from "node:fs";
-import path31 from "node:path";
+import fs36 from "node:fs";
+import path37 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { randomBytes as randomBytes15 } from "node:crypto";
 
@@ -38199,7 +38199,7 @@ var DshSessionStreamsInputSchema = z7.object({
 
 // src/shared/rpc-contract.ts
 import { oc } from "@orpc/contract";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/shared/contracts/acp.ts
 import { z as z8 } from "zod";
@@ -39684,49 +39684,142 @@ var ApplyUpdateResultSchema = z13.object({
   results: z13.array(ApplyUpdateResultEntrySchema)
 });
 
+// src/shared/contracts/search.ts
+import { z as z14 } from "zod";
+var SkillInstallationSchema = z14.object({
+  /** 入口原始绝对路径（Agent 环境视角，可能是指向 canonical 目录的 symlink）。 */
+  path: z14.string().min(1),
+  /** 该 root 所属 Workspace（Global 为 `~`，Imported 为 ws_*）。 */
+  workspaceId: WorkspaceIdSchema,
+  /** 该 root 的 Provider。 */
+  providerId: ProviderIdSchema
+}).strict();
+var SkillSearchDocumentSchema = z14.object({
+  /** 与 skills.list 一致的稳定 sk_ id（canonical path digest）。 */
+  id: SkillIdSchema,
+  /** frontmatter name；无效时回退目录名（见 invalidFrontmatter）。 */
+  name: z14.string(),
+  /** frontmatter description；无效时置空。 */
+  description: z14.string(),
+  /** frontmatter keywords（string|string[] 收窄后的字符串数组）。 */
+  keywords: z14.array(z14.string()),
+  /** frontmatter triggers（同上收窄）。 */
+  triggers: z14.array(z14.string()),
+  /** body 的 #/##/###/#### 标题拼接（截 30 条）。 */
+  headings: z14.string(),
+  /** markdown-to-search-text 正文（剥 fence 围栏行，截 12k chars）。 */
+  body: z14.string(),
+  /** realpath 真相。 */
+  canonicalPath: z14.string().min(1),
+  /** 同一 canonical 目录的全部入口（未来 RPC/GUI 可直接组装 WorkspaceProviderTarget）。 */
+  installations: z14.array(SkillInstallationSchema).min(1),
+  /** 实际被索引 SKILL.md 原始字节的 SHA-256 hex（64 字符，无前缀）。 */
+  contentHash: z14.string().regex(/^[a-f0-9]{64}$/),
+  /** 仅 .SKILL.md 在场（技能被禁用）。 */
+  disabled: z14.boolean(),
+  /** SKILL.md 与 .SKILL.md 并存（内容源取 SKILL.md）。 */
+  conflict: z14.boolean(),
+  /** frontmatter 未过 name/description schema（文档仍入索引）。 */
+  invalidFrontmatter: z14.boolean()
+}).strict();
+var SkillSearchDuplicateSchema = z14.object({
+  id: SkillIdSchema,
+  canonicalPath: z14.string().min(1)
+}).strict();
+var SkillDuplicateMemberSchema = z14.object({
+  id: SkillIdSchema,
+  name: z14.string(),
+  canonicalPath: z14.string().min(1),
+  installations: z14.array(SkillInstallationSchema).min(1),
+  disabled: z14.boolean(),
+  conflict: z14.boolean()
+}).strict();
+var SkillDuplicateGroupSchema = z14.object({
+  contentHash: z14.string().regex(/^[a-f0-9]{64}$/),
+  members: z14.array(SkillDuplicateMemberSchema).min(2)
+}).strict();
+var SkillSearchResultSchema = z14.object({
+  id: SkillIdSchema,
+  name: z14.string(),
+  description: z14.string(),
+  canonicalPath: z14.string().min(1),
+  installations: z14.array(SkillInstallationSchema).min(1),
+  contentHash: z14.string().regex(/^[a-f0-9]{64}$/),
+  disabled: z14.boolean(),
+  conflict: z14.boolean(),
+  /** final = 0.7×(bm25/(bm25+8)) + 0.3×rerank。 */
+  score: z14.number(),
+  /** 同 contentHash 组内被折叠的其余成员（同序）。 */
+  duplicates: z14.array(SkillSearchDuplicateSchema)
+}).strict();
+var SkillSearchOptionsSchema = z14.object({
+  limit: z14.number().int().min(1).max(50).default(10)
+}).strict();
+
 // src/shared/rpc-contract.ts
-var WorkspaceProviderReadInputSchema = z14.object({
+var WorkspaceProviderReadInputSchema = z15.object({
   ...WorkspaceProviderTargetSchema.shape,
-  includeDisabled: z14.boolean().optional()
+  includeDisabled: z15.boolean().optional()
 });
 var SkillsListInputSchema = WorkspaceProviderReadInputSchema;
 var SkillsInfoInputSchema = WorkspaceProviderReadInputSchema.extend({
   skillId: SkillIdSchema
 });
-var SkillsToggleInputSchema = z14.object({
+var SkillsToggleInputSchema = z15.object({
   ...WorkspaceProviderTargetSchema.shape,
-  skillIds: z14.array(SkillIdSchema).min(1),
-  mode: z14.enum(["enable", "disable"])
+  skillIds: z15.array(SkillIdSchema).min(1),
+  mode: z15.enum(["enable", "disable"])
 });
-var WorkspaceAddInputSchema = z14.object({
-  path: z14.string().trim().min(1),
-  label: z14.string().trim().min(1).optional()
+var WorkspaceAddInputSchema = z15.object({
+  path: z15.string().trim().min(1),
+  label: z15.string().trim().min(1).optional()
 });
-var WorkspaceRemoveInputSchema = z14.object({ id: ImportedWorkspaceIdSchema });
-var WorkspaceSetActiveInputSchema = z14.object({ id: WorkspaceIdSchema });
-var CreatorRemoveInputSchema = z14.object({
+var WorkspaceRemoveInputSchema = z15.object({ id: ImportedWorkspaceIdSchema });
+var WorkspaceSetActiveInputSchema = z15.object({ id: WorkspaceIdSchema });
+var CreatorRemoveInputSchema = z15.object({
   ...WorkspaceProviderTargetSchema.shape,
   skillId: SkillIdSchema,
-  expectedRevision: z14.string().regex(/^sha256:[a-f0-9]{64}$/)
+  expectedRevision: z15.string().regex(/^sha256:[a-f0-9]{64}$/)
 });
-var RepositoryScanInputSchema = z14.object({
-  source: z14.string().trim().min(1),
-  ref: z14.string().trim().min(1).optional()
+var SkillsSearchInputSchema = z15.object({
+  query: z15.string().min(1),
+  limit: SkillSearchOptionsSchema.shape.limit
+}).strict();
+var RepositoryScanInputSchema = z15.object({
+  source: z15.string().trim().min(1),
+  ref: z15.string().trim().min(1).optional()
 });
-var RepositoryPreviewInputSchema = z14.object({
+var RepositoryPreviewInputSchema = z15.object({
   sessionId: RepositorySessionIdSchema,
   skillId: RemoteSkillIdSchema
 });
 var rpcContract = oc.errors(RpcErrorDefinitions).router({
   skills: {
     /** Discover skills within one explicit Workspace Provider. */
-    list: oc.input(SkillsListInputSchema).output(z14.object({ skills: z14.array(SkillMetadataSchema) })),
+    list: oc.input(SkillsListInputSchema).output(z15.object({ skills: z15.array(SkillMetadataSchema) })),
     /** Read one Workspace Provider-scoped skill document. */
     info: oc.input(SkillsInfoInputSchema).output(SkillInfoSchema),
     /** Enable or disable selected opaque skill IDs. */
     toggle: oc.input(SkillsToggleInputSchema).output(ToggleSummarySchema),
     /** Validate one Workspace Provider-scoped skill. */
     validate: oc.input(SkillsInfoInputSchema).output(ValidateResultSchema),
+    /**
+     * Search local skills across all workspaces (daemon 长驻检索：canonical 去重 +
+     * BM25 + 冻结 rerank；返回稳定 sk_ id 与 installations 作用域三元组)。
+     */
+    search: oc.input(SkillsSearchInputSchema).output(z15.object({ results: z15.array(SkillSearchResultSchema) })),
+    /**
+     * 检索内容配置面：以系统默认编辑器打开 server-owned 的 search-config.toml
+     * （排除目录清单；路径由 daemon 派生，不接受调用方输入）。
+     */
+    searchConfig: {
+      open: oc.input(z15.object({})).output(z15.object({ opened: z15.boolean() }))
+    },
+    /**
+     * 内容重复组（索引 contentHash 分组 >1；无查询维度的全量重复清单，
+     * 排序冻结可重放）。
+     */
+    duplicates: oc.input(z15.object({})).output(z15.object({ groups: z15.array(SkillDuplicateGroupSchema) })),
     update: {
       /** Compare skills-CLI lock hashes against upstream and report outdated skills. */
       check: oc.input(UpdateCheckInputSchema).output(UpdateCheckResultSchema),
@@ -39736,13 +39829,18 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
   },
   workspace: {
     /** List Global and imported Workspaces with fresh Provider counts. */
-    list: oc.input(z14.object({})).output(z14.object({ workspaces: z14.array(WorkspaceSchema) })),
+    list: oc.input(z15.object({})).output(z15.object({ workspaces: z15.array(WorkspaceSchema) })),
     /** Import a canonical directory workspace. */
-    add: oc.input(WorkspaceAddInputSchema).output(z14.object({ workspace: WorkspaceSchema })),
+    add: oc.input(WorkspaceAddInputSchema).output(z15.object({ workspace: WorkspaceSchema })),
     /** Remove an imported workspace registration. */
-    remove: oc.input(WorkspaceRemoveInputSchema).output(z14.object({ activeId: WorkspaceIdSchema })),
+    remove: oc.input(WorkspaceRemoveInputSchema).output(z15.object({ activeId: WorkspaceIdSchema })),
     /** Select the active workspace. */
-    setActive: oc.input(WorkspaceSetActiveInputSchema).output(z14.object({ activeId: WorkspaceIdSchema }))
+    setActive: oc.input(WorkspaceSetActiveInputSchema).output(z15.object({ activeId: WorkspaceIdSchema })),
+    /**
+     * 原生目录选择器（ext-dialog；tray 挂载后可用）。用户取消 → path:null；
+     * 平台不支持 / headless → supported:false（WebUI 以此隐藏 Browse 入口）。
+     */
+    pickDirectory: oc.input(z15.object({})).output(z15.object({ supported: z15.boolean(), path: z15.string().nullable() }))
   },
   creator: {
     /** Create or revision-check and update a skill. */
@@ -39750,7 +39848,7 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
     /** Load an editable skill document. */
     load: oc.input(SkillsInfoInputSchema).output(SkillDocumentSchema),
     /** Revision-check and delete one skill. */
-    remove: oc.input(CreatorRemoveInputSchema).output(z14.object({ removed: z14.literal(true) })),
+    remove: oc.input(CreatorRemoveInputSchema).output(z15.object({ removed: z15.literal(true) })),
     /** Read revision history for one skill (change 5: change log sub-view). */
     revisions: oc.input(CreatorRevisionsInputSchema).output(CreatorRevisionsResultSchema)
   },
@@ -39763,29 +39861,29 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
     install: oc.input(RepositoryInstallInputSchema).output(InstallResultSchema),
     sources: {
       /** List curated (built-in) and user-persisted sources for the Discover grid. */
-      list: oc.input(z14.object({})).output(
-        z14.object({
-          builtIn: z14.array(
-            z14.object({
-              id: z14.string(),
-              label: z14.string(),
-              gitUrl: z14.string(),
-              description: z14.string(),
-              homepage: z14.string().optional()
+      list: oc.input(z15.object({})).output(
+        z15.object({
+          builtIn: z15.array(
+            z15.object({
+              id: z15.string(),
+              label: z15.string(),
+              gitUrl: z15.string(),
+              description: z15.string(),
+              homepage: z15.string().optional()
             })
           ),
-          user: z14.array(UserSourceSchema)
+          user: z15.array(UserSourceSchema)
         })
       ),
       /** Persist a new user source (https git URL only). */
-      add: oc.input(AddUserSourceInputSchema).output(z14.object({ source: UserSourceSchema })),
+      add: oc.input(AddUserSourceInputSchema).output(z15.object({ source: UserSourceSchema })),
       /** Remove one user-persisted source; built-in ids are rejected. */
-      remove: oc.input(RemoveUserSourceInputSchema).output(z14.object({ removed: z14.literal(true) }))
+      remove: oc.input(RemoveUserSourceInputSchema).output(z15.object({ removed: z15.literal(true) }))
     }
   },
   daemon: {
     /** Read the live daemon and tray status. */
-    status: oc.input(z14.object({})).output(DaemonStatusSchema)
+    status: oc.input(z15.object({})).output(DaemonStatusSchema)
   },
   skillIntelligence: {
     /** Read-only multi-skill analysis locked to observed revisions. */
@@ -39793,7 +39891,7 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
     /** Store a Manager-owned proposal draft; never mutates Providers. */
     propose: oc.input(ProposeInputSchema).output(ProposeResultSchema),
     /** List pending proposal drafts (newest first). */
-    list: oc.input(z14.object({})).output(ListProposalsResultSchema),
+    list: oc.input(z15.object({})).output(ListProposalsResultSchema),
     /** Delete one proposal draft. */
     reject: oc.input(RejectProposalInputSchema).output(RejectProposalResultSchema),
     /** Apply one proposal through existing revision-safe mutations. */
@@ -39801,9 +39899,9 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
   },
   steward: {
     /** Probe every registered backend (typed unavailable; no auto fallback). */
-    backends: oc.input(z14.object({})).output(StewardBackendsResultSchema),
+    backends: oc.input(z15.object({})).output(StewardBackendsResultSchema),
     /** List steward runs (newest first, bounded). */
-    list: oc.input(z14.object({})).output(StewardListResultSchema),
+    list: oc.input(z15.object({})).output(StewardListResultSchema),
     /** Start a steward run on an explicit backend and Imported Workspace.Provider. */
     start: oc.input(StewardStartInputSchema).output(StewardStartResultSchema),
     /** Poll normalized run events after a seq cursor. */
@@ -39838,16 +39936,16 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
     },
     /** MCP mutation proposal 审批链（task 4.4；Manager authority 的决定面）。 */
     proposals: {
-      list: oc.input(z14.object({})).output(z14.object({ proposals: z14.array(AgentMcpProposalViewSchema) })),
-      approve: oc.input(AgentProposalDecisionInputSchema).output(z14.object({ proposal: AgentMcpProposalViewSchema })),
-      reject: oc.input(AgentProposalDecisionInputSchema).output(z14.object({ proposal: AgentMcpProposalViewSchema }))
+      list: oc.input(z15.object({})).output(z15.object({ proposals: z15.array(AgentMcpProposalViewSchema) })),
+      approve: oc.input(AgentProposalDecisionInputSchema).output(z15.object({ proposal: AgentMcpProposalViewSchema })),
+      reject: oc.input(AgentProposalDecisionInputSchema).output(z15.object({ proposal: AgentMcpProposalViewSchema }))
     },
     /** 面板会话：内核 agent 会话的生命周期投影（task 2.2；旧 dsh.* 收敛并入）。 */
     sessions: {
       /** 列出内核 live 会话（含非面板会话的 disposed 投影）。 */
-      list: oc.input(z14.object({})).output(z14.object({ sessions: z14.array(AgentSessionSummarySchema) })),
+      list: oc.input(z15.object({})).output(z15.object({ sessions: z15.array(AgentSessionSummarySchema) })),
       /** 脱敏 run/session 帧查询（原 dsh.sessions.streams 平移；steward 投影消费）。 */
-      streams: oc.input(AgentSessionsStreamsInputSchema).output(z14.object({ frames: z14.array(DshSessionStreamFrameSchema) })),
+      streams: oc.input(AgentSessionsStreamsInputSchema).output(z15.object({ frames: z15.array(DshSessionStreamFrameSchema) })),
       /**
        * 清理面板会话转录（R14-C）：按保留天数 / 全量 / 显式 ID 删除产品转录层
        * （sessions/YYYY/MM/DD），running 会话跳过；不触碰 $DSH_HOME 内核日志。
@@ -39890,16 +39988,16 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
       /** 单文件预览：图片缩略（jSquash）/ 文本头 / 二进制名投影。 */
       preview: oc.input(AgentFilesPreviewInputSchema).output(AgentFilesPreviewResultSchema),
       /** 原生文件选择（R18 @xmorse/rfd）：mode 预置 filter；空 = 取消。 */
-      pickFiles: oc.input(z14.object({ mode: z14.enum(["image", "file"]) })).output(z14.object({ paths: z14.array(z14.string().min(1)) }))
+      pickFiles: oc.input(z15.object({ mode: z15.enum(["image", "file"]) })).output(z15.object({ paths: z15.array(z15.string().min(1)) }))
     },
     /** pi-ai 装配目录（models.dev 镜像）投影：全量 provider 画廊（filter 在 UI）。 */
     models: {
-      catalog: oc.input(z14.object({})).output(z14.object({ providers: z14.array(ModelProviderCatalogEntrySchema) }))
+      catalog: oc.input(z15.object({})).output(z15.object({ providers: z15.array(ModelProviderCatalogEntrySchema) }))
     },
     /** model/preset/permission/approval 投影（原 dsh.settings 平移）。 */
     settings: {
       /** 当前 settings 投影 + provider 凭据（apiKey 按 R16 用户裁决回显）。 */
-      get: oc.input(z14.object({})).output(DshStewardSettingsViewSchema),
+      get: oc.input(z15.object({})).output(DshStewardSettingsViewSchema),
       /** 应用补丁；revision 只在真实变更时 +1；类型化 rejected 见契约 union。 */
       update: oc.input(DshSettingsUpdateSchema).output(DshSettingsUpdateResultSchema),
       /**
@@ -39924,13 +40022,13 @@ var rpcContract = oc.errors(RpcErrorDefinitions).router({
     /** List ACP-capable agents installed on this machine (daemon-lifetime cached). */
     agents: {
       /** Probe known PATH binaries and return their availability projection. */
-      list: oc.input(z14.object({})).output(z14.object({ agents: z14.array(AcpAgentInfoSchema) }))
+      list: oc.input(z15.object({})).output(z15.object({ agents: z15.array(AcpAgentInfoSchema) }))
     },
     session: {
       /** Spawn the selected agent subprocess and register a daemon-owned session. */
       open: oc.input(AcpSessionOpenInputSchema).output(AcpSessionOpenResultSchema),
       /** Terminate the agent subprocess for one session (idempotent). */
-      close: oc.input(AcpSessionCloseInputSchema).output(z14.object({ closed: z14.literal(true) }))
+      close: oc.input(AcpSessionCloseInputSchema).output(z15.object({ closed: z15.literal(true) }))
     }
   }
 });
@@ -41070,6 +41168,7 @@ async function save(workspaces, skills, input, revisionLog, revisionLogLimit) {
   const content = matter.stringify(input.body, frontmatter);
   atomicWriteUtf8(targetFile, content.endsWith("\n") ? content : `${content}
 `);
+  skills.invalidateDiscovery(target);
   const skillId = input.mode === "create" ? (await skills.list(target, true)).find(
     (skill) => skill.path === fs4.realpathSync(skillDirectory)
   )?.id : input.skillId;
@@ -41122,6 +41221,7 @@ async function remove(workspaces, skills, target, skillId, expectedRevision) {
     throw new DomainError("CONFLICT", "This skill changed on disk. Reload it before deleting.");
   }
   fs4.rmSync(skill.path, { recursive: true, force: false });
+  skills.invalidateDiscovery(target);
 }
 function writableDirectory(workspaces, target) {
   const scope = workspaces.resolveWritable(target);
@@ -41150,28 +41250,28 @@ init_workflow_install_KvZzb83I();
 // src/daemon/repository-service.ts
 import { execa as execa2 } from "execa";
 import matter2 from "gray-matter";
-import { z as z15, ZodError as ZodError3 } from "zod";
+import { z as z16, ZodError as ZodError3 } from "zod";
 var CLONE_TIMEOUT_MS = 6e4;
 var MAX_SESSIONS = 6;
-var InstallerResultEntrySchema = z15.object({
-  skill: z15.string(),
-  destination: z15.string(),
-  path: z15.string(),
-  status: z15.enum(["installed", "skipped", "overwritten", "failed"]),
-  error: z15.string().optional()
+var InstallerResultEntrySchema = z16.object({
+  skill: z16.string(),
+  destination: z16.string(),
+  path: z16.string(),
+  status: z16.enum(["installed", "skipped", "overwritten", "failed"]),
+  error: z16.string().optional()
 });
-var InstallerSummarySchema = z15.object({
-  results: z15.array(InstallerResultEntrySchema),
-  installed: z15.number().int().nonnegative(),
-  skipped: z15.number().int().nonnegative(),
-  overwritten: z15.number().int().nonnegative(),
-  failed: z15.number().int().nonnegative()
+var InstallerSummarySchema = z16.object({
+  results: z16.array(InstallerResultEntrySchema),
+  installed: z16.number().int().nonnegative(),
+  skipped: z16.number().int().nonnegative(),
+  overwritten: z16.number().int().nonnegative(),
+  failed: z16.number().int().nonnegative()
 });
-var InstallerPreviewSchema = z15.object({
-  dryRun: z15.literal(true),
-  skills: z15.array(z15.object({ name: z15.string(), description: z15.string() })),
-  destinations: z15.array(z15.object({ path: z15.string(), exists: z15.boolean() })),
-  totalInstalls: z15.number().int().nonnegative()
+var InstallerPreviewSchema = z16.object({
+  dryRun: z16.literal(true),
+  skills: z16.array(z16.object({ name: z16.string(), description: z16.string() })),
+  destinations: z16.array(z16.object({ path: z16.string(), exists: z16.boolean() })),
+  totalInstalls: z16.number().int().nonnegative()
 });
 function createRepositoryService(workspaces, skills, options2 = {}) {
   const sessions = /* @__PURE__ */ new Map();
@@ -41457,6 +41557,7 @@ function assertExpectedInstallerEntry(target, entry) {
   }
 }
 async function installedSkillId(target, skills) {
+  skills.invalidateDiscovery(target.target);
   const canonicalPath = canonicalDirectory(target.expectedPath);
   if (canonicalPath !== target.expectedPath) {
     throw new Error("Installed skill path must not resolve through a symbolic link.");
@@ -41762,16 +41863,16 @@ function formatZodError(error) {
 
 // src/daemon/skills-cli-probe.ts
 import { execa as execa3 } from "execa";
-import { z as z16 } from "zod";
-var SkillsCliListEntrySchema = z16.object({
+import { z as z17 } from "zod";
+var SkillsCliListEntrySchema = z17.object({
   /** 技能名。 */
-  name: z16.string(),
+  name: z17.string(),
   /** 技能的规范路径（canonicalPath）。 */
-  path: z16.string().min(1),
+  path: z17.string().min(1),
   /** 作用域；CLI 输出为 `project` 或 `global`，额外值被丢弃。 */
-  scope: z16.union([z16.literal("project"), z16.literal("global")]).optional()
+  scope: z17.union([z17.literal("project"), z17.literal("global")]).optional()
 });
-var SkillsCliListEnvelopeSchema = z16.array(z16.unknown());
+var SkillsCliListEnvelopeSchema = z17.array(z17.unknown());
 var DEFAULT_TIMEOUT_MS2 = 15e3;
 async function runNpxSkillsList() {
   return execa3("npx", ["skills", "list", "--json"], {
@@ -41798,6 +41899,7 @@ function parseSkillsCliList(stdout) {
 function createSkillsCliProbe(options2 = {}) {
   const run = options2.run ?? runNpxSkillsList;
   let cached2 = null;
+  let inflight = null;
   const probeOnce = async () => {
     try {
       const { stdout } = await run();
@@ -41807,10 +41909,26 @@ function createSkillsCliProbe(options2 = {}) {
     }
   };
   return {
-    /** 返回缓存的探测映射；首次调用 shell out，后续命中缓存。 */
+    /** 返回缓存的探测映射；首次调用 shell out（在途共享），后续命中缓存。 */
     async probe() {
       if (cached2) return cached2;
-      cached2 = await probeOnce();
+      if (inflight) return inflight;
+      inflight = probeOnce().then((result) => {
+        cached2 = result;
+        return result;
+      });
+      try {
+        return await inflight;
+      } finally {
+        inflight = null;
+      }
+    },
+    /**
+     * 同步快照（perf-firstscreen B-5）：缓存命中返回映射，未就绪返回 null——
+     * 调用方（skills.list）不阻塞等待 npx（冷启动 0-15s）；daemon boot 后
+     * 台预热 probe，就绪后的下一次投影自然补全 provenance。
+     */
+    peek() {
       return cached2;
     },
     /** 失效缓存；指定路径时仅移除对应条目，否则清空全部。 */
@@ -41821,7 +41939,7 @@ function createSkillsCliProbe(options2 = {}) {
         return;
       }
       const next = new Map(cached2);
-      for (const path33 of paths) next.delete(path33);
+      for (const path39 of paths) next.delete(path39);
       cached2 = next;
     }
   };
@@ -41838,68 +41956,68 @@ import path9 from "node:path";
 import { execa as execa4 } from "execa";
 
 // src/shared/contracts/skills-lock.ts
-import { z as z17 } from "zod";
-var SkillLockEntrySchema = z17.object({
+import { z as z18 } from "zod";
+var SkillLockEntrySchema = z18.object({
   /** 规范化源标识（如 `owner/repo`、`mintlify/bun.com`）。 */
-  source: z17.string(),
+  source: z18.string(),
   /** 源类型（`github`、`mintlify`、`huggingface`、`local` 等）。 */
-  sourceType: z17.string(),
+  sourceType: z18.string(),
   /** 安装时使用的原始 URL，升级时用于重新拉取。 */
-  sourceUrl: z17.string(),
+  sourceUrl: z18.string(),
   /** 安装时使用的分支或 tag ref。 */
-  ref: z17.string().optional(),
+  ref: z18.string().optional(),
   /** 源仓库内的子路径（可选）。 */
-  skillPath: z17.string().optional(),
+  skillPath: z18.string().optional(),
   /**
    * 技能整个目录的 GitHub tree SHA；任一文件变更即变化。
    * 由 telemetry server 通过 GitHub Trees API 取得。
    */
-  skillFolderHash: z17.string(),
+  skillFolderHash: z18.string(),
   /** 首次安装的 ISO 时间戳。 */
-  installedAt: z17.string(),
+  installedAt: z18.string(),
   /** 最近一次更新的 ISO 时间戳。 */
-  updatedAt: z17.string(),
+  updatedAt: z18.string(),
   /** 所属插件名（可选）。 */
-  pluginName: z17.string().optional()
+  pluginName: z18.string().optional()
 });
-var DismissedPromptsSchema = z17.object({ findSkillsPrompt: z17.boolean().optional() }).optional();
-var SkillLockFileSchema = z17.object({
+var DismissedPromptsSchema = z18.object({ findSkillsPrompt: z18.boolean().optional() }).optional();
+var SkillLockFileSchema = z18.object({
   /** schema 版本；当前固定为 3。 */
-  version: z17.literal(3),
+  version: z18.literal(3),
   /** 技能名 → 记录的映射。 */
-  skills: z17.record(z17.string(), SkillLockEntrySchema),
+  skills: z18.record(z18.string(), SkillLockEntrySchema),
   /** 已忽略的提示集合（可选）。 */
   dismissed: DismissedPromptsSchema,
   /** 最近一次选中的 agents（可选）。 */
-  lastSelectedAgents: z17.array(z17.string()).optional()
+  lastSelectedAgents: z18.array(z18.string()).optional()
 });
-var LocalSkillLockEntrySchema = z17.object({
+var LocalSkillLockEntrySchema = z18.object({
   /** 技能来源（npm 包名、owner/repo、本地路径等）。 */
-  source: z17.string(),
+  source: z18.string(),
   /** 当 source 被规范化时，保留原始远端 URL（可选）。 */
-  sourceUrl: z17.string().optional(),
+  sourceUrl: z18.string().optional(),
   /** 安装时使用的分支或 tag ref（可选）。 */
-  ref: z17.string().optional(),
+  ref: z18.string().optional(),
   /** 源类型（`github`、`node_modules`、`local` 等）。 */
-  sourceType: z17.string(),
+  sourceType: z18.string(),
   /**
    * 源仓库内 SKILL.md 的路径（如 `skills/pdf/SKILL.md`）。
    * 升级时按它定向重装；非仓库源可缺省。
    */
-  skillPath: z17.string().optional(),
+  skillPath: z18.string().optional(),
   /**
    * 由技能目录所有文件计算的 SHA-256。
    * 与全局锁的 GitHub tree SHA 不同。
    */
-  computedHash: z17.string(),
+  computedHash: z18.string(),
   /** Eve subagent 目标（可选），daemon 不消费。 */
-  subagents: z17.array(z17.string()).optional()
+  subagents: z18.array(z18.string()).optional()
 });
-var LocalSkillLockFileSchema = z17.object({
+var LocalSkillLockFileSchema = z18.object({
   /** schema 版本；当前固定为 1。 */
-  version: z17.literal(1),
+  version: z18.literal(1),
   /** 技能名 → 记录的映射。 */
-  skills: z17.record(z17.string(), LocalSkillLockEntrySchema)
+  skills: z18.record(z18.string(), LocalSkillLockEntrySchema)
 });
 function parseGlobalSkillLock(value) {
   const parsed = SkillLockFileSchema.safeParse(value);
@@ -42356,6 +42474,1544 @@ function safeParseJsonValue(source) {
   }
 }
 
+// src/daemon/skill-search/service.ts
+import fs16 from "node:fs";
+import path18 from "node:path";
+
+// src/daemon/workspace-registry/persistence.ts
+import fs8 from "node:fs";
+import path11 from "node:path";
+
+// src/daemon/workspace-registry/state.ts
+import path10 from "node:path";
+import { z as z19 } from "zod";
+var StoredWorkspaceSchema = z19.object({
+  id: ImportedWorkspaceIdSchema,
+  label: z19.string().trim().min(1),
+  path: z19.string().min(1).refine(path10.isAbsolute, "Workspace path must be absolute.").refine((value) => path10.normalize(value) === value, "Workspace path must be normalized.")
+}).strict();
+var WorkspaceRegistryStateSchema = z19.object({
+  schemaVersion: z19.literal(2),
+  activeId: WorkspaceIdSchema,
+  workspaces: z19.array(StoredWorkspaceSchema)
+}).strict().superRefine((state, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  for (const [index, workspace] of state.workspaces.entries()) {
+    if (workspace.id !== opaquePathId("ws", workspace.path)) {
+      context.addIssue({
+        code: "custom",
+        message: "Workspace ID does not match its path.",
+        path: ["workspaces", index, "id"]
+      });
+    }
+    if (ids.has(workspace.id)) {
+      context.addIssue({
+        code: "custom",
+        message: `Duplicate Workspace ID: ${workspace.id}`,
+        path: ["workspaces", index, "id"]
+      });
+    }
+    if (paths.has(workspace.path)) {
+      context.addIssue({
+        code: "custom",
+        message: `Duplicate Workspace path: ${workspace.path}`,
+        path: ["workspaces", index, "path"]
+      });
+    }
+    ids.add(workspace.id);
+    paths.add(workspace.path);
+  }
+  if (state.activeId !== GLOBAL_WORKSPACE_ID && !ids.has(state.activeId)) {
+    context.addIssue({
+      code: "custom",
+      message: `Active Workspace is not registered: ${state.activeId}`,
+      path: ["activeId"]
+    });
+  }
+});
+function emptyRegistryState() {
+  return { schemaVersion: 2, activeId: GLOBAL_WORKSPACE_ID, workspaces: [] };
+}
+function importWorkspace(state, entry) {
+  const existing = state.workspaces.find((workspace) => workspace.path === entry.path);
+  if (existing) return { state, entry: existing, changed: false };
+  const collision = state.workspaces.find((workspace) => workspace.id === entry.id);
+  if (collision) {
+    throw new Error(`Workspace ID collision between ${collision.path} and ${entry.path}`);
+  }
+  return {
+    state: {
+      ...state,
+      activeId: entry.id,
+      workspaces: [...state.workspaces, entry]
+    },
+    entry,
+    changed: true
+  };
+}
+function forgetWorkspace(state, id) {
+  if (!state.workspaces.some((workspace) => workspace.id === id)) return null;
+  return {
+    ...state,
+    activeId: state.activeId === id ? GLOBAL_WORKSPACE_ID : state.activeId,
+    workspaces: state.workspaces.filter((workspace) => workspace.id !== id)
+  };
+}
+function activateWorkspace(state, id) {
+  if (id !== GLOBAL_WORKSPACE_ID && !state.workspaces.some((workspace) => workspace.id === id)) {
+    return null;
+  }
+  if (state.activeId === id) return state;
+  return { ...state, activeId: id };
+}
+
+// src/daemon/workspace-registry/persistence.ts
+var WORKSPACES_FILE = "workspaces.json";
+function createWorkspaceRegistryPersistence() {
+  const file = path11.join(appDir(), WORKSPACES_FILE);
+  return {
+    load: () => loadState2(file),
+    commit: (state) => commitState2(file, state)
+  };
+}
+function loadState2(file) {
+  if (!fs8.existsSync(file)) return emptyRegistryState();
+  let source;
+  try {
+    source = fs8.readFileSync(file, "utf8");
+  } catch (error) {
+    throw new Error(
+      `Cannot read workspace registry ${file}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return safeParseJson(source, WorkspaceRegistryStateSchema) ?? emptyRegistryState();
+}
+function commitState2(file, state) {
+  const validated = WorkspaceRegistryStateSchema.parse(state);
+  fs8.mkdirSync(path11.dirname(file), { recursive: true, mode: 448 });
+  atomicWriteUtf8(file, `${JSON.stringify(validated, null, 2)}
+`);
+}
+
+// src/daemon/provider-roots.ts
+import fs9 from "node:fs";
+import os5 from "node:os";
+import path12 from "node:path";
+function requireProvider(providerId) {
+  const provider = providerCatalogEntry(providerId);
+  if (!provider) throw new DomainError("NOT_FOUND", `Provider not found: ${providerId}`);
+  return provider;
+}
+function globalProviderRoot(provider) {
+  if (provider.globalPath === null) return null;
+  const home = os5.homedir();
+  const override = globalHomeOverride(provider.id);
+  if (override) return path12.join(override, "skills");
+  if (provider.id === "openclaw") return openClawRoot(home);
+  if (provider.globalPath.startsWith(".config/")) {
+    const configHome = process.env.XDG_CONFIG_HOME?.trim() || path12.join(home, ".config");
+    return path12.join(configHome, provider.globalPath.slice(".config/".length));
+  }
+  return path12.join(home, provider.globalPath);
+}
+function importedProviderRoot(workspaceRoot, provider) {
+  const root = path12.resolve(workspaceRoot, provider.workspacePath);
+  const relative2 = path12.relative(workspaceRoot, root);
+  if (relative2.startsWith("..") || path12.isAbsolute(relative2)) {
+    throw new Error(`Provider root escaped Workspace: ${provider.id}`);
+  }
+  return root;
+}
+function providerRootAvailable(root) {
+  if (!root) return false;
+  try {
+    return fs9.statSync(root).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function globalHomeOverride(providerId) {
+  const variable = providerId === "codex" ? "CODEX_HOME" : providerId === "claude-code" ? "CLAUDE_CONFIG_DIR" : providerId === "mistral-vibe" ? "VIBE_HOME" : providerId === "hermes-agent" ? "HERMES_HOME" : providerId === "autohand-code" ? "AUTOHAND_HOME" : providerId === "grok" ? "GROK_HOME" : null;
+  const value = variable ? process.env[variable]?.trim() : void 0;
+  return value || null;
+}
+function openClawRoot(home) {
+  for (const directory of [".openclaw", ".clawdbot", ".moltbot"]) {
+    if (providerRootAvailable(path12.join(home, directory)))
+      return path12.join(home, directory, "skills");
+  }
+  return path12.join(home, ".openclaw", "skills");
+}
+
+// src/daemon/skill-search/canonicalize.ts
+import fs11 from "node:fs";
+import path14 from "node:path";
+
+// src/daemon/skill-search/content-files.ts
+import fs10 from "node:fs";
+import path13 from "node:path";
+var BUILTIN_EXCLUDED_DIRS = [
+  "node_modules",
+  "build",
+  "dist",
+  "target",
+  "__pycache__",
+  "tmp",
+  "logs"
+];
+var MAX_DEPTH = 4;
+var MAX_FILES = 32;
+var IDENTITY_FILE_NAMES = /* @__PURE__ */ new Set(["skill.md", ".skill.md"]);
+function collectExtraMarkdownFiles(canonicalPath, excludedDirs = /* @__PURE__ */ new Set()) {
+  const effective = /* @__PURE__ */ new Set([...BUILTIN_EXCLUDED_DIRS, ...excludedDirs]);
+  const files = [];
+  collectDirectory(canonicalPath, 0, effective, files);
+  files.sort((left, right) => compareString(left.path, right.path));
+  return files.slice(0, MAX_FILES);
+}
+function collectDirectory(directory, depth, excludedDirs, files) {
+  if (depth > MAX_DEPTH || files.length >= MAX_FILES) return;
+  let dirents;
+  try {
+    dirents = fs10.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  dirents.sort((left, right) => compareString(left.name, right.name));
+  for (const dirent of dirents) {
+    if (files.length >= MAX_FILES) return;
+    const entryPath = path13.join(directory, dirent.name);
+    if (dirent.isDirectory()) {
+      if (dirent.name.startsWith(".") || excludedDirs.has(dirent.name)) continue;
+      let descentStat;
+      try {
+        descentStat = fs10.lstatSync(entryPath);
+      } catch {
+        continue;
+      }
+      if (!descentStat.isDirectory() || descentStat.isSymbolicLink()) continue;
+      collectDirectory(entryPath, depth + 1, excludedDirs, files);
+      continue;
+    }
+    if (!dirent.isFile()) continue;
+    if (!dirent.name.toLowerCase().endsWith(".md")) continue;
+    if (IDENTITY_FILE_NAMES.has(dirent.name.toLowerCase())) continue;
+    if (!isRegularFile(entryPath)) continue;
+    let stat2;
+    try {
+      stat2 = fs10.statSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (!stat2.isFile()) continue;
+    files.push({
+      path: entryPath,
+      mtimeMs: stat2.mtimeMs,
+      size: stat2.size,
+      ino: stat2.ino,
+      ctimeMs: stat2.ctimeMs
+    });
+  }
+}
+function isRegularFile(file) {
+  try {
+    return fs10.lstatSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function compareString(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/daemon/skill-search/canonicalize.ts
+function canonicalizeCandidates(entries, excludedDirs = /* @__PURE__ */ new Set()) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    let canonicalPath;
+    try {
+      canonicalPath = fs11.realpathSync(entry.path);
+    } catch {
+      continue;
+    }
+    const installation = {
+      path: entry.path,
+      workspaceId: entry.workspaceId,
+      providerId: entry.providerId
+    };
+    const group = groups.get(canonicalPath) ?? { installations: [] };
+    const exists = group.installations.some(
+      (candidate) => candidate.path === installation.path && candidate.workspaceId === installation.workspaceId && candidate.providerId === installation.providerId
+    );
+    if (!exists) group.installations.push(installation);
+    groups.set(canonicalPath, group);
+  }
+  const scans = [];
+  for (const [canonicalPath, group] of groups) {
+    const source = selectSourceFile(canonicalPath);
+    if (!source) continue;
+    let sourceStat;
+    try {
+      sourceStat = fs11.statSync(source.sourcePath);
+    } catch {
+      continue;
+    }
+    const extras = collectExtraMarkdownFiles(canonicalPath, excludedDirs);
+    const files = [
+      {
+        path: source.sourcePath,
+        mtimeMs: sourceStat.mtimeMs,
+        size: sourceStat.size,
+        ino: sourceStat.ino,
+        ctimeMs: sourceStat.ctimeMs
+      },
+      ...extras
+    ].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+    scans.push({
+      id: SkillIdSchema.parse(opaquePathId("sk", canonicalPath)),
+      canonicalPath,
+      installations: group.installations.sort(
+        (left, right) => compareString2(left.path, right.path)
+      ),
+      sourceFile: source.sourceFile,
+      sourcePath: source.sourcePath,
+      disabled: source.disabled,
+      conflict: source.conflict,
+      files
+    });
+  }
+  scans.sort((left, right) => compareString2(left.canonicalPath, right.canonicalPath));
+  return scans;
+}
+function selectSourceFile(canonicalPath) {
+  const enabled = path14.join(canonicalPath, "SKILL.md");
+  const disabledFile = path14.join(canonicalPath, ".SKILL.md");
+  const hasEnabled = isRegularFile2(enabled);
+  const hasDisabled = isRegularFile2(disabledFile);
+  if (hasEnabled) {
+    return { sourceFile: "SKILL.md", sourcePath: enabled, disabled: false, conflict: hasDisabled };
+  }
+  if (hasDisabled) {
+    return { sourceFile: ".SKILL.md", sourcePath: disabledFile, disabled: true, conflict: false };
+  }
+  return null;
+}
+function compareString2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function isRegularFile2(file) {
+  try {
+    return fs11.lstatSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/daemon/skill-search/config.ts
+import { createHash as createHash8 } from "node:crypto";
+import fs13 from "node:fs";
+import path16 from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { z as z22 } from "zod";
+
+// src/daemon/skill-search/index.ts
+import { createHash as createHash7 } from "node:crypto";
+import { createRequire as createRequire4 } from "node:module";
+import fs12 from "node:fs";
+import path15 from "node:path";
+import MiniSearch from "minisearch";
+import { z as z21 } from "zod";
+
+// src/daemon/skill-search/parser.ts
+import { createHash as createHash6 } from "node:crypto";
+import matter3 from "gray-matter";
+import { z as z20 } from "zod";
+var PARSER_VERSION = "matter-mdset-v2";
+var HEADINGS_LIMIT = 30;
+var BODY_LIMIT = 12e3;
+var EXTRA_FILE_LIMIT = 6e3;
+var EXTRA_TOTAL_LIMIT = 12e3;
+var FENCE_MARKER_RE = /^[ \t]*(?:```|~~~)/;
+var HEADING_RE = /^#{1,4}[ \t]+(.+)$/gm;
+var FrontmatterShapeSchema = z20.object({
+  name: z20.string().min(1),
+  description: z20.string().min(1)
+});
+function parseSkillDocumentSet(sourceRaw, extras, directoryName) {
+  return finalizeDocument(splitFrontmatter(sourceRaw), sourceRaw, extras, directoryName);
+}
+function finalizeDocument(split, sourceRaw, extras, directoryName) {
+  const hash = createHash6("sha256").update(sourceRaw);
+  for (const extra of extras) hash.update(extra.raw);
+  const headingLines = [];
+  const bodyLines = [];
+  let inFence = false;
+  for (const line of split.content.split("\n")) {
+    if (FENCE_MARKER_RE.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    bodyLines.push(line);
+    if (!inFence) headingLines.push(line);
+  }
+  const headings = collectHeadings(headingLines.join("\n"));
+  const skillBody = bodyLines.join("\n").slice(0, BODY_LIMIT);
+  let extraBudget = EXTRA_TOTAL_LIMIT;
+  const extraParts = [];
+  for (const extra of extras) {
+    if (extraBudget <= 0) break;
+    const text = stripFences(extra.raw.toString("utf8")).trim().slice(0, EXTRA_FILE_LIMIT);
+    if (!text) continue;
+    const bounded = text.slice(0, extraBudget);
+    extraBudget -= bounded.length;
+    extraParts.push(bounded);
+  }
+  const body = extraParts.length > 0 ? `${skillBody}
+${extraParts.join("\n")}` : skillBody;
+  const valid = safeParseExternal(FrontmatterShapeSchema, split.frontmatter);
+  const frontmatterRecord = split.frontmatter !== null && typeof split.frontmatter === "object" ? split.frontmatter : {};
+  return {
+    name: valid ? valid.name : directoryName,
+    description: valid ? valid.description : "",
+    keywords: narrowStringList(frontmatterRecord.keywords),
+    triggers: narrowStringList(frontmatterRecord.triggers),
+    headings,
+    body,
+    contentHash: hash.digest("hex"),
+    invalidFrontmatter: valid === null
+  };
+}
+function splitFrontmatter(raw) {
+  const text = raw.toString("utf8");
+  try {
+    const parsed = matter3(text);
+    return { frontmatter: parsed.data ?? {}, content: parsed.content ?? "" };
+  } catch {
+    return { frontmatter: {}, content: text };
+  }
+}
+function stripFences(text) {
+  const lines = [];
+  let inFence = false;
+  for (const line of text.split("\n")) {
+    if (FENCE_MARKER_RE.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+function narrowStringList(value) {
+  if (typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function collectHeadings(content) {
+  const headings = [];
+  for (const match of content.matchAll(HEADING_RE)) {
+    headings.push(match[1].trim());
+    if (headings.length >= HEADINGS_LIMIT) break;
+  }
+  return headings.join("\n");
+}
+
+// src/daemon/skill-search/ranking.ts
+var RANKING_VERSION = "rerank-2026-09-18-v2";
+var TOP_CANDIDATES = 40;
+var RERANK_WEIGHTS = {
+  exactName: 0.9,
+  namePrefix: 0.5,
+  queryInName: 0.4,
+  keywordExact: 0.3,
+  descCoverage: 0.2
+};
+var RERANK_CAP = 1;
+var MIX = { bm25: 0.7, rerank: 0.3 };
+var NORM_K = 8;
+function rankResults(candidates, query, limit, tokenize) {
+  const normalizedQuery = query.trim().toLowerCase();
+  const queryTokens = [...new Set(tokenize(query))];
+  const rerankCache = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const group = groups.get(candidate.contentHash) ?? [];
+    group.push(candidate);
+    groups.set(candidate.contentHash, group);
+  }
+  const orderedGroups = [...groups.values()].map((group) => group.slice().sort(byGroupOrder));
+  const pool = orderedGroups.map((group) => group[0]).sort(byGroupOrder).slice(0, TOP_CANDIDATES);
+  const scored = pool.map((candidate) => {
+    const rerank = rerankScore(candidate, normalizedQuery, queryTokens, tokenize, rerankCache);
+    return {
+      candidate,
+      final: stableFinal(
+        MIX.bm25 * (candidate.bm25 / (candidate.bm25 + NORM_K)) + MIX.rerank * rerank
+      )
+    };
+  });
+  scored.sort(byFrozenTieBreak);
+  return scored.slice(0, limit).map(({ candidate, final }) => {
+    const group = groups.get(candidate.contentHash) ?? [candidate];
+    const members = group.filter((member) => member !== candidate).sort(byGroupOrder);
+    return {
+      id: candidate.id,
+      name: candidate.name,
+      description: candidate.description,
+      canonicalPath: candidate.canonicalPath,
+      installations: mergeInstallations(candidate, members),
+      contentHash: candidate.contentHash,
+      disabled: candidate.disabled,
+      conflict: candidate.conflict,
+      score: final,
+      duplicates: members.map((member) => ({
+        id: member.id,
+        canonicalPath: member.canonicalPath
+      }))
+    };
+  });
+}
+function byGroupOrder(left, right) {
+  if (left.bm25 !== right.bm25) return right.bm25 - left.bm25;
+  return left.canonicalPath < right.canonicalPath ? -1 : left.canonicalPath > right.canonicalPath ? 1 : 0;
+}
+function mergeInstallations(primary, members) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const installation of [primary, ...members].flatMap(
+    (candidate) => candidate.installations
+  )) {
+    const key = `${installation.path}|${installation.workspaceId}|${installation.providerId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(installation);
+  }
+  return merged;
+}
+function stableFinal(raw) {
+  return Number(raw.toPrecision(12));
+}
+function byFrozenTieBreak(left, right) {
+  if (left.final !== right.final) return right.final - left.final;
+  if (left.candidate.name !== right.candidate.name) {
+    return left.candidate.name < right.candidate.name ? -1 : 1;
+  }
+  return left.candidate.canonicalPath < right.candidate.canonicalPath ? -1 : left.candidate.canonicalPath > right.candidate.canonicalPath ? 1 : 0;
+}
+function rerankScore(candidate, normalizedQuery, queryTokens, tokenize, descriptionTokenCache) {
+  if (normalizedQuery === "") return 0;
+  const lowerName = candidate.name.toLowerCase();
+  let score = 0;
+  if (lowerName === normalizedQuery) score += RERANK_WEIGHTS.exactName;
+  if (lowerName.startsWith(normalizedQuery)) score += RERANK_WEIGHTS.namePrefix;
+  if (lowerName.includes(normalizedQuery)) score += RERANK_WEIGHTS.queryInName;
+  if (candidate.keywords.some((keyword) => keyword.toLowerCase() === normalizedQuery)) {
+    score += RERANK_WEIGHTS.keywordExact;
+  }
+  if (queryTokens.length > 0) {
+    let tokens2 = descriptionTokenCache.get(candidate.description);
+    if (!tokens2) {
+      tokens2 = new Set(tokenize(candidate.description));
+      descriptionTokenCache.set(candidate.description, tokens2);
+    }
+    const covered = queryTokens.filter((token) => tokens2.has(token)).length;
+    score += RERANK_WEIGHTS.descCoverage * (covered / queryTokens.length);
+  }
+  return Math.min(score, RERANK_CAP);
+}
+
+// src/daemon/skill-search/tokenizer.ts
+var TOKENIZER_VERSION = "segmenter-bigram-v1";
+var CJK_SCRIPTS_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+var CJK_RUN_SOURCE = "[\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}\\p{Script=Hangul}]+";
+var LATIN_RUN_SOURCE = "[@A-Za-z0-9:/._-]+";
+var RUN_RE = new RegExp(`${CJK_RUN_SOURCE}|${LATIN_RUN_SOURCE}|.`, "gu");
+var CJK_RUN_START_RE = new RegExp(`^${CJK_RUN_SOURCE}`, "u");
+var CAMEL_RE = new RegExp("\\p{Lu}+(?=\\p{Lu}[\\p{Ll}\\d])|\\p{Lu}[\\p{Ll}\\d]*|\\p{Lu}+|\\p{Ll}+|\\d+", "gu");
+function probeSegmenter() {
+  if (typeof Intl.Segmenter === "undefined") return null;
+  let segmenter2;
+  try {
+    segmenter2 = new Intl.Segmenter("zh", { granularity: "word" });
+  } catch {
+    return null;
+  }
+  const words = [...segmenter2.segment("\u7EC4\u4EF6\u8BBE\u8BA1")].filter((segment) => segment.isWordLike).map((segment) => segment.segment);
+  if (words.length === 0) return null;
+  if (words.every((word) => [...word].length === 1)) return null;
+  return segmenter2;
+}
+function createSkillTokenizer() {
+  const segmenter2 = probeSegmenter();
+  function segmentCjk(text) {
+    if (!segmenter2) return [...text];
+    return [...segmenter2.segment(text)].filter((segment) => segment.isWordLike).map((segment) => segment.segment);
+  }
+  return { tokenize };
+  function tokenize(text) {
+    const normalized = text.normalize("NFKC");
+    const out = [];
+    for (const match of normalized.matchAll(RUN_RE)) {
+      const run = match[0];
+      if (CJK_RUN_START_RE.test(run)) {
+        emitCjkRun(segmentCjk(run), out);
+      } else if (/^[@A-Za-z0-9]/.test(run)) {
+        splitLatinIdent(run, out);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const tokens2 = [];
+    for (const token of out) {
+      const lowered = token.toLowerCase();
+      if (seen.has(lowered)) continue;
+      seen.add(lowered);
+      tokens2.push(lowered);
+    }
+    return tokens2.filter(
+      (token) => CJK_SCRIPTS_RE.test(token) ? [...token].length >= 1 : token.length >= 2 || /\d/.test(token)
+    );
+  }
+}
+function emitCjkRun(words, out) {
+  let i = 0;
+  while (i < words.length) {
+    const word = words[i];
+    if ([...word].length >= 2) {
+      out.push(word);
+      i += 1;
+      continue;
+    }
+    let j = i;
+    while (j < words.length && [...words[j]].length === 1) j += 1;
+    const singles = words.slice(i, j);
+    if (singles.length === 1) {
+      out.push(singles[0]);
+    } else {
+      for (let k = 0; k + 1 < singles.length; k++) {
+        out.push(singles[k] + singles[k + 1]);
+      }
+    }
+    i = j;
+  }
+}
+function emitKebab(chunk, out) {
+  const atoms = chunk.split(/[^A-Za-z0-9]+/).filter((atom) => atom.length > 0);
+  for (const atom of atoms) {
+    const words = atom.match(CAMEL_RE) ?? [atom];
+    out.push(...words);
+    if (words.length > 1) out.push(atom.toLowerCase());
+  }
+  if (atoms.length > 1) out.push(atoms.join("-").toLowerCase());
+}
+function splitLatinIdent(run, out) {
+  const parts = run.split("/");
+  if (parts.length >= 2) {
+    const last = parts[parts.length - 1];
+    const owner = parts[parts.length - 2];
+    if (/^@?[a-z0-9][a-z0-9._-]*$/i.test(owner) && /^[a-z0-9][a-z0-9._-]*$/i.test(last)) {
+      const scope = owner.replace(/^@/, "");
+      out.push(scope, last, `${scope}/${last}`);
+    }
+    for (const part of parts) emitKebab(part, out);
+    return;
+  }
+  emitKebab(run, out);
+}
+
+// src/daemon/skill-search/index.ts
+var SCHEMA_VERSION = 3;
+var ENGINE_NAME = "minisearch";
+var SEARCH_INDEX_FILE = "search-index.json";
+var SEARCH_FIELDS = ["name", "description", "keywords", "triggers", "headings", "body"];
+var FIELD_BOOST = {
+  name: 10,
+  description: 6,
+  keywords: 5,
+  triggers: 5,
+  headings: 3,
+  body: 1
+};
+var STORE_FIELDS = [
+  "name",
+  "description",
+  "keywords",
+  "canonicalPath",
+  "installations",
+  "contentHash",
+  "disabled",
+  "conflict",
+  "invalidFrontmatter"
+];
+var SEARCH_PREFIX = true;
+var SEARCH_FUZZY = 0.2;
+var REBUILD_DISCARD_RATIO = 0.2;
+var ENGINE_CONFIG_DIGEST = createHash7("sha256").update(
+  JSON.stringify({
+    fields: [...SEARCH_FIELDS],
+    boost: FIELD_BOOST,
+    prefix: SEARCH_PREFIX,
+    fuzzy: SEARCH_FUZZY,
+    processTerm: "identity"
+  })
+).digest("hex").slice(0, 16);
+var SkillSearchIndexError = class extends DomainError {
+  constructor(message, options2) {
+    super("UNAVAILABLE", message, options2);
+    this.name = "SkillSearchIndexError";
+  }
+};
+var FileIdentitySchema = z21.object({
+  path: z21.string().min(1),
+  mtimeMs: z21.number(),
+  size: z21.number(),
+  ino: z21.number(),
+  ctimeMs: z21.number()
+}).strict();
+var StatEnvelopeSchema = z21.object({
+  canonicalPath: z21.string().min(1),
+  files: z21.array(FileIdentitySchema).min(1),
+  installations: z21.array(SkillInstallationSchema).min(1),
+  contentHash: z21.string().regex(/^[a-f0-9]{64}$/),
+  disabled: z21.boolean(),
+  conflict: z21.boolean(),
+  invalidFrontmatter: z21.boolean()
+}).strict();
+var IndexEnvelopeSchema = z21.object({
+  schemaVersion: z21.literal(3),
+  tokenizerVersion: z21.string(),
+  parserVersion: z21.string(),
+  rankingVersion: z21.string(),
+  engine: z21.object({ name: z21.string(), version: z21.string(), configDigest: z21.string() }).strict(),
+  /** 生效排除配置的冻结摘要（配置变更触发全量重建）。 */
+  searchConfigDigest: z21.string().min(1),
+  /** 载荷完整性摘要：sha256(JSON.stringify({index, stats}))，写入时计算、加载时重算。 */
+  payloadDigest: z21.string().regex(/^[a-f0-9]{64}$/),
+  index: z21.unknown(),
+  stats: z21.record(SkillIdSchema, StatEnvelopeSchema)
+}).strict();
+var StoredProjectionSchema = z21.object({
+  name: z21.string(),
+  description: z21.string(),
+  keywords: z21.array(z21.string()),
+  canonicalPath: z21.string().min(1),
+  installations: z21.array(SkillInstallationSchema).min(1),
+  contentHash: z21.string().regex(/^[a-f0-9]{64}$/),
+  disabled: z21.boolean(),
+  conflict: z21.boolean(),
+  invalidFrontmatter: z21.boolean()
+});
+function createSearchMiniSearch(tokenizer) {
+  return new MiniSearch(miniSearchOptions(tokenizer));
+}
+function searchMiniSearchInstance(miniSearch, query) {
+  const results = miniSearch.search(query, {
+    boost: FIELD_BOOST,
+    prefix: SEARCH_PREFIX,
+    fuzzy: SEARCH_FUZZY
+  });
+  const candidates = [];
+  for (const result of results) {
+    const id = SkillIdSchema.safeParse(result.id);
+    if (!id.success) continue;
+    const stored = miniSearch.getStoredFields(result.id);
+    const projection = stored ? safeParseExternal(StoredProjectionSchema, stored) : null;
+    if (!projection) continue;
+    candidates.push({
+      id: id.data,
+      bm25: result.score,
+      ...projection
+    });
+  }
+  return candidates;
+}
+function miniSearchOptions(tokenizer) {
+  return {
+    fields: [...SEARCH_FIELDS],
+    storeFields: [...STORE_FIELDS],
+    tokenize: (text) => tokenizer.tokenize(text),
+    processTerm: (term) => term,
+    stringifyField: (value) => Array.isArray(value) ? value.join(" ") : String(value),
+    autoVacuum: false
+  };
+}
+function createSkillSearchIndex(tokenizer = createSkillTokenizer(), getSearchConfigDigest = () => UNCONFIGURED_CONFIG_DIGEST) {
+  return new MiniSearchSkillSearchIndex(tokenizer, getSearchConfigDigest);
+}
+var UNCONFIGURED_CONFIG_DIGEST = createHash7("sha256").digest("hex");
+var MiniSearchSkillSearchIndex = class {
+  constructor(tokenizer, getSearchConfigDigest) {
+    this.tokenizer = tokenizer;
+    this.getSearchConfigDigest = getSearchConfigDigest;
+    this.miniSearch = createSearchMiniSearch(tokenizer);
+  }
+  tokenizer;
+  getSearchConfigDigest;
+  miniSearch;
+  stats = /* @__PURE__ */ new Map();
+  loaded = false;
+  freshen(scans, readDocument) {
+    if (!this.loaded) {
+      const load3 = this.loadFromDisk();
+      this.loaded = true;
+      if (load3.kind !== "ok") {
+        return this.rebuild(scans, readDocument, load3.reason);
+      }
+      this.miniSearch = load3.miniSearch;
+      this.stats = load3.stats;
+    }
+    const scanById = new Map(scans.map((scan2) => [scan2.id, scan2]));
+    const indexedIds = new Set(this.stats.keys());
+    const removed = [...indexedIds].filter((id) => !scanById.has(id));
+    const changed = [];
+    for (const scan2 of scans) {
+      const stat2 = this.stats.get(scan2.id);
+      if (!stat2 || !statIsCurrent(stat2, scan2)) changed.push(scan2);
+    }
+    const discardOperations = removed.length + changed.filter((scan2) => indexedIds.has(scan2.id)).length;
+    const dirtyRatio = indexedIds.size === 0 ? 1 : discardOperations / indexedIds.size;
+    if (dirtyRatio > REBUILD_DISCARD_RATIO) {
+      return this.rebuild(scans, readDocument, "dirty-ratio");
+    }
+    if (removed.length === 0 && changed.length === 0) {
+      return { mode: "fresh", documents: this.stats.size, parsed: 0, discarded: 0 };
+    }
+    const documents = changed.map((scan2) => ({ scan: scan2, document: readDocument(scan2) }));
+    const snapshotIndex = this.miniSearch.toJSON();
+    const snapshotStats = new Map(this.stats);
+    let parsed = 0;
+    try {
+      for (const id of removed) {
+        this.discardIndexed(id);
+        this.stats.delete(id);
+      }
+      for (const { scan: scan2, document: document2 } of documents) {
+        if (indexedIds.has(scan2.id)) this.discardIndexed(scan2.id);
+        this.miniSearch.add(document2);
+        this.stats.set(scan2.id, statEntry(scan2, document2));
+        parsed += 1;
+      }
+      this.save();
+    } catch (error) {
+      this.restoreSnapshot(snapshotIndex, snapshotStats);
+      if (error instanceof SkillSearchIndexError) this.invalidateAfterSaveFailure();
+      throw error;
+    }
+    return {
+      mode: "incremental",
+      documents: this.stats.size,
+      parsed,
+      discarded: discardOperations
+    };
+  }
+  search(query) {
+    return searchMiniSearchInstance(this.miniSearch, query);
+  }
+  duplicates() {
+    const byHash = /* @__PURE__ */ new Map();
+    for (const [id, stat2] of this.stats) {
+      const group = byHash.get(stat2.contentHash) ?? [];
+      group.push({ id, stat: stat2 });
+      byHash.set(stat2.contentHash, group);
+    }
+    const groups = [];
+    for (const [contentHash, entries] of byHash) {
+      if (entries.length < 2) continue;
+      entries.sort(
+        (left, right) => compareCanonicalPath(left.stat.canonicalPath, right.stat.canonicalPath)
+      );
+      const members = [];
+      for (const { id, stat: stat2 } of entries) {
+        const stored = this.miniSearch.getStoredFields(id);
+        const name = typeof stored?.name === "string" ? stored.name : null;
+        if (name === null) continue;
+        members.push({
+          id,
+          name,
+          canonicalPath: stat2.canonicalPath,
+          installations: stat2.installations,
+          disabled: stat2.disabled,
+          conflict: stat2.conflict
+        });
+      }
+      if (members.length >= 2) groups.push({ contentHash, members });
+    }
+    groups.sort(
+      (left, right) => compareCanonicalPath(left.members[0].canonicalPath, right.members[0].canonicalPath)
+    );
+    return groups;
+  }
+  documentCount() {
+    return this.miniSearch.documentCount;
+  }
+  rebuild(scans, readDocument, reason) {
+    const discarded = this.stats.size;
+    const miniSearch = createSearchMiniSearch(this.tokenizer);
+    const stats = /* @__PURE__ */ new Map();
+    for (const scan2 of scans) {
+      const document2 = readDocument(scan2);
+      miniSearch.add(document2);
+      stats.set(scan2.id, statEntry(scan2, document2));
+    }
+    const envelopeIndex = miniSearch.toJSON();
+    const envelopeStats = Object.fromEntries(stats);
+    try {
+      this.persist(envelopeIndex, envelopeStats);
+    } catch (error) {
+      this.invalidateAfterSaveFailure();
+      throw error;
+    }
+    this.miniSearch = miniSearch;
+    this.stats = stats;
+    return {
+      mode: "rebuilt",
+      documents: stats.size,
+      parsed: scans.length,
+      discarded,
+      rebuildReason: reason
+    };
+  }
+  /** 落盘失败后清空不可持久化的内存快照，下一次调用必须重新读取磁盘真相。 */
+  invalidateAfterSaveFailure() {
+    this.loaded = false;
+    this.miniSearch = createSearchMiniSearch(this.tokenizer);
+    this.stats = /* @__PURE__ */ new Map();
+  }
+  /** 增量变更阶段失败后恢复本轮开始前的完整成员状态（索引原子一致性）。 */
+  restoreSnapshot(snapshotIndex, snapshotStats) {
+    try {
+      this.miniSearch = MiniSearch.loadJSON(
+        JSON.stringify(snapshotIndex),
+        miniSearchOptions(this.tokenizer)
+      );
+      this.stats = snapshotStats;
+    } catch {
+      this.invalidateAfterSaveFailure();
+    }
+  }
+  discardIndexed(id) {
+    if (this.miniSearch.has(id)) this.miniSearch.discard(id);
+  }
+  loadFromDisk() {
+    const file = path15.join(appDir(), SEARCH_INDEX_FILE);
+    let source;
+    try {
+      source = fs12.readFileSync(file, "utf8");
+    } catch (error) {
+      if (error instanceof Error && error.code === "ENOENT") {
+        return { kind: "empty", reason: "missing" };
+      }
+      throw new SkillSearchIndexError(
+        `Cannot read the skill search index ${file}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+    const envelope = safeParseJson(source, IndexEnvelopeSchema);
+    if (!envelope) return { kind: "empty", reason: "corrupt" };
+    if (payloadDigest(envelope.index, envelope.stats) !== envelope.payloadDigest) {
+      return { kind: "empty", reason: "corrupt" };
+    }
+    if (envelope.tokenizerVersion !== TOKENIZER_VERSION || envelope.parserVersion !== PARSER_VERSION || envelope.rankingVersion !== RANKING_VERSION || envelope.engine.name !== ENGINE_NAME || envelope.engine.version !== minisearchRuntimeVersion() || envelope.engine.configDigest !== ENGINE_CONFIG_DIGEST || envelope.searchConfigDigest !== this.getSearchConfigDigest()) {
+      return { kind: "empty", reason: "incompatible" };
+    }
+    try {
+      const serialized = safeParseExternal(
+        z21.object({
+          documentIds: z21.record(z21.string(), z21.string()),
+          storedFields: z21.record(z21.string(), z21.unknown())
+        }).passthrough(),
+        envelope.index
+      );
+      if (!serialized) return { kind: "empty", reason: "corrupt" };
+      const shortIds = Object.keys(serialized.documentIds);
+      const activeIdValues = Object.values(serialized.documentIds);
+      const activeIds = new Set(activeIdValues);
+      const statIds = new Set(Object.keys(envelope.stats));
+      const storedFieldIds = Object.keys(serialized.storedFields);
+      if (activeIds.size !== activeIdValues.length || activeIds.size !== statIds.size || activeIdValues.some((id) => !statIds.has(id)) || storedFieldIds.length !== shortIds.length || shortIds.some((shortId) => !Object.hasOwn(serialized.storedFields, shortId))) {
+        return { kind: "empty", reason: "corrupt" };
+      }
+      const miniSearch = MiniSearch.loadJSON(
+        JSON.stringify(envelope.index),
+        miniSearchOptions(this.tokenizer)
+      );
+      for (const [id, stat2] of Object.entries(envelope.stats)) {
+        if (!miniSearch.has(id)) return { kind: "empty", reason: "corrupt" };
+        const stored = miniSearch.getStoredFields(id);
+        const projection = stored ? safeParseExternal(StoredProjectionSchema, stored) : null;
+        if (!projection || projection.canonicalPath !== stat2.canonicalPath || projection.contentHash !== stat2.contentHash || projection.disabled !== stat2.disabled || projection.conflict !== stat2.conflict || projection.invalidFrontmatter !== stat2.invalidFrontmatter || JSON.stringify(projection.installations) !== JSON.stringify(stat2.installations)) {
+          return { kind: "empty", reason: "corrupt" };
+        }
+      }
+      return { kind: "ok", miniSearch, stats: new Map(Object.entries(envelope.stats)) };
+    } catch {
+      return { kind: "empty", reason: "corrupt" };
+    }
+  }
+  save() {
+    this.persist(this.miniSearch.toJSON(), Object.fromEntries(this.stats));
+  }
+  /** 组装五版本信封并原子落盘；载荷摘要随写计算。 */
+  persist(index, stats) {
+    const file = path15.join(appDir(), SEARCH_INDEX_FILE);
+    const envelope = {
+      schemaVersion: SCHEMA_VERSION,
+      tokenizerVersion: TOKENIZER_VERSION,
+      parserVersion: PARSER_VERSION,
+      rankingVersion: RANKING_VERSION,
+      engine: {
+        name: ENGINE_NAME,
+        version: minisearchRuntimeVersion(),
+        configDigest: ENGINE_CONFIG_DIGEST
+      },
+      searchConfigDigest: this.getSearchConfigDigest(),
+      payloadDigest: payloadDigest(index, stats),
+      index,
+      stats
+    };
+    try {
+      atomicWriteUtf8(file, JSON.stringify(envelope));
+    } catch (error) {
+      throw new SkillSearchIndexError(
+        `Cannot persist the skill search index ${file}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+};
+function compareCanonicalPath(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function payloadDigest(index, stats) {
+  return createHash7("sha256").update(JSON.stringify({ index, stats })).digest("hex");
+}
+function statIsCurrent(stat2, scan2) {
+  if (stat2.canonicalPath !== scan2.canonicalPath || stat2.disabled !== scan2.disabled || stat2.conflict !== scan2.conflict || stat2.files.length !== scan2.files.length) {
+    return false;
+  }
+  for (let index = 0; index < stat2.files.length; index += 1) {
+    const indexed = stat2.files[index];
+    const candidate = scan2.files[index];
+    if (indexed.path !== candidate.path || indexed.mtimeMs !== candidate.mtimeMs || indexed.size !== candidate.size || indexed.ino !== candidate.ino || indexed.ctimeMs !== candidate.ctimeMs) {
+      return false;
+    }
+  }
+  return stat2.installations.length === scan2.installations.length && stat2.installations.every((installation, index) => {
+    const candidate = scan2.installations[index];
+    return installation.path === candidate.path && installation.workspaceId === candidate.workspaceId && installation.providerId === candidate.providerId;
+  });
+}
+function statEntry(scan2, document2) {
+  return {
+    canonicalPath: scan2.canonicalPath,
+    files: scan2.files,
+    installations: document2.installations,
+    contentHash: document2.contentHash,
+    disabled: document2.disabled,
+    conflict: document2.conflict,
+    invalidFrontmatter: document2.invalidFrontmatter
+  };
+}
+var cachedRuntimeVersion = null;
+function minisearchRuntimeVersion() {
+  if (cachedRuntimeVersion) return cachedRuntimeVersion;
+  try {
+    const require2 = createRequire4(import.meta.url);
+    const entry = require2.resolve("minisearch");
+    let directory = path15.dirname(entry);
+    for (let hop = 0; hop < 4; hop += 1) {
+      const packageFile = path15.join(directory, "package.json");
+      if (fs12.existsSync(packageFile)) {
+        const version = safeParseJson(
+          fs12.readFileSync(packageFile, "utf8"),
+          z21.object({ version: z21.string() })
+        )?.version;
+        cachedRuntimeVersion = version ?? "unresolved";
+        return cachedRuntimeVersion;
+      }
+      directory = path15.dirname(directory);
+    }
+    cachedRuntimeVersion = "unresolved";
+  } catch {
+    cachedRuntimeVersion = "unresolved";
+  }
+  return cachedRuntimeVersion;
+}
+
+// src/daemon/skill-search/config.ts
+var SEARCH_CONFIG_FILE = "search-config.toml";
+var TEMPLATE_EXCLUDE_DIRS = [
+  ".cargo",
+  ".cache",
+  ".npm",
+  ".pnpm-store",
+  ".bun",
+  ".rustup",
+  ".local"
+];
+var SearchConfigSchema = z22.object({
+  excludeDirs: z22.array(z22.string().min(1)).default([])
+}).strict();
+function searchConfigPath() {
+  return path16.join(appDir(), SEARCH_CONFIG_FILE);
+}
+function searchConfigTemplate() {
+  return `# Skill search content configuration (server-owned).
+# \u6280\u80FD\u6B63\u6587\u7D22\u5F15\u4F1A\u6536\u96C6\u6280\u80FD\u76EE\u5F55\u5185\u7684\u5176\u4F59 *.md\uFF1B\u4E0B\u5217\u76EE\u5F55\u540D\u4E0D\u4F1A\u8FDB\u5165\u6536\u96C6
+# \uFF08\u5728\u5185\u7F6E\u6E05\u5355\u4E4B\u4E0A\u8FFD\u52A0\uFF0C\u53EA\u80FD\u589E\u52A0\u6392\u9664\uFF1B\u4EE5 "." \u5F00\u5934\u7684\u76EE\u5F55\u59CB\u7EC8\u5168\u8DF3\uFF0C
+# \u5185\u7F6E\u6E05\u5355\u4E0D\u53EF\u79FB\u9664\uFF09\u3002\u4FEE\u6539\u540E\u4E0B\u4E00\u6B21\u7D22\u5F15\u7EF4\u62A4\u4F1A\u81EA\u52A8\u5168\u91CF\u91CD\u5EFA\u3002
+excludeDirs = [
+  ${TEMPLATE_EXCLUDE_DIRS.map((dir) => `"${dir}"`).join(",\n  ")},
+]
+`;
+}
+function loadSkillSearchConfig() {
+  const file = searchConfigPath();
+  let source;
+  try {
+    source = fs13.readFileSync(file, "utf8");
+  } catch (error) {
+    const code = error instanceof Error ? error.code : void 0;
+    if (code === "ENOENT") {
+      writeTemplate(file);
+      return effectiveConfig(TEMPLATE_EXCLUDE_DIRS);
+    }
+    throw new SkillSearchIndexError(
+      `Cannot read the skill search config ${file}: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  let raw;
+  try {
+    raw = parseToml(source);
+  } catch {
+    return effectiveConfig([]);
+  }
+  const parsed = safeParseExternal(SearchConfigSchema, raw);
+  return effectiveConfig(parsed ? parsed.excludeDirs : []);
+}
+function effectiveConfig(extraDirs) {
+  const merged = [.../* @__PURE__ */ new Set([...BUILTIN_EXCLUDED_DIRS, ...extraDirs])].sort();
+  return { excludedDirs: merged, configDigest: digestOf(merged) };
+}
+function digestOf(dirs) {
+  return createHash8("sha256").update(dirs.join("\n")).digest("hex");
+}
+function writeTemplate(file) {
+  try {
+    atomicWriteUtf8(file, searchConfigTemplate());
+  } catch (error) {
+    throw new SkillSearchIndexError(
+      `Cannot write the skill search config template ${file}: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+
+// src/daemon/skill-search/scanner.ts
+import fs14 from "node:fs";
+import path17 from "node:path";
+var MAX_DEPTH2 = 2;
+var SKILL_FILE_NAMES = ["SKILL.md", ".SKILL.md"];
+function scanSkillRoots(roots) {
+  const entries = [];
+  for (const root of roots) {
+    scanDirectory(root, root.rootPath, 1, entries);
+  }
+  entries.sort(
+    (left, right) => left.path === right.path ? compareString3(left.workspaceId, right.workspaceId) || compareString3(left.providerId, right.providerId) : compareString3(left.path, right.path)
+  );
+  return entries;
+}
+function compareString3(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function scanDirectory(root, directory, depth, entries) {
+  let dirents;
+  try {
+    dirents = fs14.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  dirents.sort((left, right) => compareString3(left.name, right.name));
+  for (const dirent of dirents) {
+    if (dirent.name.startsWith(".") || dirent.name === "node_modules") continue;
+    if (!dirent.isDirectory() && !dirent.isSymbolicLink()) continue;
+    if (depth > 1 && !dirent.isDirectory()) continue;
+    const entryPath = path17.join(directory, dirent.name);
+    let stat2;
+    try {
+      stat2 = fs14.statSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (!stat2.isDirectory()) continue;
+    if (hasSkillFile(entryPath)) {
+      entries.push({ path: entryPath, workspaceId: root.workspaceId, providerId: root.providerId });
+    }
+    if (dirent.isDirectory() && depth < MAX_DEPTH2) {
+      scanDirectory(root, entryPath, depth + 1, entries);
+    }
+  }
+}
+function hasSkillFile(entryPath) {
+  return SKILL_FILE_NAMES.some((name) => isRegularFile3(path17.join(entryPath, name)));
+}
+function isRegularFile3(file) {
+  try {
+    return fs14.lstatSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/daemon/skill-search/watcher.ts
+import fs15 from "node:fs";
+var FLUSH_DEBOUNCE_MS = 300;
+var SYNCHRONOUS_FLUSH_DOCUMENT_LIMIT = 2e4;
+var fsWatchFactory = (directory) => {
+  const watcher = fs15.watch(directory, { recursive: true, persistent: false });
+  return {
+    close: () => watcher.close(),
+    onEvent: (callback) => watcher.on("change", callback),
+    onError: (callback) => watcher.on("error", callback)
+  };
+};
+function createSkillSearchWatcher(options2) {
+  const watchFactory = options2.watch ?? fsWatchFactory;
+  const watched = /* @__PURE__ */ new Map();
+  let dirty = false;
+  let disposed = false;
+  let flushTimer = null;
+  function markDirty() {
+    if (disposed) return;
+    dirty = true;
+    if (flushTimer !== null) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      if (disposed || !dirty) return;
+      if (options2.documentCount() > SYNCHRONOUS_FLUSH_DOCUMENT_LIMIT) return;
+      try {
+        options2.onFlush();
+        dirty = false;
+      } catch {
+      }
+    }, FLUSH_DEBOUNCE_MS);
+    flushTimer.unref?.();
+  }
+  return {
+    reconcile(watchDirs) {
+      if (disposed) return;
+      const desired = new Set(watchDirs);
+      for (const [dir, entry] of watched) {
+        if (!desired.has(dir)) {
+          watched.delete(dir);
+          closeQuietly(entry);
+        }
+      }
+      for (const dir of desired) {
+        if (watched.has(dir)) continue;
+        try {
+          const handle = watchFactory(dir);
+          handle.onEvent(() => markDirty());
+          handle.onError(() => {
+            const entry = watched.get(dir);
+            if (entry) {
+              watched.delete(dir);
+              closeQuietly(entry);
+            }
+            markDirty();
+          });
+          watched.set(dir, { handle, closed: false });
+        } catch {
+        }
+      }
+    },
+    isClean(watchDirs) {
+      if (dirty) return false;
+      return watchDirs.every((dir) => watched.has(dir));
+    },
+    dispose() {
+      disposed = true;
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      for (const entry of watched.values()) closeQuietly(entry);
+      watched.clear();
+      dirty = false;
+    },
+    watchedCount() {
+      return watched.size;
+    }
+  };
+}
+function closeQuietly(entry) {
+  if (entry.closed) return;
+  entry.closed = true;
+  try {
+    entry.handle.close();
+  } catch {
+  }
+}
+
+// src/daemon/skill-search/service.ts
+var SkillSearchDocumentReadError = class extends DomainError {
+  constructor(message, options2) {
+    super("UNAVAILABLE", message, options2);
+    this.name = "SkillSearchDocumentReadError";
+  }
+};
+function createSkillSearchService() {
+  return createSkillSearchEngine(defaultResolveRoots(createWorkspaceRegistryPersistence()));
+}
+function createSkillSearchEngine(resolveRoots) {
+  const tokenizer = createSkillTokenizer();
+  let config = null;
+  const index = createSkillSearchIndex(tokenizer, () => config?.configDigest ?? "");
+  try {
+    config = loadSkillSearchConfig();
+  } catch (error) {
+    console.warn(
+      `[skill-search] config priming failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  let cachedWatchDirs = [];
+  let cachedRootsKey = null;
+  function maintain() {
+    const activeConfig = loadSkillSearchConfig();
+    config = activeConfig;
+    const roots = resolveRoots();
+    const candidates = scanSkillRoots(roots);
+    const excluded = new Set(activeConfig.excludedDirs);
+    const scans = canonicalizeCandidates(candidates, excluded);
+    index.freshen(scans, readSkillSearchDocument);
+    cachedWatchDirs = canonicalWatchDirs(roots);
+    cachedRootsKey = rootsKeyOf(roots);
+    watcher.reconcile(cachedWatchDirs);
+  }
+  const watcher = createSkillSearchWatcher({
+    onFlush: () => maintain(),
+    documentCount: () => index.documentCount()
+  });
+  function ensureMaintained() {
+    const roots = resolveRoots();
+    const rootsChanged = cachedRootsKey !== rootsKeyOf(roots);
+    const configChanged = config === null || loadSkillSearchConfig().configDigest !== config.configDigest;
+    if (rootsChanged || configChanged || !watcher.isClean(cachedWatchDirs)) {
+      maintain();
+    }
+  }
+  return {
+    /** 检索本地 skills；query 为空字符串时返回空结果（CLI 层负责把空 query 判为用法错误）。 */
+    search: async (query, searchOptions) => {
+      const parsedOptions = SkillSearchOptionsSchema.parse(searchOptions ?? {});
+      if (query.trim() === "") return [];
+      ensureMaintained();
+      const hits = index.search(query);
+      return rankResults(hits, query, parsedOptions.limit, (text) => tokenizer.tokenize(text));
+    },
+    /**
+     * 内容重复组投影（与 search 共用维护门：clean + 配置未变时零扫描直读内存）。
+     */
+    duplicates: async () => {
+      ensureMaintained();
+      return index.duplicates().map((group) => ({
+        contentHash: group.contentHash,
+        members: group.members.map((member) => ({
+          ...member,
+          id: SkillIdSchema.parse(member.id)
+        }))
+      }));
+    },
+    /** watcher 回收（daemon stop coordinator 接线；幂等）。 */
+    dispose: () => {
+      watcher.dispose();
+    }
+  };
+}
+function canonicalWatchDirs(roots) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    try {
+      dirs.add(fs16.realpathSync(root.rootPath));
+    } catch {
+    }
+  }
+  return [...dirs].sort();
+}
+function rootsKeyOf(roots) {
+  return roots.map((root) => `${root.workspaceId}:${root.providerId}:${root.rootPath}`).sort().join("|");
+}
+function readSkillSearchDocument(scan2) {
+  const sourceIdentity = scan2.files.find((file) => file.path === scan2.sourcePath);
+  if (!sourceIdentity) {
+    throw new SkillSearchDocumentReadError(
+      `The scanned skill identity source is missing from the file set: ${scan2.sourcePath}`
+    );
+  }
+  const extras = [];
+  for (const file of scan2.files) {
+    if (file.path === scan2.sourcePath) continue;
+    extras.push({ path: file.path, raw: readFileWithIdentity(file.path, file) });
+  }
+  const sourceRaw = readFileWithIdentity(scan2.sourcePath, sourceIdentity);
+  const parsed = parseSkillDocumentSet(sourceRaw, extras, path18.basename(scan2.canonicalPath));
+  return {
+    id: scan2.id,
+    name: parsed.name,
+    description: parsed.description,
+    keywords: parsed.keywords,
+    triggers: parsed.triggers,
+    headings: parsed.headings,
+    body: parsed.body,
+    canonicalPath: scan2.canonicalPath,
+    installations: scan2.installations,
+    contentHash: parsed.contentHash,
+    disabled: scan2.disabled,
+    conflict: scan2.conflict,
+    invalidFrontmatter: parsed.invalidFrontmatter
+  };
+}
+function readFileWithIdentity(filePath, identity2) {
+  let fd = null;
+  try {
+    try {
+      const noFollow = process.platform === "win32" ? 0 : fs16.constants.O_NOFOLLOW;
+      fd = fs16.openSync(filePath, fs16.constants.O_RDONLY | noFollow);
+    } catch (error) {
+      throw new SkillSearchDocumentReadError(
+        `Cannot open the scanned skill file ${filePath} without following a symlink.`,
+        { cause: error }
+      );
+    }
+    const descriptorStat = fs16.fstatSync(fd);
+    if (!descriptorStat.isFile() || descriptorStat.ino !== identity2.ino || descriptorStat.size !== identity2.size) {
+      throw new SkillSearchDocumentReadError(
+        `The scanned skill file identity changed before read: ${filePath}`
+      );
+    }
+    return fs16.readFileSync(fd);
+  } catch (error) {
+    if (error instanceof SkillSearchDocumentReadError) throw error;
+    throw new SkillSearchDocumentReadError(`Cannot read the scanned skill file ${filePath}.`, {
+      cause: error
+    });
+  } finally {
+    if (fd !== null) fs16.closeSync(fd);
+  }
+}
+function defaultResolveRoots(stateSource) {
+  return () => {
+    const roots = [];
+    for (const provider of PROVIDER_CATALOG) {
+      const rootPath = globalProviderRoot(provider);
+      if (rootPath === null) continue;
+      roots.push({
+        rootPath,
+        workspaceId: GLOBAL_WORKSPACE_ID,
+        providerId: ProviderIdSchema.parse(provider.id)
+      });
+    }
+    const state = stateSource.load();
+    for (const workspace of state.workspaces) {
+      for (const provider of PROVIDER_CATALOG) {
+        roots.push({
+          rootPath: importedProviderRoot(workspace.path, provider),
+          workspaceId: workspace.id,
+          providerId: ProviderIdSchema.parse(provider.id)
+        });
+      }
+    }
+    return roots;
+  };
+}
+
+// src/daemon/search-config-opener.ts
+import { spawn as spawn5 } from "node:child_process";
+function platformOpenFile(filePath) {
+  const platform2 = process.platform;
+  if (platform2 === "win32") {
+    return spawnDetached({ file: "cmd", args: ["/c", "start", "", filePath] });
+  }
+  const command = platform2 === "darwin" ? { file: "open", args: [filePath] } : { file: "xdg-open", args: [filePath] };
+  return spawnDetached(command, { checkExitCode: true });
+}
+function spawnDetached(command, options2 = {}) {
+  const label = `${command.file} ${command.args.join(" ")}`;
+  return new Promise((resolve2, reject) => {
+    let child;
+    try {
+      child = spawn5(command.file, command.args, { detached: true, stdio: "ignore" });
+    } catch (error) {
+      reject(openerError(label, error));
+      return;
+    }
+    child.on("error", (error) => reject(openerError(label, error)));
+    child.unref();
+    if (!options2.checkExitCode) {
+      resolve2();
+      return;
+    }
+    child.on("exit", (code) => {
+      if (code !== null && code !== 0) {
+        reject(
+          new DomainError(
+            "UNAVAILABLE",
+            `Cannot open the search config with ${label}: exited with code ${code} (no default application?)`
+          )
+        );
+      } else {
+        resolve2();
+      }
+    });
+  });
+}
+function openerError(label, cause) {
+  return new DomainError(
+    "UNAVAILABLE",
+    `Cannot open the search config with ${label}: ${cause instanceof Error ? cause.message : String(cause)}`,
+    { cause }
+  );
+}
+
+// src/daemon/dialog-service.ts
+async function attachExtDialog(tray) {
+  const ext = await import("@opentray/ext-dialog");
+  return ext.attachDialog(tray);
+}
+function createDialogService(options2 = {}) {
+  const attachDialog = options2.attachDialog ?? attachExtDialog;
+  let picker = null;
+  return {
+    attach(tray) {
+      if (picker !== null) return;
+      try {
+        void Promise.resolve(attachDialog(tray)).then((attached) => {
+          picker = attached;
+        }).catch(() => void 0);
+      } catch {
+      }
+    },
+    async pickDirectory() {
+      if (picker === null) return { supported: false, path: null };
+      try {
+        return { supported: true, path: await picker.pickDirectory() };
+      } catch (error) {
+        const code = error.code;
+        if (code === "dialog_platform_unsupported") {
+          return { supported: false, path: null };
+        }
+        throw new DomainError(
+          "UNAVAILABLE",
+          "The native directory picker could not be presented.",
+          { cause: error }
+        );
+      }
+    }
+  };
+}
+
 // src/daemon/skill-intelligence-service.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 
@@ -42621,7 +44277,7 @@ function analyzeDocuments(documents) {
         }
       }
       const sharedPaths = left.referencedPaths.filter(
-        (path33) => right.referencedPaths.includes(path33)
+        (path39) => right.referencedPaths.includes(path39)
       );
       if (sharedPaths.length > 0) {
         const id = findingId("shared-resource-path", [left.skillId, right.skillId]);
@@ -42635,9 +44291,9 @@ function analyzeDocuments(documents) {
             [left.skillId]: left.revision,
             [right.skillId]: right.revision
           },
-          evidence: sharedPaths.slice(0, 3).map((path33) => ({
+          evidence: sharedPaths.slice(0, 3).map((path39) => ({
             label: "shared path",
-            snippet: path33
+            snippet: path39
           }))
         });
         addEdge("shared-resource", [left.skillId, right.skillId], id);
@@ -43015,30 +44671,30 @@ function createSkillIntelligenceService(skills, creator) {
 }
 
 // src/daemon/skill-service.ts
-import fs8 from "node:fs";
-import path10 from "node:path";
-import { z as z18 } from "zod";
+import fs17 from "node:fs";
+import path19 from "node:path";
+import { z as z23 } from "zod";
 function metadataId(skillPath) {
   return SkillIdSchema.parse(opaquePathId("sk", canonicalDirectory(skillPath)));
 }
-var CcskiSkillMetadataSchema = z18.object({
-  name: z18.string(),
-  description: z18.string(),
-  disabled: z18.boolean().optional(),
-  provider: z18.string(),
+var CcskiSkillMetadataSchema = z23.object({
+  name: z23.string(),
+  description: z23.string(),
+  disabled: z23.boolean().optional(),
+  provider: z23.string(),
   location: SkillLocationSchema,
-  sourcePriority: z18.number().optional(),
-  sourceKind: z18.string().optional(),
-  path: z18.string().min(1),
-  hasReferences: z18.boolean(),
-  hasScripts: z18.boolean(),
-  hasAssets: z18.boolean(),
+  sourcePriority: z23.number().optional(),
+  sourceKind: z23.string().optional(),
+  path: z23.string().min(1),
+  hasReferences: z23.boolean(),
+  hasScripts: z23.boolean(),
+  hasAssets: z23.boolean(),
   pluginInfo: PluginInfoSchema.optional()
 });
-var CcskiValidateResultSchema = z18.object({
-  success: z18.boolean(),
-  errors: z18.array(z18.string()),
-  warnings: z18.array(z18.string())
+var CcskiValidateResultSchema = z23.object({
+  success: z23.boolean(),
+  errors: z23.array(z23.string()),
+  warnings: z23.array(z23.string())
 });
 function projectProvenance(skillPath, probeMap) {
   if (!probeMap) return { installedVia: "unknown", updatable: false };
@@ -43055,7 +44711,7 @@ function projectMetadata(source, probeMap) {
       id: metadataId(canonicalPath),
       name: skill.name,
       description: skill.description,
-      directoryName: path10.basename(canonicalPath),
+      directoryName: path19.basename(canonicalPath),
       disabled: skill.disabled ?? false,
       provider: skill.provider,
       location: skill.location,
@@ -43077,19 +44733,41 @@ function createSkillService(workspaces, options2 = {}) {
   const discoverSkills2 = options2.discoverSkills ?? listSkills;
   const validateSkill2 = options2.validateSkill ?? validateSkill;
   const skillsCliProbe = options2.skillsCliProbe;
+  const discoveryInflight = /* @__PURE__ */ new Map();
+  const discoveryKey = (target, includeDisabled) => `${target.workspaceId}:${target.providerId}:${includeDisabled}`;
+  const cachedList = (target, includeDisabled = true) => {
+    const key = discoveryKey(target, includeDisabled);
+    const existing = discoveryInflight.get(key);
+    if (existing) return existing;
+    const promise = list(workspaces, discoverSkills2, target, includeDisabled, skillsCliProbe);
+    discoveryInflight.set(key, promise);
+    const forget = () => discoveryInflight.delete(key);
+    promise.then(forget, forget);
+    return promise;
+  };
+  const invalidateTarget = (target) => {
+    discoveryInflight.delete(discoveryKey(target, true));
+    discoveryInflight.delete(discoveryKey(target, false));
+  };
   return {
-    list: (target, includeDisabled = true) => list(workspaces, discoverSkills2, target, includeDisabled, skillsCliProbe),
-    resolve: (target, skillId) => resolveSkill2(workspaces, discoverSkills2, target, skillId, skillsCliProbe),
+    list: (target, includeDisabled = true) => cachedList(target, includeDisabled),
+    resolve: (target, skillId) => resolveSkill2(cachedList, target, skillId),
     skillFile,
-    info: (target, skillId) => info2(workspaces, discoverSkills2, target, skillId, skillsCliProbe),
-    toggle: (target, skillIds, mode) => toggle(workspaces, discoverSkills2, target, skillIds, mode, skillsCliProbe),
-    validate: (target, skillId) => validate2(workspaces, discoverSkills2, validateSkill2, target, skillId, skillsCliProbe)
+    info: (target, skillId) => info2(cachedList, target, skillId),
+    toggle: (target, skillIds, mode) => toggle(cachedList, target, skillIds, mode).finally(() => invalidateTarget(target)),
+    validate: (target, skillId) => validate2(cachedList, validateSkill2, workspaces, target, skillId),
+    /**
+     * 丢弃该 target 的 discovery 缓存（写事务用）：apply/rollback 等绕过
+     * 本 service 直接写盘后，验证读必须看到新磁盘态（perf B-6 的 TTL 缓存
+     * 不知道外部写入）。
+     */
+    invalidateDiscovery: invalidateTarget
   };
 }
 async function list(workspaces, discoverSkills2, target, includeDisabled = true, skillsCliProbe) {
   const scope = workspaces.resolve(target, includeDisabled);
   const skills = await discoverSkills2(scope.options);
-  const probeMap = skillsCliProbe ? await skillsCliProbe.probe() : null;
+  const probeMap = skillsCliProbe?.peek() ?? null;
   const byId = /* @__PURE__ */ new Map();
   for (const skill of skills) {
     const projected = projectMetadata(skill, probeMap);
@@ -43099,27 +44777,25 @@ async function list(workspaces, discoverSkills2, target, includeDisabled = true,
   }
   return [...byId.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
-async function resolveSkill2(workspaces, discoverSkills2, target, skillId, skillsCliProbe) {
-  const skill = (await list(workspaces, discoverSkills2, target, true, skillsCliProbe)).find(
-    (candidate) => candidate.id === skillId
-  );
+async function resolveSkill2(loadList, target, skillId) {
+  const skill = (await loadList(target, true)).find((candidate) => candidate.id === skillId);
   if (!skill)
     throw new DomainError("NOT_FOUND", `Skill not found in Workspace Provider: ${skillId}`);
   return skill;
 }
 function skillFile(skill) {
   const filename = skill.disabled ? ".SKILL.md" : "SKILL.md";
-  const file = path10.join(skill.path, filename);
+  const file = path19.join(skill.path, filename);
   assertPathInside(skill.path, file);
-  if (!fs8.existsSync(file) || !fs8.statSync(file).isFile()) {
+  if (!fs17.existsSync(file) || !fs17.statSync(file).isFile()) {
     throw new DomainError("UNAVAILABLE", `Skill document is unavailable: ${skill.name}`);
   }
   return file;
 }
-async function info2(workspaces, discoverSkills2, target, skillId, skillsCliProbe) {
-  const skill = await resolveSkill2(workspaces, discoverSkills2, target, skillId, skillsCliProbe);
+async function info2(loadList, target, skillId) {
+  const skill = await resolveSkill2(loadList, target, skillId);
   const file = skillFile(skill);
-  const content = fs8.readFileSync(file, "utf8");
+  const content = fs17.readFileSync(file, "utf8");
   return {
     ...skill,
     size: Buffer.byteLength(content),
@@ -43127,13 +44803,8 @@ async function info2(workspaces, discoverSkills2, target, skillId, skillsCliProb
     revision: contentRevision(content)
   };
 }
-async function toggle(workspaces, discoverSkills2, target, skillIds, mode, skillsCliProbe) {
-  const discovered = new Map(
-    (await list(workspaces, discoverSkills2, target, true, skillsCliProbe)).map((skill) => [
-      skill.id,
-      skill
-    ])
-  );
+async function toggle(loadList, target, skillIds, mode) {
+  const discovered = new Map((await loadList(target, true)).map((skill) => [skill.id, skill]));
   const results = [];
   for (const skillId of skillIds) {
     const skill = discovered.get(skillId);
@@ -43146,21 +44817,21 @@ async function toggle(workspaces, discoverSkills2, target, skillIds, mode, skill
       results.push({ skillId, name: skill.name, status: "skipped" });
       continue;
     }
-    const source = path10.join(skill.path, wantsDisabled ? "SKILL.md" : ".SKILL.md");
-    const destination = path10.join(skill.path, wantsDisabled ? ".SKILL.md" : "SKILL.md");
+    const source = path19.join(skill.path, wantsDisabled ? "SKILL.md" : ".SKILL.md");
+    const destination = path19.join(skill.path, wantsDisabled ? ".SKILL.md" : "SKILL.md");
     try {
       assertPathInside(skill.path, source);
       assertPathInside(skill.path, destination);
-      if (fs8.existsSync(destination)) {
+      if (fs17.existsSync(destination)) {
         results.push({
           skillId,
           name: skill.name,
           status: "conflict",
-          error: `Both ${path10.basename(source)} and ${path10.basename(destination)} exist.`
+          error: `Both ${path19.basename(source)} and ${path19.basename(destination)} exist.`
         });
         continue;
       }
-      fs8.renameSync(source, destination);
+      fs17.renameSync(source, destination);
       results.push({ skillId, name: skill.name, status: wantsDisabled ? "disabled" : "enabled" });
     } catch {
       results.push({
@@ -43182,10 +44853,8 @@ async function toggle(workspaces, discoverSkills2, target, skillIds, mode, skill
     failed: results.filter((result) => result.status === "failed").length
   };
 }
-async function validate2(workspaces, discoverSkills2, validateSkill2, target, skillId, skillsCliProbe) {
-  const skill = (await list(workspaces, discoverSkills2, target, true, skillsCliProbe)).find(
-    (candidate) => candidate.id === skillId
-  );
+async function validate2(loadList, validateSkill2, workspaces, target, skillId) {
+  const skill = (await loadList(target, true)).find((candidate) => candidate.id === skillId);
   if (!skill)
     throw new DomainError("NOT_FOUND", `Skill not found in Workspace Provider: ${skillId}`);
   const result = safeParseExternal(
@@ -43214,9 +44883,9 @@ async function validate2(workspaces, discoverSkills2, validateSkill2, target, sk
 }
 
 // src/daemon/steward-service.ts
-import { promises as fs9 } from "node:fs";
+import { promises as fs18 } from "node:fs";
 import { randomBytes as randomBytes6 } from "node:crypto";
-import path11 from "node:path";
+import path20 from "node:path";
 
 // src/daemon/steward/harness-adapter.ts
 var HarnessProcessLostError = class extends Error {
@@ -43261,7 +44930,7 @@ function createStewardService(workspaces, skills, intelligence, options2) {
   );
   const runs = /* @__PURE__ */ new Map();
   let disposed = false;
-  const executionParent = options2.executionRootParent ?? path11.join(runDir(), "steward");
+  const executionParent = options2.executionRootParent ?? path20.join(runDir(), "steward");
   const appendEvent = (entry, event) => {
     const seq = entry.events.length > 0 ? entry.events[entry.events.length - 1].seq + 1 : 1;
     entry.events.push({ ...event, seq, at: (/* @__PURE__ */ new Date()).toISOString(), runId: entry.run.runId });
@@ -43290,7 +44959,7 @@ function createStewardService(workspaces, skills, intelligence, options2) {
   };
   const cleanupExecutionRoot = async (root) => {
     try {
-      await fs9.rm(root, { recursive: true, force: true });
+      await fs18.rm(root, { recursive: true, force: true });
     } catch {
     }
   };
@@ -43362,8 +45031,8 @@ function createStewardService(workspaces, skills, intelligence, options2) {
     if (selected.length === 0) {
       throw new DomainError("INVALID_OPERATION", "No skills selected for the steward run.");
     }
-    await fs9.mkdir(executionParent, { recursive: true });
-    const executionRoot = await fs9.mkdtemp(path11.join(executionParent, "run-"));
+    await fs18.mkdir(executionParent, { recursive: true });
+    const executionRoot = await fs18.mkdtemp(path20.join(executionParent, "run-"));
     const runId = brandRunId(`sr_${randomBytes6(12).toString("hex")}`);
     const run = {
       runId,
@@ -43417,9 +45086,9 @@ function createStewardService(workspaces, skills, intelligence, options2) {
       }
       for (const skill of selected) {
         const info3 = await skillsService.info(run.target, skill.id);
-        const destination = path11.join(entry.run.executionRoot, "skills", skill.directoryName);
-        await fs9.mkdir(destination, { recursive: true });
-        await fs9.writeFile(path11.join(destination, "SKILL.md"), info3.content, "utf8");
+        const destination = path20.join(entry.run.executionRoot, "skills", skill.directoryName);
+        await fs18.mkdir(destination, { recursive: true });
+        await fs18.writeFile(path20.join(destination, "SKILL.md"), info3.content, "utf8");
       }
       const findingSnapshots = analyzed.report.findings.map(
         (finding) => ({
@@ -43505,7 +45174,7 @@ function createStewardService(workspaces, skills, intelligence, options2) {
             directoryName: skill.directoryName,
             revision,
             disabled: skill.disabled,
-            documentPath: path11.join("skills", skill.directoryName, "SKILL.md")
+            documentPath: path20.join("skills", skill.directoryName, "SKILL.md")
           };
         }),
         findings: findingSnapshots,
@@ -43734,23 +45403,23 @@ var STEWARD_PROMPT_VERSION = "1.0.0";
 var STEWARD_TOOL_VERSION = "1.0.0";
 
 // src/daemon/steward/context-snapshot.ts
-import { createHash as createHash6, randomBytes as randomBytes7 } from "node:crypto";
-import { promises as fs10 } from "node:fs";
-import path12 from "node:path";
+import { createHash as createHash9, randomBytes as randomBytes7 } from "node:crypto";
+import { promises as fs19 } from "node:fs";
+import path21 from "node:path";
 function stewardStoreDir() {
-  return path12.join(homeDir(), "steward-store");
+  return path21.join(homeDir(), "steward-store");
 }
 function snapshotsDir() {
-  return path12.join(stewardStoreDir(), "snapshots");
+  return path21.join(stewardStoreDir(), "snapshots");
 }
 async function walkRegularFiles(directory) {
   const found = [];
-  const entries = await fs10.readdir(directory, { withFileTypes: true });
+  const entries = await fs19.readdir(directory, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".SKILL.md" || entry.name.startsWith(".tmp-")) continue;
-    const absolute = path12.join(directory, entry.name);
+    const absolute = path21.join(directory, entry.name);
     if (entry.isDirectory()) {
-      found.push(...(await walkRegularFiles(absolute)).map((rel) => path12.join(entry.name, rel)));
+      found.push(...(await walkRegularFiles(absolute)).map((rel) => path21.join(entry.name, rel)));
       continue;
     }
     if (entry.isFile()) {
@@ -43761,8 +45430,8 @@ async function walkRegularFiles(directory) {
   return found;
 }
 async function sha256File(absolute) {
-  const bytes = await fs10.readFile(absolute);
-  return { hash: createHash6("sha256").update(bytes).digest("hex"), byteSize: bytes.byteLength };
+  const bytes = await fs19.readFile(absolute);
+  return { hash: createHash9("sha256").update(bytes).digest("hex"), byteSize: bytes.byteLength };
 }
 async function buildContextSnapshot(skills, input) {
   const scopeKind = input.target.workspaceId === GLOBAL_WORKSPACE_ID ? "global" : "imported";
@@ -43825,7 +45494,7 @@ async function buildContextSnapshot(skills, input) {
     try {
       const relFiles = await walkRegularFiles(skill.path);
       for (const rel of relFiles) {
-        const { hash, byteSize: resourceBytes } = await sha256File(path12.join(skill.path, rel));
+        const { hash, byteSize: resourceBytes } = await sha256File(path21.join(skill.path, rel));
         resources.push({
           skillId: skill.id,
           relPath: rel,
@@ -43867,8 +45536,8 @@ async function buildContextSnapshot(skills, input) {
   }
   const snapshot = parsedSnapshot.data;
   try {
-    await fs10.mkdir(snapshotsDir(), { recursive: true });
-    const file = path12.join(snapshotsDir(), `${snapshotId}.json`);
+    await fs19.mkdir(snapshotsDir(), { recursive: true });
+    const file = path21.join(snapshotsDir(), `${snapshotId}.json`);
     atomicWriteUtf8(file, JSON.stringify(snapshot, null, 2));
   } catch (error) {
     throw new DomainError(
@@ -43880,15 +45549,15 @@ async function buildContextSnapshot(skills, input) {
 }
 
 // src/daemon/steward/audit-store.ts
-import { promises as fs11 } from "node:fs";
-import path13 from "node:path";
+import { promises as fs20 } from "node:fs";
+import path22 from "node:path";
 function storeFile(name) {
-  return path13.join(stewardStoreDir(), `${name}.jsonl`);
+  return path22.join(stewardStoreDir(), `${name}.jsonl`);
 }
 async function appendLine(file, value) {
   try {
-    await fs11.mkdir(path13.dirname(file), { recursive: true });
-    await fs11.appendFile(file, `${JSON.stringify(value)}
+    await fs20.mkdir(path22.dirname(file), { recursive: true });
+    await fs20.appendFile(file, `${JSON.stringify(value)}
 `, "utf8");
   } catch (error) {
     throw new DomainError(
@@ -43900,7 +45569,7 @@ async function appendLine(file, value) {
 async function readLines(file, parse2) {
   let raw;
   try {
-    raw = await fs11.readFile(file, "utf8");
+    raw = await fs20.readFile(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw new DomainError(
@@ -43959,21 +45628,21 @@ function createStewardAuditStore() {
 }
 
 // src/daemon/steward/approval-service.ts
-import { createHash as createHash8, randomBytes as randomBytes10 } from "node:crypto";
-import path17 from "node:path";
+import { createHash as createHash11, randomBytes as randomBytes10 } from "node:crypto";
+import path26 from "node:path";
 
 // src/daemon/steward/apply-transaction.ts
 import { randomBytes as randomBytes9 } from "node:crypto";
-import { promises as fs15 } from "node:fs";
-import path16 from "node:path";
+import { promises as fs24 } from "node:fs";
+import path25 from "node:path";
 
 // src/daemon/steward/journal-schema.ts
-import { promises as fs13 } from "node:fs";
-import path14 from "node:path";
-import { z as z19 } from "zod";
+import { promises as fs22 } from "node:fs";
+import path23 from "node:path";
+import { z as z24 } from "zod";
 
 // src/daemon/steward/dir-identity.ts
-import { promises as fs12 } from "node:fs";
+import { promises as fs21 } from "node:fs";
 function darwinSystemAlias(dir) {
   if (process.platform !== "darwin") return null;
   for (const root of ["/var", "/tmp", "/etc"]) {
@@ -43982,14 +45651,14 @@ function darwinSystemAlias(dir) {
   return null;
 }
 async function assertCanonicalDirectory(dir) {
-  const stat2 = await fs12.lstat(dir).catch(() => null);
+  const stat2 = await fs21.lstat(dir).catch(() => null);
   if (stat2 === null || !stat2.isDirectory() || stat2.isSymbolicLink()) {
     throw new DomainError(
       "INVALID_OPERATION",
       `manager root is not a real directory (symlinked or missing): ${dir}`
     );
   }
-  const real = await fs12.realpath(dir);
+  const real = await fs21.realpath(dir);
   const darwinAlias = darwinSystemAlias(dir);
   if (real !== dir && real !== darwinAlias) {
     throw new DomainError(
@@ -44000,7 +45669,7 @@ async function assertCanonicalDirectory(dir) {
   return { dev: stat2.dev, ino: stat2.ino };
 }
 async function verifyDirIdentity(dir, identity2) {
-  const stat2 = await fs12.lstat(dir).catch(() => null);
+  const stat2 = await fs21.lstat(dir).catch(() => null);
   if (stat2 === null || !stat2.isDirectory() || stat2.dev !== identity2.dev || stat2.ino !== identity2.ino) {
     throw new DomainError(
       "UNAVAILABLE",
@@ -44029,20 +45698,20 @@ async function anchorManagerDirectory(dir) {
 }
 
 // src/daemon/steward/journal-schema.ts
-var BackupRefSchema = z19.string().regex(/^\d+-[0-9a-f]{12}\.bin$/, {
+var BackupRefSchema = z24.string().regex(/^\d+-[0-9a-f]{12}\.bin$/, {
   message: "Manager backup reference must match `<seq>-<sha12>.bin`."
 });
-var Sha256HexSchema = z19.string().regex(/^[a-f0-9]{64}$/);
-var BackupManifestLineSchema = z19.strictObject({
+var Sha256HexSchema = z24.string().regex(/^[a-f0-9]{64}$/);
+var BackupManifestLineSchema = z24.strictObject({
   ref: BackupRefSchema,
-  seq: z19.number().int().positive(),
+  seq: z24.number().int().positive(),
   from: RelPathSchema,
   sha256: Sha256HexSchema,
-  byteSize: z19.number().int().nonnegative().max(64 * 1024 * 1024, "backup byteSize exceeds the manager ceiling")
+  byteSize: z24.number().int().nonnegative().max(64 * 1024 * 1024, "backup byteSize exceeds the manager ceiling")
 });
-var ResourceDetailSchema = z19.strictObject({
-  kind: z19.literal("resource"),
-  strategy: z19.enum(["copy", "move", "reference"]),
+var ResourceDetailSchema = z24.strictObject({
+  kind: z24.literal("resource"),
+  strategy: z24.enum(["copy", "move", "reference"]),
   from: RelPathSchema,
   to: RelPathSchema,
   /** Codex R10 P1-2/P1-7：apply 时记录的落盘字节 sha256（回滚删除前逐项校验）。 */
@@ -44066,81 +45735,81 @@ var ResourceDetailSchema = z19.strictObject({
     });
   }
 });
-var JournalEntrySchema = z19.discriminatedUnion("step", [
-  z19.strictObject({
-    seq: z19.number().int().positive(),
-    step: z19.literal("precheck"),
-    detail: z19.strictObject({
-      kind: z19.literal("precheck"),
-      targets: z19.array(SkillDirectoryNameSchema).min(1)
+var JournalEntrySchema = z24.discriminatedUnion("step", [
+  z24.strictObject({
+    seq: z24.number().int().positive(),
+    step: z24.literal("precheck"),
+    detail: z24.strictObject({
+      kind: z24.literal("precheck"),
+      targets: z24.array(SkillDirectoryNameSchema).min(1)
     })
   }),
-  z19.strictObject({
-    seq: z19.number().int().positive(),
-    step: z19.literal("edit"),
-    detail: z19.strictObject({
-      kind: z19.literal("content"),
+  z24.strictObject({
+    seq: z24.number().int().positive(),
+    step: z24.literal("edit"),
+    detail: z24.strictObject({
+      kind: z24.literal("content"),
       skillId: SkillIdSchema,
       beforeRevision: ContentRevisionSchema
     })
   }),
-  z19.strictObject({
-    seq: z19.number().int().positive(),
-    step: z19.literal("disable"),
-    detail: z19.strictObject({
-      kind: z19.literal("enablement"),
+  z24.strictObject({
+    seq: z24.number().int().positive(),
+    step: z24.literal("disable"),
+    detail: z24.strictObject({
+      kind: z24.literal("enablement"),
       skillId: SkillIdSchema,
       /** Codex R10 P1-3：apply 捕获的启停前态——undo 只恢复捕获状态。 */
-      wasDisabled: z19.boolean(),
+      wasDisabled: z24.boolean(),
       revision: ContentRevisionSchema.optional()
     })
   }),
-  z19.strictObject({
-    seq: z19.number().int().positive(),
-    step: z19.literal("enable"),
-    detail: z19.strictObject({
-      kind: z19.literal("enablement"),
+  z24.strictObject({
+    seq: z24.number().int().positive(),
+    step: z24.literal("enable"),
+    detail: z24.strictObject({
+      kind: z24.literal("enablement"),
       skillId: SkillIdSchema,
       /** Codex R10 P1-3：apply 捕获的启停前态——undo 只恢复捕获状态。 */
-      wasEnabled: z19.boolean(),
+      wasEnabled: z24.boolean(),
       revision: ContentRevisionSchema.optional()
     })
   }),
-  z19.strictObject({
-    seq: z19.number().int().positive(),
-    step: z19.literal("create-target"),
-    detail: z19.strictObject({
-      kind: z19.literal("content"),
+  z24.strictObject({
+    seq: z24.number().int().positive(),
+    step: z24.literal("create-target"),
+    detail: z24.strictObject({
+      kind: z24.literal("content"),
       directoryName: SkillDirectoryNameSchema,
       /** Codex R10 P1-2：创建后 SKILL.md 的 revision（sha256:…，回滚删除前校验）。 */
       revision: ContentRevisionSchema
     })
   }),
-  z19.strictObject({
-    seq: z19.number().int().positive(),
-    step: z19.literal("resource"),
+  z24.strictObject({
+    seq: z24.number().int().positive(),
+    step: z24.literal("resource"),
     detail: ResourceDetailSchema
   }),
-  z19.strictObject({
-    seq: z19.number().int().positive(),
-    step: z19.literal("commit"),
-    detail: z19.strictObject({
-      kind: z19.literal("commit"),
+  z24.strictObject({
+    seq: z24.number().int().positive(),
+    step: z24.literal("commit"),
+    detail: z24.strictObject({
+      kind: z24.literal("commit"),
       /** 操作 ID（journal 文件名派生）；回放侧按与期望 operationId 全等比对。 */
-      proposalId: z19.string().min(1).max(200),
-      status: z19.literal("applied"),
-      mutationCount: z19.number().int().nonnegative()
+      proposalId: z24.string().min(1).max(200),
+      status: z24.literal("applied"),
+      mutationCount: z24.number().int().nonnegative()
     })
   })
 ]);
 async function readJournal(journalPath) {
-  const parentIdentity = await anchorManagerDirectory(path14.dirname(journalPath));
+  const parentIdentity = await anchorManagerDirectory(path23.dirname(journalPath));
   let raw;
   let leafIdentity;
   try {
-    const handle = await fs13.open(
+    const handle = await fs22.open(
       journalPath,
-      fs13.constants.O_RDONLY | fs13.constants.O_NOFOLLOW
+      fs22.constants.O_RDONLY | fs22.constants.O_NOFOLLOW
     );
     try {
       const stat2 = await handle.stat();
@@ -44166,14 +45835,14 @@ async function readJournal(journalPath) {
       `Journal file unreadable (${code}); recovery required: ${journalPath}`
     );
   }
-  const after = await fs13.lstat(journalPath).catch(() => null);
+  const after = await fs22.lstat(journalPath).catch(() => null);
   if (after === null || !after.isFile() || after.dev !== leafIdentity.dev || after.ino !== leafIdentity.ino) {
     throw new DomainError(
       "UNAVAILABLE",
       `Journal leaf identity drifted after read; recovery required: ${journalPath}`
     );
   }
-  await verifyDirIdentity(path14.dirname(journalPath), parentIdentity);
+  await verifyDirIdentity(path23.dirname(journalPath), parentIdentity);
   const entries = [];
   const lines = raw.split("\n");
   for (let index = 0; index < lines.length; index += 1) {
@@ -44329,29 +45998,29 @@ function assertCommittedJournal(entries, expected) {
 }
 
 // src/daemon/steward/fs-authority.ts
-import { createHash as createHash7, randomBytes as randomBytes8 } from "node:crypto";
-import { promises as fs14 } from "node:fs";
-import path15 from "node:path";
+import { createHash as createHash10, randomBytes as randomBytes8 } from "node:crypto";
+import { promises as fs23 } from "node:fs";
+import path24 from "node:path";
 var assertRealRoot = assertCanonicalDirectory;
-var O_NOFOLLOW = fs14.constants.O_NOFOLLOW ?? 0;
+var O_NOFOLLOW = fs23.constants.O_NOFOLLOW ?? 0;
 function sha256Hex(bytes) {
-  return createHash7("sha256").update(bytes).digest("hex");
+  return createHash10("sha256").update(bytes).digest("hex");
 }
 async function assertNoSymlinkAncestors(to, root) {
-  const realRoot = await fs14.realpath(root);
-  const parent = path15.dirname(to);
-  const realParent = await fs14.realpath(parent);
-  const lexicalParent = path15.join(realRoot, path15.relative(root, parent));
+  const realRoot = await fs23.realpath(root);
+  const parent = path24.dirname(to);
+  const realParent = await fs23.realpath(parent);
+  const lexicalParent = path24.join(realRoot, path24.relative(root, parent));
   if (realParent !== lexicalParent) {
     throw new DomainError(
       "INVALID_OPERATION",
-      `Resource target path contains a symlink ancestor: ${path15.relative(root, to)}`
+      `Resource target path contains a symlink ancestor: ${path24.relative(root, to)}`
     );
   }
 }
 async function syncDir(dir) {
   try {
-    const handle = await fs14.open(dir, fs14.constants.O_RDONLY | fs14.constants.O_DIRECTORY);
+    const handle = await fs23.open(dir, fs23.constants.O_RDONLY | fs23.constants.O_DIRECTORY);
     try {
       await handle.sync();
     } finally {
@@ -44367,7 +46036,7 @@ async function syncDir(dir) {
 async function captureLeafIdentity(leaf, label, expectedByteSize) {
   let stat2;
   try {
-    stat2 = await fs14.lstat(leaf);
+    stat2 = await fs23.lstat(leaf);
   } catch {
     throw new DomainError("NOT_FOUND", `Resource source missing on disk: ${label}`);
   }
@@ -44385,8 +46054,8 @@ async function captureLeafIdentity(leaf, label, expectedByteSize) {
 async function readResourceBytesStrict(from, root, expectedByteSize, label) {
   assertPathInside(root, from);
   const rootIdentity = await assertRealRoot(root);
-  const realRoot = await fs14.realpath(root);
-  const lexicalPosition = path15.join(realRoot, path15.relative(root, from));
+  const realRoot = await fs23.realpath(root);
+  const lexicalPosition = path24.join(realRoot, path24.relative(root, from));
   const realFrom = await realpathOrNotFound(from, label);
   if (realFrom !== lexicalPosition) {
     throw new DomainError(
@@ -44397,7 +46066,7 @@ async function readResourceBytesStrict(from, root, expectedByteSize, label) {
   const identity2 = await captureLeafIdentity(from, label, expectedByteSize);
   let handle;
   try {
-    handle = await fs14.open(from, fs14.constants.O_RDONLY | O_NOFOLLOW);
+    handle = await fs23.open(from, fs23.constants.O_RDONLY | O_NOFOLLOW);
   } catch {
     throw new DomainError("NOT_FOUND", `Resource source missing on disk: ${label}`);
   }
@@ -44435,7 +46104,7 @@ async function readResourceBytesStrict(from, root, expectedByteSize, label) {
 }
 async function realpathOrNotFound(target, label) {
   try {
-    return await fs14.realpath(target);
+    return await fs23.realpath(target);
   } catch {
     throw new DomainError("NOT_FOUND", `Resource source missing on disk: ${label}`);
   }
@@ -44443,13 +46112,13 @@ async function realpathOrNotFound(target, label) {
 async function writeFileExclusiveVerified(to, root, bytes, label) {
   assertPathInside(root, to);
   const rootIdentity = await assertRealRoot(root);
-  const realRoot = await fs14.realpath(root);
-  const lexicalPosition = path15.join(realRoot, path15.relative(root, to));
+  const realRoot = await fs23.realpath(root);
+  const lexicalPosition = path24.join(realRoot, path24.relative(root, to));
   await assertNoSymlinkAncestors(to, root);
-  const parentIdentity = await assertCanonicalDirectory(path15.dirname(to));
+  const parentIdentity = await assertCanonicalDirectory(path24.dirname(to));
   let handle;
   try {
-    handle = await fs14.open(to, "wx");
+    handle = await fs23.open(to, "wx");
   } catch (error) {
     throw new DomainError(
       "INVALID_OPERATION",
@@ -44463,14 +46132,14 @@ async function writeFileExclusiveVerified(to, root, bytes, label) {
       throw new DomainError("INVALID_OPERATION", `Resource target is not a regular file: ${label}`);
     }
     identity2 = { dev: stat2.dev, ino: stat2.ino };
-    const realTo = await fs14.realpath(to);
+    const realTo = await fs23.realpath(to);
     if (realTo !== lexicalPosition) {
       throw new DomainError(
         "UNAVAILABLE",
         `Resource target escaped the root before any bytes were written (path race; at most an empty placeholder remains at ${realTo}); recovery required: ${label}`
       );
     }
-    const atPosition = await fs14.lstat(to);
+    const atPosition = await fs23.lstat(to);
     if (atPosition.dev !== identity2.dev || atPosition.ino !== identity2.ino) {
       throw new DomainError(
         "UNAVAILABLE",
@@ -44478,20 +46147,20 @@ async function writeFileExclusiveVerified(to, root, bytes, label) {
       );
     }
     await verifyDirIdentity(root, rootIdentity);
-    await verifyDirIdentity(path15.dirname(to), parentIdentity);
+    await verifyDirIdentity(path24.dirname(to), parentIdentity);
     await handle.writeFile(bytes);
     await handle.sync();
   } finally {
     await handle.close().catch(() => void 0);
   }
-  const realToAfter = await fs14.realpath(to);
+  const realToAfter = await fs23.realpath(to);
   if (realToAfter !== lexicalPosition) {
     throw new DomainError(
       "UNAVAILABLE",
       `Resource target escaped the provider root after write (path race); external path untouched, recovery required: ${label}`
     );
   }
-  const after = await fs14.lstat(to);
+  const after = await fs23.lstat(to);
   if (after.dev !== identity2.dev || after.ino !== identity2.ino) {
     throw new DomainError(
       "UNAVAILABLE",
@@ -44506,7 +46175,7 @@ async function restoreResourceBytesStrict(to, root, bytes, label) {
   await assertNoSymlinkAncestors(to, root);
   let stat2 = null;
   try {
-    stat2 = await fs14.lstat(to);
+    stat2 = await fs23.lstat(to);
   } catch {
     stat2 = null;
   }
@@ -44514,7 +46183,7 @@ async function restoreResourceBytesStrict(to, root, bytes, label) {
     if (!stat2.isFile()) {
       throw new Error(`move restore target exists but is not a regular file: ${label}`);
     }
-    const handle = await fs14.open(to, fs14.constants.O_RDONLY | O_NOFOLLOW).catch(() => null);
+    const handle = await fs23.open(to, fs23.constants.O_RDONLY | O_NOFOLLOW).catch(() => null);
     if (handle === null) {
       throw new Error(`move restore target cannot be opened without following symlinks: ${label}`);
     }
@@ -44530,7 +46199,7 @@ async function restoreResourceBytesStrict(to, root, bytes, label) {
     } finally {
       await handle.close().catch(() => void 0);
     }
-    const after = await fs14.lstat(to);
+    const after = await fs23.lstat(to);
     if (after.dev !== stat2.dev || after.ino !== stat2.ino) {
       throw new Error(`move restore target identity drifted after read: ${label}`);
     }
@@ -44554,7 +46223,7 @@ async function unlinkFileVerified(leaf, root, label, quarantineJournalPath) {
       `Resource source is hardlinked (nlink=${identity2.nlink}); exclusive-inode policy refuses to move it: ${label}`
     );
   }
-  const handle = await fs14.open(leaf, fs14.constants.O_RDONLY | O_NOFOLLOW).catch(() => null);
+  const handle = await fs23.open(leaf, fs23.constants.O_RDONLY | O_NOFOLLOW).catch(() => null);
   if (handle === null) {
     throw new DomainError("NOT_FOUND", `Resource source missing on disk: ${label}`);
   }
@@ -44568,13 +46237,13 @@ async function unlinkFileVerified(leaf, root, label, quarantineJournalPath) {
     }
     const quarantineRoot = await prepareBackupRoot(quarantineJournalPath);
     const quarantineIdentity = await assertCanonicalDirectory(quarantineRoot);
-    const tombstone = path15.join(
+    const tombstone = path24.join(
       quarantineRoot,
-      `removed-${randomBytes8(8).toString("hex")}-${path15.basename(leaf)}`
+      `removed-${randomBytes8(8).toString("hex")}-${path24.basename(leaf)}`
     );
     try {
       await verifyDirIdentity(root, rootIdentity);
-      await fs14.rename(leaf, tombstone);
+      await fs23.rename(leaf, tombstone);
     } catch (error) {
       if (error.code === "EXDEV") {
         throw new DomainError(
@@ -44584,7 +46253,7 @@ async function unlinkFileVerified(leaf, root, label, quarantineJournalPath) {
       }
       throw error;
     }
-    const stillExists = await fs14.lstat(leaf).then(
+    const stillExists = await fs23.lstat(leaf).then(
       () => true,
       () => false
     );
@@ -44594,7 +46263,7 @@ async function unlinkFileVerified(leaf, root, label, quarantineJournalPath) {
         `Resource source path survived quarantine rename (path race); recovery required: ${label}`
       );
     }
-    const tomb = await fs14.lstat(tombstone).catch(() => null);
+    const tomb = await fs23.lstat(tombstone).catch(() => null);
     if (tomb === null || !tomb.isFile() || tomb.dev !== identity2.dev || tomb.ino !== identity2.ino) {
       throw new DomainError(
         "UNAVAILABLE",
@@ -44617,14 +46286,14 @@ async function unlinkFileVerified(leaf, root, label, quarantineJournalPath) {
 }
 async function prepareBackupRoot(journalPath) {
   const backupDir = `${journalPath}.backups`;
-  await fs14.mkdir(path15.dirname(journalPath), 448).catch(() => void 0);
-  await anchorManagerDirectory(path15.dirname(journalPath)).catch(() => {
+  await fs23.mkdir(path24.dirname(journalPath), 448).catch(() => void 0);
+  await anchorManagerDirectory(path24.dirname(journalPath)).catch(() => {
     throw new DomainError(
       "UNAVAILABLE",
-      `journal directory is not canonical (or was replaced during this daemon lifetime); recovery required: ${path15.dirname(journalPath)}`
+      `journal directory is not canonical (or was replaced during this daemon lifetime); recovery required: ${path24.dirname(journalPath)}`
     );
   });
-  await fs14.mkdir(backupDir, 448).catch(() => void 0);
+  await fs23.mkdir(backupDir, 448).catch(() => void 0);
   await anchorManagerDirectory(backupDir).catch(() => {
     throw new DomainError(
       "UNAVAILABLE",
@@ -44638,24 +46307,24 @@ async function writeBackupWithManifest(options2) {
   const parsedRef = BackupRefSchema.parse(ref);
   const root = await prepareBackupRoot(options2.journalPath);
   const rootIdentity = await assertCanonicalDirectory(root);
-  await writeFileExclusiveVerified(path15.join(root, parsedRef), root, bytes, `backup:${parsedRef}`);
+  await writeFileExclusiveVerified(path24.join(root, parsedRef), root, bytes, `backup:${parsedRef}`);
   await syncDir(root);
   await verifyDirIdentity(root, rootIdentity);
-  const manifestHandle = await fs14.open(
-    path15.join(root, "manifest.jsonl"),
-    fs14.constants.O_WRONLY | fs14.constants.O_APPEND | fs14.constants.O_CREAT | O_NOFOLLOW,
+  const manifestHandle = await fs23.open(
+    path24.join(root, "manifest.jsonl"),
+    fs23.constants.O_WRONLY | fs23.constants.O_APPEND | fs23.constants.O_CREAT | O_NOFOLLOW,
     384
   );
   await verifyDirIdentity(root, rootIdentity);
   const manifestStat = await manifestHandle.stat();
   if (!manifestStat.isFile()) {
     await manifestHandle.close().catch(() => void 0);
-    throw new Error(`backup manifest is not a regular file: ${path15.join(root, "manifest.jsonl")}`);
+    throw new Error(`backup manifest is not a regular file: ${path24.join(root, "manifest.jsonl")}`);
   }
   if (manifestStat.nlink !== 1) {
     await manifestHandle.close().catch(() => void 0);
     throw new Error(
-      `backup manifest is hardlinked (nlink=${manifestStat.nlink}); manager refuses to append: ${path15.join(root, "manifest.jsonl")}`
+      `backup manifest is hardlinked (nlink=${manifestStat.nlink}); manager refuses to append: ${path24.join(root, "manifest.jsonl")}`
     );
   }
   try {
@@ -44671,7 +46340,7 @@ async function writeBackupWithManifest(options2) {
     await manifestHandle.sync();
     if ((await manifestHandle.stat()).nlink !== 1) {
       throw new Error(
-        `backup manifest gained a hardlink during append; recovery required: ${path15.join(root, "manifest.jsonl")}`
+        `backup manifest gained a hardlink during append; recovery required: ${path24.join(root, "manifest.jsonl")}`
       );
     }
   } finally {
@@ -44682,10 +46351,10 @@ async function writeBackupWithManifest(options2) {
 }
 async function readBackupManifest(journalPath) {
   const root = await prepareBackupRoot(journalPath);
-  const manifestPath = path15.join(root, "manifest.jsonl");
+  const manifestPath = path24.join(root, "manifest.jsonl");
   let raw;
   try {
-    const handle = await fs14.open(manifestPath, fs14.constants.O_RDONLY | O_NOFOLLOW);
+    const handle = await fs23.open(manifestPath, fs23.constants.O_RDONLY | O_NOFOLLOW);
     try {
       if (!(await handle.stat()).isFile()) {
         throw new Error(`backup manifest is not a regular file: ${manifestPath}`);
@@ -44776,18 +46445,18 @@ async function applyProposalTransaction(proposal, snapshot, deps) {
   let seq = 0;
   const movedRestore = /* @__PURE__ */ new Map();
   let journalWriter = null;
-  const operationId = path16.basename(deps.journalPath, ".jsonl");
+  const operationId = path25.basename(deps.journalPath, ".jsonl");
   const recordStep = async (step, detail) => {
     if (journalWriter === null) {
-      await fs15.mkdir(path16.dirname(deps.journalPath), { recursive: true });
-      await assertCanonicalDirectory(path16.dirname(deps.journalPath));
-      const journalDirIdentity = await anchorManagerDirectory(path16.dirname(deps.journalPath));
-      journalWriter = await fs15.open(
+      await fs24.mkdir(path25.dirname(deps.journalPath), { recursive: true });
+      await assertCanonicalDirectory(path25.dirname(deps.journalPath));
+      const journalDirIdentity = await anchorManagerDirectory(path25.dirname(deps.journalPath));
+      journalWriter = await fs24.open(
         deps.journalPath,
-        fs15.constants.O_WRONLY | fs15.constants.O_CREAT | fs15.constants.O_EXCL | fs15.constants.O_NOFOLLOW,
+        fs24.constants.O_WRONLY | fs24.constants.O_CREAT | fs24.constants.O_EXCL | fs24.constants.O_NOFOLLOW,
         384
       );
-      await verifyDirIdentity(path16.dirname(deps.journalPath), journalDirIdentity);
+      await verifyDirIdentity(path25.dirname(deps.journalPath), journalDirIdentity);
     }
     seq += 1;
     const entry = { seq, step, detail };
@@ -44797,6 +46466,7 @@ async function applyProposalTransaction(proposal, snapshot, deps) {
     await journalWriter.sync();
   };
   const root = deps.workspaces.resolveWritable(snapshot.target).directory;
+  deps.skills.invalidateDiscovery(snapshot.target);
   const compensate = async (failure) => {
     const targetTrees = buildTargetTrees(journal);
     for (const entry of [...journal].reverse()) {
@@ -44819,6 +46489,7 @@ async function applyProposalTransaction(proposal, snapshot, deps) {
         };
       }
     }
+    deps.skills.invalidateDiscovery(snapshot.target);
     return { status: "compensated", mutations, failure };
   };
   try {
@@ -44940,7 +46611,7 @@ async function applyProposalTransaction(proposal, snapshot, deps) {
         }
         const targets = proposal.patch.kind === "split" ? proposal.patch.targets : [proposal.patch.target];
         for (const target of targets) {
-          const destination = path16.join(root, target.directoryName);
+          const destination = path25.join(root, target.directoryName);
           if (await pathExists(destination)) {
             throw new DomainError(
               "CONFLICT",
@@ -44985,12 +46656,12 @@ async function applyProposalTransaction(proposal, snapshot, deps) {
                 `Resource mapping source missing from snapshot: ${mapping.sourceSkillId}`
               );
             }
-            const from = path16.join(root, mappingSource.directoryName, mapping.sourcePath);
-            const to = path16.join(root, target.directoryName, mapping.targetPath);
+            const from = path25.join(root, mappingSource.directoryName, mapping.sourcePath);
+            const to = path25.join(root, target.directoryName, mapping.targetPath);
             assertPathInside(root, from);
             assertPathInside(root, to);
-            assertPathInside(path16.join(root, target.directoryName), to);
-            if (path16.basename(to).toLowerCase() === "skill.md") {
+            assertPathInside(path25.join(root, target.directoryName), to);
+            if (path25.basename(to).toLowerCase() === "skill.md") {
               throw new DomainError(
                 "INVALID_OPERATION",
                 `Resource targetPath must not target the skill document: ${target.directoryName}/${mapping.targetPath}`
@@ -45055,7 +46726,7 @@ async function applyProposalTransaction(proposal, snapshot, deps) {
               sha256: sha256Hex(writtenBytes),
               ...backupRef === void 0 ? {} : { backupRef, sourceSha256: liveHash }
             });
-            await fs15.mkdir(path16.dirname(to), { recursive: true });
+            await fs24.mkdir(path25.dirname(to), { recursive: true });
             await assertNoSymlinkAncestors(to, root);
             if (mapping.strategy === "reference") {
               await writeFileExclusiveVerified(
@@ -45099,6 +46770,7 @@ async function applyProposalTransaction(proposal, snapshot, deps) {
         break;
       }
     }
+    deps.skills.invalidateDiscovery(snapshot.target);
     await recordStep("commit", {
       kind: "commit",
       proposalId: operationId,
@@ -45137,7 +46809,7 @@ async function toggleWithPostcondition(deps, target, skillId, mode) {
 }
 async function pathExists(target) {
   try {
-    await fs15.stat(target);
+    await fs24.stat(target);
     return true;
   } catch {
     return false;
@@ -45157,7 +46829,7 @@ async function undoJournalSteps(entries, context) {
     checked.push(parsed.data);
   }
   assertCommittedJournal(checked, {
-    proposalId: path16.basename(context.backupJournalPath ?? context.deps.journalPath, ".jsonl"),
+    proposalId: path25.basename(context.backupJournalPath ?? context.deps.journalPath, ".jsonl"),
     proposal: context.proposal,
     snapshot: context.snapshot
   });
@@ -45202,7 +46874,7 @@ async function removeCreatedDirectory(dir, root, directoryName, tree, quarantine
   assertPathInside(root, dir);
   let stat2;
   try {
-    stat2 = await fs15.lstat(dir);
+    stat2 = await fs24.lstat(dir);
   } catch {
     return;
   }
@@ -45213,8 +46885,8 @@ async function removeCreatedDirectory(dir, root, directoryName, tree, quarantine
       `Created target is no longer a directory (external drift): ${directoryName}`
     );
   }
-  const realDir = await fs15.realpath(dir);
-  const lexicalDir = path16.join(await fs15.realpath(root), path16.relative(root, dir));
+  const realDir = await fs24.realpath(dir);
+  const lexicalDir = path25.join(await fs24.realpath(root), path25.relative(root, dir));
   if (realDir !== lexicalDir) {
     throw new DomainError(
       "INVALID_OPERATION",
@@ -45231,7 +46903,7 @@ async function removeCreatedDirectory(dir, root, directoryName, tree, quarantine
       );
     }
     for (const [file, expectedSha] of expected) {
-      const content = await fs15.readFile(path16.join(dir, file));
+      const content = await fs24.readFile(path25.join(dir, file));
       const actualSha = sha256Hex(content);
       const wanted = expectedSha.startsWith("sha256:") ? expectedSha.slice("sha256:".length) : expectedSha;
       if (actualSha !== wanted) {
@@ -45244,13 +46916,13 @@ async function removeCreatedDirectory(dir, root, directoryName, tree, quarantine
   const identity2 = { dev: stat2.dev, ino: stat2.ino };
   const quarantineRoot = await prepareBackupRoot(quarantineJournalPath);
   const quarantineIdentity = await assertCanonicalDirectory(quarantineRoot);
-  const tombstone = path16.join(
+  const tombstone = path25.join(
     quarantineRoot,
-    `removed-dir-${randomBytes9(8).toString("hex")}-${path16.basename(dir)}`
+    `removed-dir-${randomBytes9(8).toString("hex")}-${path25.basename(dir)}`
   );
   try {
     await verifyDirIdentity(root, rootIdentity);
-    await fs15.rename(dir, tombstone);
+    await fs24.rename(dir, tombstone);
   } catch (error) {
     if (error.code === "EXDEV") {
       throw new DomainError(
@@ -45260,7 +46932,7 @@ async function removeCreatedDirectory(dir, root, directoryName, tree, quarantine
     }
     throw error;
   }
-  const stillExists = await fs15.lstat(dir).then(
+  const stillExists = await fs24.lstat(dir).then(
     () => true,
     () => false
   );
@@ -45270,7 +46942,7 @@ async function removeCreatedDirectory(dir, root, directoryName, tree, quarantine
       `Created target survived quarantine rename (path race); recovery required: ${directoryName}`
     );
   }
-  const tomb = await fs15.lstat(tombstone).catch(() => null);
+  const tomb = await fs24.lstat(tombstone).catch(() => null);
   if (tomb === null || !tomb.isDirectory() || tomb.dev !== identity2.dev || tomb.ino !== identity2.ino) {
     throw new DomainError(
       "UNAVAILABLE",
@@ -45283,11 +46955,11 @@ async function removeCreatedDirectory(dir, root, directoryName, tree, quarantine
 }
 async function walkFiles(dir, prefix) {
   const files = /* @__PURE__ */ new Map();
-  const entries = await fs15.readdir(dir, { withFileTypes: true });
+  const entries = await fs24.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const rel = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      for (const [f] of await walkFiles(path16.join(dir, entry.name), rel)) files.set(f, "");
+      for (const [f] of await walkFiles(path25.join(dir, entry.name), rel)) files.set(f, "");
     } else if (entry.isFile()) {
       files.set(rel, "");
     } else {
@@ -45373,7 +47045,7 @@ async function undoStep(entry, context) {
         );
       }
       await removeCreatedDirectory(
-        path16.join(root, directoryName),
+        path25.join(root, directoryName),
         root,
         directoryName,
         context.targetTrees.get(directoryName),
@@ -45384,11 +47056,11 @@ async function undoStep(entry, context) {
     case "resource": {
       const { from: fromRel, to, strategy } = entry.detail;
       if (strategy === "move") {
-        const from = path16.join(root, fromRel);
+        const from = path25.join(root, fromRel);
         assertPathInside(root, from);
         const moved = context.movedRestore?.get(entry.seq);
         if (moved) {
-          await fs15.mkdir(path16.dirname(moved.from), { recursive: true });
+          await fs24.mkdir(path25.dirname(moved.from), { recursive: true });
           await restoreResourceBytesStrict(moved.from, root, moved.bytes, fromRel);
         } else {
           const { backupRef, sourceSha256 } = entry.detail;
@@ -45407,7 +47079,7 @@ async function undoStep(entry, context) {
             sha256: sourceSha256
           });
           const backupRoot = await prepareBackupRoot(backupJournalPath);
-          const backupPath = path16.join(backupRoot, backupRef);
+          const backupPath = path25.join(backupRoot, backupRef);
           let backup;
           try {
             backup = await readResourceBytesStrict(
@@ -45426,7 +47098,7 @@ async function undoStep(entry, context) {
               `move rollback backup hash mismatch for step ${entry.seq}: ${backupRef}`
             );
           }
-          await fs15.mkdir(path16.dirname(from), { recursive: true });
+          await fs24.mkdir(path25.dirname(from), { recursive: true });
           await restoreResourceBytesStrict(from, root, backup, fromRel);
         }
       }
@@ -45438,7 +47110,7 @@ async function undoStep(entry, context) {
         );
       }
       await removeCreatedDirectory(
-        path16.join(root, directoryName),
+        path25.join(root, directoryName),
         root,
         directoryName,
         context.targetTrees.get(directoryName),
@@ -45469,17 +47141,17 @@ function coerceYamlScalar(raw) {
   return raw;
 }
 async function scanUnfinishedJournals(storeDir) {
-  const journalDir = path16.join(storeDir, "journal");
+  const journalDir = path25.join(storeDir, "journal");
   let files;
   try {
-    files = await fs15.readdir(journalDir);
+    files = await fs24.readdir(journalDir);
   } catch {
     return [];
   }
   const unfinished = [];
   for (const file of files) {
     if (!file.endsWith(".jsonl") || file.endsWith("-rollback.jsonl")) continue;
-    const journalPath = path16.join(journalDir, file);
+    const journalPath = path25.join(journalDir, file);
     const proposalId = file.replace(/\.jsonl$/, "");
     let entries;
     try {
@@ -45504,7 +47176,7 @@ async function scanUnfinishedJournals(storeDir) {
 // src/daemon/steward/approval-service.ts
 function fingerprintOf(proposal) {
   const canonical = JSON.stringify(proposal.patch, Object.keys(proposal.patch).sort());
-  return `sha256:${createHash8("sha256").update(canonical).digest("hex")}`;
+  return `sha256:${createHash11("sha256").update(canonical).digest("hex")}`;
 }
 function createStewardApprovalService(deps) {
   const proposals = /* @__PURE__ */ new Map();
@@ -45574,7 +47246,7 @@ function createStewardApprovalService(deps) {
       const targets = entry.proposal.patch.kind === "split" ? entry.proposal.patch.targets.map((target) => target.directoryName) : [entry.proposal.patch.target.directoryName];
       let conflict = false;
       for (const name of targets) {
-        const exists = await (await import("node:fs/promises")).stat(path17.join(root, name)).then(() => true).catch(() => false);
+        const exists = await (await import("node:fs/promises")).stat(path26.join(root, name)).then(() => true).catch(() => false);
         if (exists) {
           conflict = true;
           checks.push({
@@ -45659,7 +47331,7 @@ function createStewardApprovalService(deps) {
         skills: deps.skills,
         creator: deps.creator,
         store: deps.store,
-        journalPath: path17.join(stewardStoreDir(), "journal", `${proposalId}.jsonl`)
+        journalPath: path26.join(stewardStoreDir(), "journal", `${proposalId}.jsonl`)
       });
       const audit = {
         id: StewardAuditIdSchema.parse(`aud_${randomBytes10(8).toString("hex")}`),
@@ -45691,7 +47363,7 @@ function createStewardApprovalService(deps) {
     const entry = requireProposal(audit.proposalId);
     const patch = entry.proposal.patch;
     if (patch.kind === "disable") {
-      const journalPathForProbe = path17.join(
+      const journalPathForProbe = path26.join(
         stewardStoreDir(),
         "journal",
         `${audit.proposalId}.jsonl`
@@ -45871,7 +47543,7 @@ function createStewardApprovalService(deps) {
     if (fingerprintOf(entry.proposal) !== grant.fingerprint) {
       throw new DomainError("CONFLICT", "Patch fingerprint drifted since the rollback grant.");
     }
-    const journalPath = path17.join(stewardStoreDir(), "journal", `${audit.proposalId}.jsonl`);
+    const journalPath = path26.join(stewardStoreDir(), "journal", `${audit.proposalId}.jsonl`);
     const root = deps.workspaces.resolveWritable(entry.snapshot.target).directory;
     const mutations = [];
     try {
@@ -45889,7 +47561,7 @@ function createStewardApprovalService(deps) {
           skills: deps.skills,
           creator: deps.creator,
           store: deps.store,
-          journalPath: path17.join(stewardStoreDir(), "journal", `${auditId}-rollback.jsonl`)
+          journalPath: path26.join(stewardStoreDir(), "journal", `${auditId}-rollback.jsonl`)
         },
         root,
         mutations,
@@ -46005,7 +47677,7 @@ function createCapabilityRegistry(definitions) {
 }
 
 // src/daemon/steward/capabilities.ts
-import { z as z20 } from "zod";
+import { z as z25 } from "zod";
 function ok(value) {
   return { kind: "ok", value };
 }
@@ -46029,11 +47701,11 @@ function parseAuditIdInput(input) {
   const value = input.auditId;
   return typeof value === "string" && value.length > 0 ? value : null;
 }
-var listInputSchema = z20.unknown();
-var skillIdInputSchema = z20.object({ skillId: SkillIdSchema });
-var proposeInputSchema = z20.object({ proposal: SkillProposalSchema });
-var proposalIdInputSchema = z20.object({ proposalId: StewardProposalIdSchema });
-var auditIdInputSchema = z20.object({ auditId: z20.string().min(1) });
+var listInputSchema = z25.unknown();
+var skillIdInputSchema = z25.object({ skillId: SkillIdSchema });
+var proposeInputSchema = z25.object({ proposal: SkillProposalSchema });
+var proposalIdInputSchema = z25.object({ proposalId: StewardProposalIdSchema });
+var auditIdInputSchema = z25.object({ auditId: z25.string().min(1) });
 function createStewardCapabilities(deps) {
   const { snapshot, proposals, validate: validate3, apply, rollback } = deps;
   return [
@@ -46711,7 +48383,7 @@ function createSkillStewardPipelineService(deps) {
 
 // src/daemon/steward/dsh-settings.ts
 import { promises as fsp } from "node:fs";
-import path20 from "node:path";
+import path29 from "node:path";
 import { normalizeApiKey } from "@deepseek-ai/dsh-llm";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
@@ -46950,7 +48622,7 @@ function dshBridgeModelEntry(model) {
 }
 async function syncDshModelRoutes(routes) {
   const dshHome = resolveDefaultDshHome();
-  const file = path20.join(dshHome, "settings.yaml");
+  const file = path29.join(dshHome, "settings.yaml");
   let doc = {};
   try {
     const raw = await fsp.readFile(file, "utf8");
@@ -46983,7 +48655,7 @@ async function syncDshModelRoutes(routes) {
 async function syncDshRouteCredential(provider, apiKey) {
   const ref = dshRouteApiKeyEnv(provider);
   const dshHome = resolveDefaultDshHome();
-  const file = path20.join(dshHome, ".credentials.yaml");
+  const file = path29.join(dshHome, ".credentials.yaml");
   let doc = {};
   try {
     const parsed = parseYaml(await fsp.readFile(file, "utf8"));
@@ -47015,10 +48687,10 @@ async function syncDshRouteCredential(provider, apiKey) {
   }
 }
 function settingsFile() {
-  return path20.join(homeDir(), "steward-store", "dsh-settings.json");
+  return path29.join(homeDir(), "steward-store", "dsh-settings.json");
 }
 function credentialsFile() {
-  return path20.join(homeDir(), "steward-store", "dsh-credentials.json");
+  return path29.join(homeDir(), "steward-store", "dsh-credentials.json");
 }
 async function readPrivateJson(file) {
   let raw;
@@ -47290,7 +48962,7 @@ function createDshSettingsService(options2 = {}) {
 // src/daemon/kernel/agent-sessions.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createUserMessage as createUserMessage2 } from "@deepseek-ai/dsh-llm";
-import { z as z22 } from "zod";
+import { z as z27 } from "zod";
 init_agent_roles();
 init_dsh_kernel();
 
@@ -47384,6 +49056,8 @@ var AGENT_MODES = {
     tools: [
       "workspace_list",
       "skills_list",
+      "skills_search",
+      "skills_duplicates",
       "skills_info",
       "skills_validate",
       "creator_load",
@@ -47397,6 +49071,8 @@ var AGENT_MODES = {
     tools: [
       "workspace_list",
       "skills_list",
+      "skills_search",
+      "skills_duplicates",
       "skills_info",
       "skills_validate",
       "skills_toggle",
@@ -47412,6 +49088,8 @@ var AGENT_MODES = {
     tools: [
       "workspace_list",
       "skills_list",
+      "skills_search",
+      "skills_duplicates",
       "skills_info",
       "skills_validate",
       "repository_scan",
@@ -47587,11 +49265,11 @@ async function runBootSessionCleanup(deps) {
 
 // src/daemon/kernel/agent-queue.ts
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { z as z21 } from "zod";
-var InboxMessageSchema = z21.object({
-  id: z21.string().min(1),
-  source: z21.unknown().optional(),
-  content: z21.array(z21.object({ type: z21.string().min(1), text: z21.string().optional() }).passthrough()).min(1)
+import { z as z26 } from "zod";
+var InboxMessageSchema = z26.object({
+  id: z26.string().min(1),
+  source: z26.unknown().optional(),
+  content: z26.array(z26.object({ type: z26.string().min(1), text: z26.string().optional() }).passthrough()).min(1)
 }).passthrough();
 function parseInboxMessage(raw) {
   const checked = InboxMessageSchema.safeParse(raw);
@@ -47633,8 +49311,8 @@ function rebuildEditedMessage(original, text) {
 }
 
 // src/daemon/kernel/session-transcripts.ts
-import fs18 from "node:fs";
-import path21 from "node:path";
+import fs27 from "node:fs";
+import path30 from "node:path";
 function parseMeta(raw) {
   if (typeof raw !== "object" || raw === null) return null;
   const meta = raw;
@@ -47661,22 +49339,22 @@ function createSessionTranscripts(rootDir) {
   let hydrated = false;
   function sessionDir(meta) {
     const [y, m, d] = dateSegments(meta.createdAt);
-    return path21.join(rootDir, y, m, d, meta.sessionId);
+    return path30.join(rootDir, y, m, d, meta.sessionId);
   }
   function hydrate() {
     if (hydrated) return;
     hydrated = true;
     let years = [];
     try {
-      years = fs18.readdirSync(rootDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d{4}$/.test(entry.name)).map((entry) => entry.name);
+      years = fs27.readdirSync(rootDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d{4}$/.test(entry.name)).map((entry) => entry.name);
     } catch {
       return;
     }
     for (const year of years) {
-      for (const month of safeDirs(path21.join(rootDir, year))) {
-        for (const day of safeDirs(path21.join(rootDir, year, month))) {
-          for (const sid of safeDirs(path21.join(rootDir, year, month, day))) {
-            if (!dirs.has(sid)) dirs.set(sid, path21.join(rootDir, year, month, day, sid));
+      for (const month of safeDirs(path30.join(rootDir, year))) {
+        for (const day of safeDirs(path30.join(rootDir, year, month))) {
+          for (const sid of safeDirs(path30.join(rootDir, year, month, day))) {
+            if (!dirs.has(sid)) dirs.set(sid, path30.join(rootDir, year, month, day, sid));
           }
         }
       }
@@ -47684,35 +49362,35 @@ function createSessionTranscripts(rootDir) {
   }
   function safeDirs(dir) {
     try {
-      return fs18.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      return fs27.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     } catch {
       return [];
     }
   }
   function pruneEmptyDateDirs() {
     for (const year of safeDirs(rootDir)) {
-      const yearDir = path21.join(rootDir, year);
+      const yearDir = path30.join(rootDir, year);
       for (const month of safeDirs(yearDir)) {
-        const monthDir = path21.join(yearDir, month);
+        const monthDir = path30.join(yearDir, month);
         for (const day of safeDirs(monthDir)) {
-          const dayDir = path21.join(monthDir, day);
+          const dayDir = path30.join(monthDir, day);
           if (safeDirs(dayDir).length === 0) {
             try {
-              fs18.rmdirSync(dayDir);
+              fs27.rmdirSync(dayDir);
             } catch {
             }
           }
         }
         if (safeDirs(monthDir).length === 0) {
           try {
-            fs18.rmdirSync(monthDir);
+            fs27.rmdirSync(monthDir);
           } catch {
           }
         }
       }
       if (safeDirs(yearDir).length === 0) {
         try {
-          fs18.rmdirSync(yearDir);
+          fs27.rmdirSync(yearDir);
         } catch {
         }
       }
@@ -47722,12 +49400,12 @@ function createSessionTranscripts(rootDir) {
     recordStart(meta) {
       try {
         const dir = sessionDir(meta);
-        fs18.mkdirSync(dir, { recursive: true, mode: 448 });
-        const target = path21.join(dir, "meta.json");
+        fs27.mkdirSync(dir, { recursive: true, mode: 448 });
+        const target = path30.join(dir, "meta.json");
         const tmp = `${target}.tmp`;
-        fs18.writeFileSync(tmp, `${JSON.stringify(meta)}
+        fs27.writeFileSync(tmp, `${JSON.stringify(meta)}
 `, { mode: 384 });
-        fs18.renameSync(tmp, target);
+        fs27.renameSync(tmp, target);
         dirs.set(meta.sessionId, dir);
       } catch (error) {
         console.error(`[session-transcripts] recordStart failed for ${meta.sessionId}:`, error);
@@ -47737,7 +49415,7 @@ function createSessionTranscripts(rootDir) {
       try {
         const dir = dirs.get(sessionId);
         if (dir === void 0) return;
-        fs18.appendFileSync(path21.join(dir, "frames.jsonl"), `${JSON.stringify(frame)}
+        fs27.appendFileSync(path30.join(dir, "frames.jsonl"), `${JSON.stringify(frame)}
 `, {
           mode: 384
         });
@@ -47749,14 +49427,14 @@ function createSessionTranscripts(rootDir) {
       const dir = dirs.get(sessionId);
       if (dir === void 0) return false;
       try {
-        const meta = parseMeta(JSON.parse(fs18.readFileSync(path21.join(dir, "meta.json"), "utf8")));
+        const meta = parseMeta(JSON.parse(fs27.readFileSync(path30.join(dir, "meta.json"), "utf8")));
         if (meta === null || meta.mode === mode) return meta !== null;
         const next = { ...meta, mode };
-        const target = path21.join(dir, "meta.json");
+        const target = path30.join(dir, "meta.json");
         const tmp = `${target}.tmp`;
-        fs18.writeFileSync(tmp, `${JSON.stringify(next)}
+        fs27.writeFileSync(tmp, `${JSON.stringify(next)}
 `, { mode: 384 });
-        fs18.renameSync(tmp, target);
+        fs27.renameSync(tmp, target);
         return true;
       } catch (error) {
         console.error(`[session-transcripts] updateMode failed for ${sessionId}:`, error);
@@ -47769,14 +49447,14 @@ function createSessionTranscripts(rootDir) {
       const dir = dirs.get(sessionId);
       if (dir === void 0) return false;
       try {
-        const meta = parseMeta(JSON.parse(fs18.readFileSync(path21.join(dir, "meta.json"), "utf8")));
+        const meta = parseMeta(JSON.parse(fs27.readFileSync(path30.join(dir, "meta.json"), "utf8")));
         if (meta === null || meta.title === trimmed) return meta !== null;
         const next = { ...meta, title: trimmed };
-        const target = path21.join(dir, "meta.json");
+        const target = path30.join(dir, "meta.json");
         const tmp = `${target}.tmp`;
-        fs18.writeFileSync(tmp, `${JSON.stringify(next)}
+        fs27.writeFileSync(tmp, `${JSON.stringify(next)}
 `, { mode: 384 });
-        fs18.renameSync(tmp, target);
+        fs27.renameSync(tmp, target);
         return true;
       } catch (error) {
         console.error(`[session-transcripts] updateTitle failed for ${sessionId}:`, error);
@@ -47788,7 +49466,7 @@ function createSessionTranscripts(rootDir) {
       const metas = [];
       for (const dir of dirs.values()) {
         try {
-          const meta = parseMeta(JSON.parse(fs18.readFileSync(path21.join(dir, "meta.json"), "utf8")));
+          const meta = parseMeta(JSON.parse(fs27.readFileSync(path30.join(dir, "meta.json"), "utf8")));
           if (meta !== null) metas.push(meta);
         } catch {
         }
@@ -47802,7 +49480,7 @@ function createSessionTranscripts(rootDir) {
       if (dir === void 0) return [];
       let lines = [];
       try {
-        lines = fs18.readFileSync(path21.join(dir, "frames.jsonl"), "utf8").split("\n");
+        lines = fs27.readFileSync(path30.join(dir, "frames.jsonl"), "utf8").split("\n");
       } catch {
         return [];
       }
@@ -47822,7 +49500,7 @@ function createSessionTranscripts(rootDir) {
       hydrate();
       const buckets = /* @__PURE__ */ new Map();
       for (const [sessionId, dir] of dirs) {
-        const segments = path21.relative(rootDir, dir).split(path21.sep);
+        const segments = path30.relative(rootDir, dir).split(path30.sep);
         if (segments.length !== 4) continue;
         const [year, month, day] = segments;
         if (!/^\d{4}$/.test(year) || !/^\d{2}$/.test(month) || !/^\d{2}$/.test(day)) continue;
@@ -47840,7 +49518,7 @@ function createSessionTranscripts(rootDir) {
       const dir = dirs.get(sessionId);
       if (dir === void 0) return false;
       try {
-        fs18.rmSync(dir, { recursive: true, force: true });
+        fs27.rmSync(dir, { recursive: true, force: true });
       } catch (error) {
         console.error(`[session-transcripts] remove failed for ${sessionId}:`, error);
         return false;
@@ -47863,35 +49541,35 @@ function summaryOfMeta(meta) {
 }
 
 // src/daemon/kernel/agent-sessions.ts
-var AgentChunkEventSchema = z22.object({
-  chunk: z22.object({
-    type: z22.string().min(1),
-    text: z22.string().optional(),
-    id: z22.string().optional(),
-    name: z22.string().optional(),
-    argumentsDelta: z22.string().optional()
+var AgentChunkEventSchema = z27.object({
+  chunk: z27.object({
+    type: z27.string().min(1),
+    text: z27.string().optional(),
+    id: z27.string().optional(),
+    name: z27.string().optional(),
+    argumentsDelta: z27.string().optional()
   })
 });
-var TodoWriteEventSchema = z22.object({
-  todos: z22.array(
-    z22.object({
-      content: z22.string(),
-      status: z22.string().min(1)
+var TodoWriteEventSchema = z27.object({
+  todos: z27.array(
+    z27.object({
+      content: z27.string(),
+      status: z27.string().min(1)
     })
   )
 });
-var MessageSourceSchema = z22.object({
-  kind: z22.string().optional(),
-  callId: z22.string().optional()
+var MessageSourceSchema = z27.object({
+  kind: z27.string().optional(),
+  callId: z27.string().optional()
 }).passthrough();
-var MessageBlockSchema = z22.object({
-  type: z22.string().min(1),
-  text: z22.string().optional(),
-  name: z22.string().optional()
+var MessageBlockSchema = z27.object({
+  type: z27.string().min(1),
+  text: z27.string().optional(),
+  name: z27.string().optional()
 }).passthrough();
-var MessageShapeSchema = z22.object({
+var MessageShapeSchema = z27.object({
   source: MessageSourceSchema.optional(),
-  content: z22.array(MessageBlockSchema).min(1)
+  content: z27.array(MessageBlockSchema).min(1)
 }).passthrough();
 function messageEnvelopeOf(raw) {
   if (typeof raw === "object" && raw !== null && "message" in raw) {
@@ -47900,29 +49578,29 @@ function messageEnvelopeOf(raw) {
   }
   return raw;
 }
-var MessageEventSchema = z22.preprocess(messageEnvelopeOf, MessageShapeSchema);
-var TurnEndEventSchema = z22.object({
-  reason: z22.object({ kind: z22.string().optional() }).passthrough().optional()
+var MessageEventSchema = z27.preprocess(messageEnvelopeOf, MessageShapeSchema);
+var TurnEndEventSchema = z27.object({
+  reason: z27.object({ kind: z27.string().optional() }).passthrough().optional()
 }).passthrough();
-var SessionTitleEventSchema = z22.object({
-  title: z22.string().optional()
+var SessionTitleEventSchema = z27.object({
+  title: z27.string().optional()
 }).passthrough();
-var ToolCallEventSchema = z22.object({
-  callId: z22.string().min(1),
-  name: z22.string().min(1),
-  arguments: z22.string()
+var ToolCallEventSchema = z27.object({
+  callId: z27.string().min(1),
+  name: z27.string().min(1),
+  arguments: z27.string()
 }).passthrough();
-var ToolResultEventSchema = z22.object({
-  message: z22.object({
-    source: z22.object({ kind: z22.literal("tool"), callId: z22.string().min(1) }).passthrough(),
-    content: z22.tuple([
-      z22.object({
-        type: z22.literal("tool-result"),
-        toolCallId: z22.string().min(1),
-        content: z22.array(
-          z22.object({
-            type: z22.string().min(1),
-            text: z22.string().optional()
+var ToolResultEventSchema = z27.object({
+  message: z27.object({
+    source: z27.object({ kind: z27.literal("tool"), callId: z27.string().min(1) }).passthrough(),
+    content: z27.tuple([
+      z27.object({
+        type: z27.literal("tool-result"),
+        toolCallId: z27.string().min(1),
+        content: z27.array(
+          z27.object({
+            type: z27.string().min(1),
+            text: z27.string().optional()
           }).passthrough()
         ).min(1).refine(
           (parts) => parts.some(
@@ -47934,15 +49612,15 @@ var ToolResultEventSchema = z22.object({
     ])
   }).passthrough()
 });
-var TurnStartEventSchema = z22.record(z22.string(), z22.unknown());
-var AgentStatusEventSchema = z22.record(z22.string(), z22.unknown());
-var SubagentCatalogEventSchema = z22.object({
-  childId: z22.string().min(1),
-  childCreatedAt: z22.number().optional(),
-  mode: z22.enum(["one-shot", "continuable"]),
-  label: z22.string().optional()
+var TurnStartEventSchema = z27.record(z27.string(), z27.unknown());
+var AgentStatusEventSchema = z27.record(z27.string(), z27.unknown());
+var SubagentCatalogEventSchema = z27.object({
+  childId: z27.string().min(1),
+  childCreatedAt: z27.number().optional(),
+  mode: z27.enum(["one-shot", "continuable"]),
+  label: z27.string().optional()
 });
-var UsageEnvelopeSchema = z22.object({ usage: z22.record(z22.string(), z22.unknown()).optional() }).passthrough();
+var UsageEnvelopeSchema = z27.object({ usage: z27.record(z27.string(), z27.unknown()).optional() }).passthrough();
 var DROPPED_EVENT_LOG_MAX = 200;
 function logDroppedEvent(sessionId, type, data) {
   let detail;
@@ -48996,9 +50674,9 @@ function productToolDenyList(globalNames, mode) {
 }
 
 // src/daemon/model-catalog.ts
-import fs19 from "node:fs";
-import path22 from "node:path";
-import { createRequire as createRequire5 } from "node:module";
+import fs28 from "node:fs";
+import path31 from "node:path";
+import { createRequire as createRequire6 } from "node:module";
 
 // src/shared/provider-icons.generated.ts
 var PROVIDER_ICONS = {
@@ -49065,13 +50743,13 @@ function labelOf(provider) {
   return cn ? `${pretty} \xB7 CN` : pretty;
 }
 function resolveCatalogDataDir() {
-  const require2 = createRequire5(import.meta.url);
+  const require2 = createRequire6(import.meta.url);
   const basePkg = require2.resolve("@deepseek-ai/dsh-base/package.json");
-  const baseNm = path22.dirname(path22.dirname(path22.dirname(basePkg)));
-  const hostReal = fs19.realpathSync(path22.join(baseNm, "@deepseek-ai/dsh-llm-pi-ai"));
-  const piAi = path22.join(path22.dirname(hostReal), "../@earendil-works/pi-ai");
-  const dataDir = path22.join(piAi, "dist", "providers", "data");
-  if (!fs19.existsSync(dataDir)) {
+  const baseNm = path31.dirname(path31.dirname(path31.dirname(basePkg)));
+  const hostReal = fs28.realpathSync(path31.join(baseNm, "@deepseek-ai/dsh-llm-pi-ai"));
+  const piAi = path31.join(path31.dirname(hostReal), "../@earendil-works/pi-ai");
+  const dataDir = path31.join(piAi, "dist", "providers", "data");
+  if (!fs28.existsSync(dataDir)) {
     throw new DomainError("UNAVAILABLE", `pi-ai catalog data not found at ${dataDir}`);
   }
   return dataDir;
@@ -49112,13 +50790,13 @@ function listModelProviders() {
   if (cached !== null) return cached;
   const dataDir = resolveCatalogDataDir();
   const entries = [];
-  for (const file of fs19.readdirSync(dataDir)) {
+  for (const file of fs28.readdirSync(dataDir)) {
     if (!file.endsWith(".json")) continue;
     const provider = file.slice(0, -".json".length);
     if (EXCLUDED_PROVIDERS.has(provider)) continue;
     let parsed;
     try {
-      parsed = JSON.parse(fs19.readFileSync(path22.join(dataDir, file), "utf8"));
+      parsed = JSON.parse(fs28.readFileSync(path31.join(dataDir, file), "utf8"));
     } catch {
       continue;
     }
@@ -49173,7 +50851,7 @@ function createModelCatalogService() {
 }
 
 // src/daemon/capability/domain-capabilities.ts
-import { z as z23 } from "zod";
+import { z as z28 } from "zod";
 function toResult(error) {
   if (error instanceof DomainError) {
     return { kind: "failed", code: error.code, message: error.message };
@@ -49194,7 +50872,7 @@ async function invoke(action) {
     return toResult(error);
   }
 }
-var none = z23.object({});
+var none = z28.object({});
 function createDomainCapabilities(domain) {
   return [
     {
@@ -49272,6 +50950,41 @@ function createDomainCapabilities(domain) {
         return domain.skills.validate(parsed, parsed.skillId);
       })
     },
+    {
+      name: "skills.search",
+      description: "Search installed local skills across all workspaces; returns stable skill ids with workspace/provider scope.",
+      authority: "readonly",
+      input: SkillsSearchInputSchema,
+      handler: (input) => invoke(async () => {
+        const parsed = SkillsSearchInputSchema.parse(input);
+        return {
+          results: await domain.skillSearch.search(parsed.query, {
+            limit: parsed.limit ?? 10
+          })
+        };
+      })
+    },
+    {
+      name: "skills.duplicates",
+      description: "List content-duplicate skill groups from the search index (contentHash groups with more than one canonical entry).",
+      authority: "readonly",
+      input: z28.object({}).strict(),
+      handler: (input) => invoke(async () => {
+        z28.object({}).strict().parse(input);
+        return { groups: await domain.skillSearch.duplicates() };
+      })
+    },
+    {
+      name: "skills.search_config.open",
+      description: "Open the server-owned skill search config file (search-config.toml) with the system default editor.",
+      authority: "readonly",
+      input: z28.object({}).strict(),
+      handler: (input) => invoke(async () => {
+        z28.object({}).strict().parse(input);
+        await domain.searchConfigOpener(searchConfigPath());
+        return { opened: true };
+      })
+    },
     {
       name: "skills.update.check",
       description: "Compare skills-CLI lock hashes against upstream (read-only).",
@@ -49598,7 +51311,7 @@ function createMcpProposalStore(registry) {
 }
 
 // src/daemon/steward/jsonrpc-stdio.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 function parseFrame2(raw) {
   let value;
   try {
@@ -49797,7 +51510,7 @@ var StdioJsonRpcClient = class {
   }
 };
 function defaultStdioSpawn(command, args, options2) {
-  return spawn5(command, args, { cwd: options2.cwd, stdio: ["pipe", "pipe", "pipe"] });
+  return spawn6(command, args, { cwd: options2.cwd, stdio: ["pipe", "pipe", "pipe"] });
 }
 function parseCommandSpec(spec) {
   const trimmed = spec.trim();
@@ -50146,182 +51859,19 @@ function createFixtureHarnessAdapter(options2 = {}) {
 }
 
 // src/daemon/workspace-registry/index.ts
-import fs22 from "node:fs";
-import path27 from "node:path";
-
-// src/daemon/provider-roots.ts
-import fs20 from "node:fs";
-import os5 from "node:os";
-import path23 from "node:path";
-function requireProvider(providerId) {
-  const provider = providerCatalogEntry(providerId);
-  if (!provider) throw new DomainError("NOT_FOUND", `Provider not found: ${providerId}`);
-  return provider;
-}
-function globalProviderRoot(provider) {
-  if (provider.globalPath === null) return null;
-  const home = os5.homedir();
-  const override = globalHomeOverride(provider.id);
-  if (override) return path23.join(override, "skills");
-  if (provider.id === "openclaw") return openClawRoot(home);
-  if (provider.globalPath.startsWith(".config/")) {
-    const configHome = process.env.XDG_CONFIG_HOME?.trim() || path23.join(home, ".config");
-    return path23.join(configHome, provider.globalPath.slice(".config/".length));
-  }
-  return path23.join(home, provider.globalPath);
-}
-function importedProviderRoot(workspaceRoot, provider) {
-  const root = path23.resolve(workspaceRoot, provider.workspacePath);
-  const relative2 = path23.relative(workspaceRoot, root);
-  if (relative2.startsWith("..") || path23.isAbsolute(relative2)) {
-    throw new Error(`Provider root escaped Workspace: ${provider.id}`);
-  }
-  return root;
-}
-function providerRootAvailable(root) {
-  if (!root) return false;
-  try {
-    return fs20.statSync(root).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function globalHomeOverride(providerId) {
-  const variable = providerId === "codex" ? "CODEX_HOME" : providerId === "claude-code" ? "CLAUDE_CONFIG_DIR" : providerId === "mistral-vibe" ? "VIBE_HOME" : providerId === "hermes-agent" ? "HERMES_HOME" : providerId === "autohand-code" ? "AUTOHAND_HOME" : providerId === "grok" ? "GROK_HOME" : null;
-  const value = variable ? process.env[variable]?.trim() : void 0;
-  return value || null;
-}
-function openClawRoot(home) {
-  for (const directory of [".openclaw", ".clawdbot", ".moltbot"]) {
-    if (providerRootAvailable(path23.join(home, directory)))
-      return path23.join(home, directory, "skills");
-  }
-  return path23.join(home, ".openclaw", "skills");
-}
-
-// src/daemon/workspace-registry/persistence.ts
-import fs21 from "node:fs";
-import path25 from "node:path";
-
-// src/daemon/workspace-registry/state.ts
-import path24 from "node:path";
-import { z as z24 } from "zod";
-var StoredWorkspaceSchema = z24.object({
-  id: ImportedWorkspaceIdSchema,
-  label: z24.string().trim().min(1),
-  path: z24.string().min(1).refine(path24.isAbsolute, "Workspace path must be absolute.").refine((value) => path24.normalize(value) === value, "Workspace path must be normalized.")
-}).strict();
-var WorkspaceRegistryStateSchema = z24.object({
-  schemaVersion: z24.literal(2),
-  activeId: WorkspaceIdSchema,
-  workspaces: z24.array(StoredWorkspaceSchema)
-}).strict().superRefine((state, context) => {
-  const ids = /* @__PURE__ */ new Set();
-  const paths = /* @__PURE__ */ new Set();
-  for (const [index, workspace] of state.workspaces.entries()) {
-    if (workspace.id !== opaquePathId("ws", workspace.path)) {
-      context.addIssue({
-        code: "custom",
-        message: "Workspace ID does not match its path.",
-        path: ["workspaces", index, "id"]
-      });
-    }
-    if (ids.has(workspace.id)) {
-      context.addIssue({
-        code: "custom",
-        message: `Duplicate Workspace ID: ${workspace.id}`,
-        path: ["workspaces", index, "id"]
-      });
-    }
-    if (paths.has(workspace.path)) {
-      context.addIssue({
-        code: "custom",
-        message: `Duplicate Workspace path: ${workspace.path}`,
-        path: ["workspaces", index, "path"]
-      });
-    }
-    ids.add(workspace.id);
-    paths.add(workspace.path);
-  }
-  if (state.activeId !== GLOBAL_WORKSPACE_ID && !ids.has(state.activeId)) {
-    context.addIssue({
-      code: "custom",
-      message: `Active Workspace is not registered: ${state.activeId}`,
-      path: ["activeId"]
-    });
-  }
-});
-function emptyRegistryState() {
-  return { schemaVersion: 2, activeId: GLOBAL_WORKSPACE_ID, workspaces: [] };
-}
-function importWorkspace(state, entry) {
-  const existing = state.workspaces.find((workspace) => workspace.path === entry.path);
-  if (existing) return { state, entry: existing, changed: false };
-  const collision = state.workspaces.find((workspace) => workspace.id === entry.id);
-  if (collision) {
-    throw new Error(`Workspace ID collision between ${collision.path} and ${entry.path}`);
-  }
-  return {
-    state: {
-      ...state,
-      activeId: entry.id,
-      workspaces: [...state.workspaces, entry]
-    },
-    entry,
-    changed: true
-  };
-}
-function forgetWorkspace(state, id) {
-  if (!state.workspaces.some((workspace) => workspace.id === id)) return null;
-  return {
-    ...state,
-    activeId: state.activeId === id ? GLOBAL_WORKSPACE_ID : state.activeId,
-    workspaces: state.workspaces.filter((workspace) => workspace.id !== id)
-  };
-}
-function activateWorkspace(state, id) {
-  if (id !== GLOBAL_WORKSPACE_ID && !state.workspaces.some((workspace) => workspace.id === id)) {
-    return null;
-  }
-  if (state.activeId === id) return state;
-  return { ...state, activeId: id };
-}
-
-// src/daemon/workspace-registry/persistence.ts
-var WORKSPACES_FILE = "workspaces.json";
-function createWorkspaceRegistryPersistence() {
-  const file = path25.join(appDir(), WORKSPACES_FILE);
-  return {
-    load: () => loadState2(file),
-    commit: (state) => commitState2(file, state)
-  };
-}
-function loadState2(file) {
-  if (!fs21.existsSync(file)) return emptyRegistryState();
-  let source;
-  try {
-    source = fs21.readFileSync(file, "utf8");
-  } catch (error) {
-    throw new Error(
-      `Cannot read workspace registry ${file}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  return safeParseJson(source, WorkspaceRegistryStateSchema) ?? emptyRegistryState();
-}
-function commitState2(file, state) {
-  const validated = WorkspaceRegistryStateSchema.parse(state);
-  fs21.mkdirSync(path25.dirname(file), { recursive: true, mode: 448 });
-  atomicWriteUtf8(file, `${JSON.stringify(validated, null, 2)}
-`);
-}
+import fs29 from "node:fs";
+import path33 from "node:path";
 
 // src/daemon/workspace-registry/projection.ts
-import path26 from "node:path";
+import os6 from "node:os";
+import path32 from "node:path";
 function providerCountKey(workspaceId, providerId) {
   return `${workspaceId}:${providerId}`;
 }
-async function countWorkspaceSnapshot(state, countSkills) {
-  const tasks = [];
+var SKIP_PLUGINS_PATH = path32.join(os6.tmpdir(), `.skill-creator-skip-plugins-${process.pid}`);
+async function scanWorkspaceSnapshot(state, listSkills2) {
+  const counts = /* @__PURE__ */ new Map();
+  const skillKeys = /* @__PURE__ */ new Map();
   const workspaces = [
     { id: GLOBAL_WORKSPACE_ID, directory: null, global: true },
     ...state.workspaces.map((workspace) => ({
@@ -50330,56 +51880,33 @@ async function countWorkspaceSnapshot(state, countSkills) {
       global: false
     }))
   ];
+  const tasks = [];
   for (const workspace of workspaces) {
+    const keySet = /* @__PURE__ */ new Set();
+    skillKeys.set(workspace.id, keySet);
     for (const provider of PROVIDER_CATALOG) {
       const root = workspace.global ? globalProviderRoot(provider) : workspace.directory ? importedProviderRoot(workspace.directory, provider) : null;
       const providerId = provider.id;
-      const count = root && providerRootAvailable(root) ? countSkills({
+      const scan2 = root && providerRootAvailable(root) ? listSkills2({
         customDirs: [root],
         customProvider: providerId,
         scanDefaultDirs: false,
-        all: true
-      }) : Promise.resolve(0);
+        all: true,
+        ...provider.id === "claude-code" ? {} : { claudePluginsFile: SKIP_PLUGINS_PATH, claudePluginsRoot: SKIP_PLUGINS_PATH }
+      }) : Promise.resolve([]);
       tasks.push(
-        count.then((value) => [providerCountKey(workspace.id, providerId), value])
+        scan2.then((entries) => {
+          counts.set(providerCountKey(workspace.id, providerId), entries.length);
+          const canonicalRoot = root === null ? "" : safeCanonical(root) ?? root;
+          for (const entry of entries) {
+            keySet.add(`${canonicalRoot}${path32.sep}${entry.directoryName}`);
+          }
+        })
       );
     }
   }
-  return new Map(await Promise.all(tasks));
-}
-async function collectWorkspaceSkillKeys(state, listSkills2) {
-  const tasks = [];
-  const workspaces = [
-    { id: GLOBAL_WORKSPACE_ID, directory: null, global: true },
-    ...state.workspaces.map((workspace) => ({
-      id: workspace.id,
-      directory: availableDirectory(workspace.path),
-      global: false
-    }))
-  ];
-  for (const workspace of workspaces) {
-    const keySet = /* @__PURE__ */ new Set();
-    tasks.push(listWorkspaceKeys(workspace, listSkills2, keySet));
-  }
-  return new Map(await Promise.all(tasks));
-}
-async function listWorkspaceKeys(workspace, listSkills2, keySet) {
-  for (const provider of PROVIDER_CATALOG) {
-    const root = workspace.global ? globalProviderRoot(provider) : workspace.directory ? importedProviderRoot(workspace.directory, provider) : null;
-    if (!root || !providerRootAvailable(root)) continue;
-    const providerId = provider.id;
-    const entries = await listSkills2({
-      customDirs: [root],
-      customProvider: providerId,
-      scanDefaultDirs: false,
-      all: true
-    });
-    const canonicalRoot = safeCanonical(root) ?? root;
-    for (const entry of entries) {
-      keySet.add(`${canonicalRoot}${path26.sep}${entry.directoryName}`);
-    }
-  }
-  return [workspace.id, keySet];
+  await Promise.all(tasks);
+  return { counts, skillKeys };
 }
 function projectWorkspaceSnapshot(state, counts, skillKeys) {
   const global3 = projectGlobalWorkspace(state.activeId, counts, skillKeys);
@@ -50461,9 +51988,7 @@ function createWorkspaceRegistry(options2 = {}) {
   const persistence = createWorkspaceRegistryPersistence();
   let state = persistence.load();
   let revision = 0;
-  const usingDefaultCounter = options2.countSkills === void 0;
-  const countSkills = options2.countSkills ?? countCcskiSkills;
-  const listSkills2 = options2.listSkills ?? (usingDefaultCounter ? listCcskiSkills : void 0);
+  const listSkills2 = options2.listSkills ?? listCcskiSkills;
   const commit = (next) => {
     if (next === state) return;
     persistence.commit(next);
@@ -50476,9 +52001,7 @@ function createWorkspaceRegistry(options2 = {}) {
         const observedRevision = revision;
         const snapshot = state;
         try {
-          const counts = await countWorkspaceSnapshot(snapshot, countSkills);
-          if (revision !== observedRevision) continue;
-          const skillKeys = listSkills2 ? await collectWorkspaceSkillKeys(snapshot, listSkills2) : void 0;
+          const { counts, skillKeys } = await scanWorkspaceSnapshot(snapshot, listSkills2);
           if (revision !== observedRevision) continue;
           return projectWorkspaceSnapshot(snapshot, counts, skillKeys);
         } catch (error) {
@@ -50487,17 +52010,17 @@ function createWorkspaceRegistry(options2 = {}) {
       }
     },
     import(directory, label) {
-      const resolvedPath = path27.resolve(directory);
-      if (!fs22.existsSync(resolvedPath)) {
+      const resolvedPath = path33.resolve(directory);
+      if (!fs29.existsSync(resolvedPath)) {
         throw new DomainError("NOT_FOUND", "Workspace directory was not found.");
       }
-      if (!fs22.statSync(resolvedPath).isDirectory()) {
+      if (!fs29.statSync(resolvedPath).isDirectory()) {
         throw new DomainError("INVALID_OPERATION", "Workspace path must be a directory.");
       }
       const canonicalPath = canonicalDirectory(resolvedPath);
       const entry = {
         id: ImportedWorkspaceIdSchema.parse(opaquePathId("ws", canonicalPath)),
-        label: label?.trim() || path27.basename(canonicalPath) || canonicalPath,
+        label: label?.trim() || path33.basename(canonicalPath) || canonicalPath,
         path: canonicalPath
       };
       const result = importWorkspace(state, entry);
@@ -50555,12 +52078,9 @@ function createWorkspaceRegistry(options2 = {}) {
     }
   };
 }
-async function countCcskiSkills(options2) {
-  return (await listSkills(options2)).length;
-}
 async function listCcskiSkills(options2) {
   const skills = await listSkills(options2);
-  return skills.map((skill) => ({ directoryName: path27.basename(skill.path) }));
+  return skills.map((skill) => ({ directoryName: path33.basename(skill.path) }));
 }
 function providerScope(target, workspaceKind, workspaceLabel, directory, includeDisabled) {
   return {
@@ -50592,6 +52112,7 @@ function createDaemonDomain(workspaces = createWorkspaceRegistry(), options2 = {
   const modelCatalog = createModelCatalogService();
   const agentFiles = createAgentFilesService();
   const skillsCliProbe = options2.skillsCliProbe ?? createSkillsCliProbe();
+  void skillsCliProbe.probe().catch(() => void 0);
   const skills = createSkillService(workspaces, { skillsCliProbe });
   const agentSessions = createAgentSessionsService({
     kernel: () => kernelHostRef.handle,
@@ -50627,6 +52148,8 @@ ${info3.content.slice(0, 2e5)}`
   const repository = createRepositoryService(workspaces, skills);
   const creator = createCreatorService(workspaces, skills);
   const skillIntelligence = createSkillIntelligenceService(skills, creator);
+  const searchConfigOpener = options2.searchConfigOpener ?? platformOpenFile;
+  const dialog = options2.dialog ?? createDialogService();
   const domain = {
     workspaces,
     skills,
@@ -50635,6 +52158,9 @@ ${info3.content.slice(0, 2e5)}`
     sourceRegistry: createSourceRegistry(),
     skillsCliProbe,
     skillsUpdate: createSkillsUpdateService(workspaces, skills, skillsCliProbe, repository),
+    skillSearch: createSkillSearchService(),
+    searchConfigOpener,
+    dialog,
     acpBridge: createAcpBridgeService(workspaces),
     skillIntelligence,
     steward: createStewardService(workspaces, skills, skillIntelligence, {
@@ -50666,7 +52192,7 @@ ${info3.content.slice(0, 2e5)}`
 }
 
 // src/daemon/ipc-server.ts
-import fs24 from "node:fs";
+import fs31 from "node:fs";
 import net2 from "node:net";
 
 // src/shared/socket-liveness.ts
@@ -50693,10 +52219,10 @@ function socketAcceptsConnections(socketPathname, timeoutMs = DEFAULT_SOCKET_PRO
 }
 
 // src/daemon/log.ts
-import fs23 from "node:fs";
+import fs30 from "node:fs";
 function log(message) {
   try {
-    fs23.appendFileSync(daemonLogPath(), `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+    fs30.appendFileSync(daemonLogPath(), `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
 `);
   } catch {
   }
@@ -50723,8 +52249,8 @@ var IpcServer = class {
   /** 获取单实例 socket，仅清理已确认失活的 Unix 路径。 */
   async start() {
     const directory = runDir();
-    fs24.mkdirSync(directory, { recursive: true, mode: 448 });
-    if (process.platform !== "win32") fs24.chmodSync(directory, 448);
+    fs31.mkdirSync(directory, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") fs31.chmodSync(directory, 448);
     const server = await this.bindSocket(true);
     if (!server) return false;
     this.server = server;
@@ -50775,7 +52301,7 @@ var IpcServer = class {
       }
     );
     if (result.server) {
-      if (process.platform !== "win32") fs24.chmodSync(socket, 384);
+      if (process.platform !== "win32") fs31.chmodSync(socket, 384);
       log(`ipc listening on ${socket}`);
       return result.server;
     }
@@ -50785,7 +52311,7 @@ var IpcServer = class {
     }
     if (!allowStaleCleanup || await socketAcceptsConnections(socket)) return null;
     try {
-      fs24.unlinkSync(socket);
+      fs31.unlinkSync(socket);
     } catch (error) {
       const code = error instanceof Error && "code" in error ? error.code : void 0;
       if (code !== "ENOENT") return null;
@@ -50866,9 +52392,9 @@ var IpcServer = class {
 };
 
 // src/daemon/web-server.ts
-import { existsSync as existsSync2, promises as fs25 } from "node:fs";
+import { existsSync as existsSync2, promises as fs32 } from "node:fs";
 import http from "node:http";
-import path28 from "node:path";
+import path34 from "node:path";
 import { RPCHandler } from "@orpc/server/ws";
 import { WebSocketServer } from "ws";
 
@@ -50903,6 +52429,21 @@ function createRpcRouter(deps) {
       validate: rpc.skills.validate.handler(
         async ({ input }) => domain.skills.validate(input, input.skillId)
       ),
+      // skill-search-integration C1：daemon 长驻检索单例（索引 IO 故障经错误边界透传）。
+      search: rpc.skills.search.handler(async ({ input }) => ({
+        results: await domain.skillSearch.search(input.query, { limit: input.limit ?? 10 })
+      })),
+      // search-robustness R3：在系统默认编辑器打开 server-owned search-config.toml。
+      searchConfig: {
+        open: rpc.skills.searchConfig.open.handler(async () => {
+          await domain.searchConfigOpener(searchConfigPath());
+          return { opened: true };
+        })
+      },
+      // search-duplicates P1：内容重复组投影（索引事实，排序冻结）。
+      duplicates: rpc.skills.duplicates.handler(async () => ({
+        groups: await domain.skillSearch.duplicates()
+      })),
       update: {
         check: rpc.skills.update.check.handler(async ({ input }) => {
           const discovered = await domain.skills.list(input, true);
@@ -50925,7 +52466,8 @@ function createRpcRouter(deps) {
       })),
       setActive: rpc.workspace.setActive.handler(({ input }) => ({
         activeId: domain.workspaces.activate(input.id)
-      }))
+      })),
+      pickDirectory: rpc.workspace.pickDirectory.handler(async () => domain.dialog.pickDirectory())
     },
     creator: {
       save: rpc.creator.save.handler(({ input }) => domain.creator.save(input)),
@@ -51439,19 +52981,19 @@ var WebServer = class {
   async serveStatic(response, pathname) {
     let relativePath = decodeURIComponent(pathname.slice(1));
     if (!relativePath || relativePath.endsWith("/")) relativePath += "index.html";
-    const root = path28.resolve(this.options.webuiDir);
-    let file = path28.resolve(root, relativePath);
-    if (path28.relative(root, file).startsWith("..")) {
+    const root = path34.resolve(this.options.webuiDir);
+    let file = path34.resolve(root, relativePath);
+    if (path34.relative(root, file).startsWith("..")) {
       response.writeHead(403).end();
       return;
     }
-    if (!existsSync2(file)) file = path28.join(root, "index.html");
+    if (!existsSync2(file)) file = path34.join(root, "index.html");
     if (!existsSync2(file)) {
       response.writeHead(404).end("not found");
       return;
     }
-    const extension = path28.extname(file);
-    const data = await fs25.readFile(file);
+    const extension = path34.extname(file);
+    const data = await fs32.readFile(file);
     response.writeHead(200, {
       "content-type": MIME[extension] ?? "application/octet-stream",
       "cache-control": extension === ".html" ? "no-cache" : "public, max-age=3600"
@@ -51461,7 +53003,7 @@ var WebServer = class {
 };
 
 // src/daemon/steward/dsh-session-binder.ts
-import fs26 from "node:fs/promises";
+import fs33 from "node:fs/promises";
 import {
   createAssistantMessage,
   createToolResultMessage,
@@ -51501,7 +53043,7 @@ function createDshSessionBinder(options2) {
     if (!host) return { ok: false, failure: { kind: "HOST_UNAVAILABLE" } };
     const surface = narrowHostSurface(host.ctx);
     if ("kind" in surface) return { ok: false, failure: surface };
-    const canonical = await fs26.realpath(input.workspaceDir);
+    const canonical = await fs33.realpath(input.workspaceDir);
     const workspace = await surface.workspaceRegistry.resolveByPath(canonical) ?? await surface.workspaceRegistry.create(
       canonical,
       input.workspaceTitle ?? canonical.split("/").pop() ?? canonical
@@ -51643,7 +53185,7 @@ function summarizeToolResult(call) {
 
 // src/daemon/mcp/skill-creator-mcp.ts
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
-import { z as z25 } from "zod";
+import { z as z29 } from "zod";
 function mcpToolName(capabilityName) {
   return capabilityName.replace(/\./g, "_");
 }
@@ -51708,7 +53250,7 @@ function createSkillCreatorMcpServer(deps) {
           proposeName,
           {
             description: `Propose: ${descriptor.description} A human approves it in the Skill Creator UI before execution.`,
-            inputSchema: z25.object(shape2)
+            inputSchema: z29.object(shape2)
           },
           async (args) => proposeResult(deps.proposals.create(descriptor.name, args))
         );
@@ -51730,7 +53272,7 @@ function createSkillCreatorMcpServer(deps) {
     if (shape) {
       server.registerTool(
         toolName,
-        { description: descriptor.description, inputSchema: z25.object(shape) },
+        { description: descriptor.description, inputSchema: z29.object(shape) },
         async (args) => withCard(
           descriptor.name,
           await deps.capabilities.call(descriptor.name, args, MCP_PRINCIPAL),
@@ -51785,13 +53327,13 @@ function createSkillCreatorMcpServer(deps) {
 }
 
 // src/daemon/tray-host.ts
-import fs28 from "node:fs";
-import path30 from "node:path";
+import fs35 from "node:fs";
+import path36 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/daemon/app-icon.ts
-import fs27 from "node:fs";
-import path29 from "node:path";
+import fs34 from "node:fs";
+import path35 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var LINUX_ICON_SIZES = [16, 32, 48, 64, 128, 256, 512];
 function resolveAppIcon(webuiDir, platform2 = process.platform) {
@@ -51840,7 +53382,7 @@ function resolveAppIcon(webuiDir, platform2 = process.platform) {
   if (platform2 === "linux") {
     const assets = LINUX_ICON_SIZES.flatMap((size) => {
       const iconPath = resolvePackagedIconPath(
-        path29.join("linux", `${size}x${size}`, "app-icon.png"),
+        path35.join("linux", `${size}x${size}`, "app-icon.png"),
         webuiDir
       );
       return iconPath === null ? [] : [
@@ -51867,31 +53409,31 @@ function resolveNativeVariantPair(lightFileName, darkFileName, webuiDir) {
   return [lightPath, darkPath];
 }
 function resolveNativeAppIconPath(fileName, webuiDir) {
-  const here = path29.dirname(fileURLToPath3(import.meta.url));
+  const here = path35.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
-    webuiDir ? path29.join(webuiDir, "icons", "app-icon", fileName) : null,
-    path29.join(here, "webui", "icons", "app-icon", fileName),
-    path29.join(here, "..", "resources", "app-icon", fileName),
-    path29.join(here, "..", "..", "resources", "app-icon", fileName),
-    path29.join(process.cwd(), "resources", "app-icon", fileName)
+    webuiDir ? path35.join(webuiDir, "icons", "app-icon", fileName) : null,
+    path35.join(here, "webui", "icons", "app-icon", fileName),
+    path35.join(here, "..", "resources", "app-icon", fileName),
+    path35.join(here, "..", "..", "resources", "app-icon", fileName),
+    path35.join(process.cwd(), "resources", "app-icon", fileName)
   ];
   return firstExistingFile(candidates);
 }
 function resolvePackagedIconPath(fileName, webuiDir) {
-  const here = path29.dirname(fileURLToPath3(import.meta.url));
+  const here = path35.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
-    webuiDir ? path29.join(webuiDir, "icons", fileName) : null,
-    path29.join(here, "webui", "icons", fileName),
-    path29.join(here, "..", "..", "webui", "build", "icons", fileName),
-    path29.join(here, "..", "..", "webui", "static", "icons", fileName),
-    path29.join(process.cwd(), "webui", "build", "icons", fileName),
-    path29.join(process.cwd(), "webui", "static", "icons", fileName)
+    webuiDir ? path35.join(webuiDir, "icons", fileName) : null,
+    path35.join(here, "webui", "icons", fileName),
+    path35.join(here, "..", "..", "webui", "build", "icons", fileName),
+    path35.join(here, "..", "..", "webui", "static", "icons", fileName),
+    path35.join(process.cwd(), "webui", "build", "icons", fileName),
+    path35.join(process.cwd(), "webui", "static", "icons", fileName)
   ];
   return firstExistingFile(candidates);
 }
 function firstExistingFile(candidates) {
   for (const candidate of candidates) {
-    if (candidate && fs27.existsSync(candidate)) return candidate;
+    if (candidate && fs34.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -52264,17 +53806,17 @@ function resolveTrayIconPath(webuiDir) {
   return resolvePackagedIconPath2("monochrome-mini.png", webuiDir);
 }
 function resolvePackagedIconPath2(fileName, webuiDir) {
-  const here = path30.dirname(fileURLToPath4(import.meta.url));
+  const here = path36.dirname(fileURLToPath4(import.meta.url));
   const candidates = [
-    webuiDir ? path30.join(webuiDir, "icons", fileName) : null,
-    path30.join(here, "webui", "icons", fileName),
-    path30.join(here, "..", "..", "webui", "build", "icons", fileName),
-    path30.join(here, "..", "..", "webui", "static", "icons", fileName),
-    path30.join(process.cwd(), "webui", "build", "icons", fileName),
-    path30.join(process.cwd(), "webui", "static", "icons", fileName)
+    webuiDir ? path36.join(webuiDir, "icons", fileName) : null,
+    path36.join(here, "webui", "icons", fileName),
+    path36.join(here, "..", "..", "webui", "build", "icons", fileName),
+    path36.join(here, "..", "..", "webui", "static", "icons", fileName),
+    path36.join(process.cwd(), "webui", "build", "icons", fileName),
+    path36.join(process.cwd(), "webui", "static", "icons", fileName)
   ];
   for (const candidate of candidates) {
-    if (candidate && fs28.existsSync(candidate)) return candidate;
+    if (candidate && fs35.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -52362,7 +53904,7 @@ async function safeCall(label, operation) {
 }
 
 // src/daemon/index.ts
-var __dirname = path31.dirname(fileURLToPath5(import.meta.url));
+var __dirname = path37.dirname(fileURLToPath5(import.meta.url));
 var SHUTDOWN_GRACE_MS = 1e3;
 var SHUTDOWN_TASK_TIMEOUT_MS = 2e3;
 async function settleTeardown(label, action) {
@@ -52391,20 +53933,20 @@ async function settleTeardown(label, action) {
   }
 }
 function resolveWebuiDir(override) {
-  if (override) return path31.resolve(override);
+  if (override) return path37.resolve(override);
   const candidates = [
-    path31.join(__dirname, "webui"),
+    path37.join(__dirname, "webui"),
     // dist/webui (bundled)
-    path31.join(__dirname, "..", "..", "webui", "static"),
+    path37.join(__dirname, "..", "..", "webui", "static"),
     // source dev: Vite static assets
-    path31.join(__dirname, "..", "..", "webui", "build"),
+    path37.join(__dirname, "..", "..", "webui", "build"),
     // source production build
-    path31.join(process.cwd(), "dist", "webui"),
-    path31.join(process.cwd(), "webui", "static"),
-    path31.join(process.cwd(), "webui", "build")
+    path37.join(process.cwd(), "dist", "webui"),
+    path37.join(process.cwd(), "webui", "static"),
+    path37.join(process.cwd(), "webui", "build")
   ];
   for (const c of candidates) {
-    if (fs29.existsSync(c)) return c;
+    if (fs36.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -52529,7 +54071,9 @@ async function bootDaemon(opts) {
         // ACP 子进程池：有界杀光所有 agent 子进程，避免孤儿进程泄漏。
         settleTeardown("acp bridge", () => domain.acpBridge.dispose()),
         // steward：取消活动 run、回收隔离 execution root、dispose backend adapter。
-        settleTeardown("steward service", () => domain.steward.dispose())
+        settleTeardown("steward service", () => domain.steward.dispose()),
+        // skill search：关闭 provider root watchers（persistent:false 之外的显式回收）。
+        settleTeardown("skill search", () => domain.skillSearch.dispose())
       ];
       await Promise.allSettled(tasks);
     } finally {
@@ -52589,6 +54133,7 @@ async function bootDaemon(opts) {
       await Promise.allSettled([settleTeardown("late tray host", async () => host?.destroy())]);
     } else {
       handlesRef.trayHost = host;
+      if (result.tray) domain.dialog.attach(result.tray);
       status.tray = result.window ? "mounted" : webMode && result.tray ? "web" : "headless";
       if (result.failure) {
         status.trayError = `[${result.failure.kind}@${result.failure.stage}] ${result.failure.cause instanceof Error ? result.failure.cause.message : String(result.failure.cause)}`;
@@ -52611,21 +54156,21 @@ async function bootDaemon(opts) {
 }
 
 // src/shared/package-version.ts
-import fs30 from "node:fs";
-import path32 from "node:path";
+import fs37 from "node:fs";
+import path38 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { z as z26 } from "zod";
-var PackageVersionSchema = z26.object({ version: z26.string().min(1) });
+import { z as z30 } from "zod";
+var PackageVersionSchema = z30.object({ version: z30.string().min(1) });
 function readNearestPackageVersion(moduleUrl) {
-  const here = path32.dirname(fileURLToPath6(moduleUrl));
+  const here = path38.dirname(fileURLToPath6(moduleUrl));
   const candidates = [
-    path32.join(here, "package.json"),
-    path32.join(here, "..", "package.json"),
-    path32.join(here, "..", "..", "package.json")
+    path38.join(here, "package.json"),
+    path38.join(here, "..", "package.json"),
+    path38.join(here, "..", "..", "package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const pkg = safeParseJson(fs30.readFileSync(candidate, "utf8"), PackageVersionSchema);
+      const pkg = safeParseJson(fs37.readFileSync(candidate, "utf8"), PackageVersionSchema);
       if (pkg) return pkg.version;
     } catch {
     }