nextclaw 0.10.0 → 0.12.0

package/dist/cli/index.js

@@ -6,12 +6,12 @@ import { APP_NAME as APP_NAME5, APP_TAGLINE } from "@nextclaw/core";
 
 // src/cli/runtime.ts
 import {
-  loadConfig as loadConfig7,
+  loadConfig as loadConfig8,
   saveConfig as saveConfig6,
   getConfigPath as getConfigPath4,
   getDataDir as getDataDir8,
   ConfigSchema as ConfigSchema2,
-  getWorkspacePath as getWorkspacePath6,
+  getWorkspacePath as getWorkspacePath9,
   expandHome as expandHome2,
   MessageBus as MessageBus2,
   AgentLoop,
@@ -22,12 +22,12 @@ import {
   DEFAULT_WORKSPACE_PATH
 } from "@nextclaw/core";
 import {
-  getPluginChannelBindings as getPluginChannelBindings3,
+  getPluginChannelBindings as getPluginChannelBindings4,
   resolvePluginChannelMessageToolHints as resolvePluginChannelMessageToolHints2,
   setPluginRuntimeBridge as setPluginRuntimeBridge2
 } from "@nextclaw/openclaw-compat";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join7, resolve as resolve9 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { join as join7, resolve as resolve12 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { spawn as spawn3 } from "child_process";
@@ -115,32 +115,32 @@ function resolveRestartSentinelPath() {
   return resolve(getDataDir(), "run", RESTART_SENTINEL_FILENAME);
 }
 async function writeRestartSentinel(payload) {
-  const path = resolveRestartSentinelPath();
-  mkdirSync(resolve(path, ".."), { recursive: true });
+  const path2 = resolveRestartSentinelPath();
+  mkdirSync(resolve(path2, ".."), { recursive: true });
   const file = {
     version: 1,
     payload
   };
-  writeFileSync(path, `${JSON.stringify(file, null, 2)}
+  writeFileSync(path2, `${JSON.stringify(file, null, 2)}
 `, "utf-8");
-  return path;
+  return path2;
 }
 async function consumeRestartSentinel() {
-  const path = resolveRestartSentinelPath();
-  if (!existsSync(path)) {
+  const path2 = resolveRestartSentinelPath();
+  if (!existsSync(path2)) {
     return null;
   }
   try {
-    const raw = readFileSync(path, "utf-8");
+    const raw = readFileSync(path2, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.version !== 1 || !parsed.payload) {
-      rmSync(path, { force: true });
+      rmSync(path2, { force: true });
       return null;
     }
-    rmSync(path, { force: true });
+    rmSync(path2, { force: true });
     return parsed;
   } catch {
-    rmSync(path, { force: true });
+    rmSync(path2, { force: true });
     return null;
   }
 }
@@ -186,24 +186,236 @@ function parseSessionKey(sessionKey) {
 }
 
 // src/cli/skills/marketplace.ts
-import { cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname, isAbsolute, join, relative, resolve as resolve2 } from "path";
+import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve as resolve3 } from "path";
 import { SkillsLoader } from "@nextclaw/core";
+
+// src/cli/skills/marketplace.metadata.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { parse as parseYaml } from "yaml";
+var DEFAULT_MARKETPLACE_META_FILENAME = "marketplace.json";
+function parseSkillFrontmatter(raw) {
+  const normalized = raw.replace(/\r\n/g, "\n");
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!match || !match[1]) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(match[1]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid SKILL.md frontmatter: ${message}`);
+  }
+  if (!isRecord(parsed)) {
+    return {};
+  }
+  const summaryI18n = readLocalizedTextMapField(parsed, [["summaryi18n"], ["summary_i18n"]]);
+  const descriptionI18n = readLocalizedTextMapField(parsed, [["descriptioni18n"], ["description_i18n"]]);
+  const summaryZh = readFrontmatterStringField(parsed, [["summaryzh"], ["summary_zh"]]);
+  const descriptionZh = readFrontmatterStringField(parsed, [["descriptionzh"], ["description_zh"]]);
+  return {
+    name: readFrontmatterStringField(parsed, [["name"]]),
+    summary: readFrontmatterStringField(parsed, [["summary"]]),
+    summaryI18n: mergeLocalizedTextMap(summaryI18n, { zh: summaryZh }),
+    description: readFrontmatterStringField(parsed, [["description"]]),
+    descriptionI18n: mergeLocalizedTextMap(descriptionI18n, { zh: descriptionZh }),
+    author: readFrontmatterStringField(parsed, [["author"]]),
+    tags: readFrontmatterTags(parsed)
+  };
+}
+function buildLocalizedTextMap(englishText, ...maps) {
+  const normalized = mergeLocalizedTextMap(...maps);
+  return {
+    ...normalized ?? {},
+    en: englishText
+  };
+}
+function readMarketplaceMetadataFile(skillDir, explicitMetaFile) {
+  const metadataPath = resolveMarketplaceMetadataPath(skillDir, explicitMetaFile);
+  if (!metadataPath) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(metadataPath, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid marketplace metadata file: ${metadataPath} (${message})`);
+  }
+  if (!isRecord(parsed)) {
+    throw new Error(`Invalid marketplace metadata file: ${metadataPath} (root must be an object)`);
+  }
+  return {
+    slug: readMetadataString(parsed, "slug"),
+    name: readMetadataString(parsed, "name"),
+    summary: readMetadataString(parsed, "summary"),
+    summaryI18n: readMetadataLocalizedTextMap(parsed, "summaryI18n"),
+    description: readMetadataString(parsed, "description"),
+    descriptionI18n: readMetadataLocalizedTextMap(parsed, "descriptionI18n"),
+    author: readMetadataString(parsed, "author"),
+    tags: readMetadataStringArray(parsed, "tags"),
+    sourceRepo: readMetadataString(parsed, "sourceRepo"),
+    homepage: readMetadataString(parsed, "homepage"),
+    publishedAt: readMetadataString(parsed, "publishedAt"),
+    updatedAt: readMetadataString(parsed, "updatedAt")
+  };
+}
+function resolveMarketplaceMetadataPath(skillDir, explicitMetaFile) {
+  const resolved = explicitMetaFile?.trim() ? resolve2(explicitMetaFile) : resolve2(skillDir, DEFAULT_MARKETPLACE_META_FILENAME);
+  return existsSync2(resolved) ? resolved : void 0;
+}
+function mergeLocalizedTextMap(...maps) {
+  const localized = {};
+  for (const map of maps) {
+    for (const [locale, text] of Object.entries(map ?? {})) {
+      const normalizedText = typeof text === "string" ? text.trim() : "";
+      if (!normalizedText) {
+        continue;
+      }
+      localized[normalizeLocaleTag(locale)] = normalizedText;
+    }
+  }
+  return Object.keys(localized).length > 0 ? localized : void 0;
+}
+function readMetadataString(record, fieldName) {
+  const value = record[fieldName];
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Invalid marketplace metadata field: ${fieldName} must be a string`);
+  }
+  const normalized = value.trim();
+  return normalized || void 0;
+}
+function readMetadataStringArray(record, fieldName) {
+  const value = record[fieldName];
+  if (value == null) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid marketplace metadata field: ${fieldName} must be an array`);
+  }
+  const tags = value.map((entry, index) => {
+    if (typeof entry !== "string") {
+      throw new Error(`Invalid marketplace metadata field: ${fieldName}[${index}] must be a string`);
+    }
+    return entry.trim();
+  }).filter(Boolean);
+  return tags.length > 0 ? tags : void 0;
+}
+function readMetadataLocalizedTextMap(record, fieldName) {
+  const value = record[fieldName];
+  if (value == null) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    throw new Error(`Invalid marketplace metadata field: ${fieldName} must be an object`);
+  }
+  const localized = {};
+  for (const [locale, text] of Object.entries(value)) {
+    if (typeof text !== "string") {
+      throw new Error(`Invalid marketplace metadata field: ${fieldName}.${locale} must be a string`);
+    }
+    const normalized = text.trim();
+    if (!normalized) {
+      continue;
+    }
+    localized[normalizeLocaleTag(locale)] = normalized;
+  }
+  return Object.keys(localized).length > 0 ? localized : void 0;
+}
+function readFrontmatterStringField(record, keyPaths) {
+  for (const keyPath of keyPaths) {
+    const value = readNestedFrontmatterValue(record, keyPath);
+    if (typeof value !== "string") {
+      continue;
+    }
+    const normalized = value.trim();
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+function readLocalizedTextMapField(record, keyPaths) {
+  for (const keyPath of keyPaths) {
+    const value = readNestedFrontmatterValue(record, keyPath);
+    if (!isRecord(value)) {
+      continue;
+    }
+    const normalized = {};
+    for (const [locale, text] of Object.entries(value)) {
+      if (typeof text !== "string") {
+        continue;
+      }
+      const trimmed = text.trim();
+      if (!trimmed) {
+        continue;
+      }
+      normalized[normalizeLocaleTag(locale)] = trimmed;
+    }
+    if (Object.keys(normalized).length > 0) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+function readFrontmatterTags(record) {
+  const rawTags = readNestedFrontmatterValue(record, ["tags"]);
+  if (Array.isArray(rawTags)) {
+    const tags2 = rawTags.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+    return tags2.length > 0 ? tags2 : void 0;
+  }
+  if (typeof rawTags !== "string") {
+    return void 0;
+  }
+  const tags = rawTags.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return tags.length > 0 ? tags : void 0;
+}
+function readNestedFrontmatterValue(record, keyPath) {
+  let current = record;
+  for (const rawKey of keyPath) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    const normalizedKey = normalizeFrontmatterKey(rawKey);
+    const matchingKey = Object.keys(current).find((candidate) => normalizeFrontmatterKey(candidate) === normalizedKey);
+    if (!matchingKey) {
+      return void 0;
+    }
+    current = current[matchingKey];
+  }
+  return current;
+}
+function normalizeFrontmatterKey(raw) {
+  return raw.replace(/[-_]/g, "").toLowerCase();
+}
+function normalizeLocaleTag(raw) {
+  return raw.trim().toLowerCase();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/cli/skills/marketplace.ts
 var DEFAULT_MARKETPLACE_API_BASE = "https://marketplace-api.nextclaw.io";
 async function installMarketplaceSkill(options) {
   const slug = validateSkillSlug(options.slug.trim(), "slug");
-  const workdir = resolve2(options.workdir);
-  if (!existsSync2(workdir)) {
+  const workdir = resolve3(options.workdir);
+  if (!existsSync3(workdir)) {
     throw new Error(`Workdir does not exist: ${workdir}`);
   }
   const dirName = options.dir?.trim() || "skills";
-  const destinationDir = isAbsolute(dirName) ? resolve2(dirName, slug) : resolve2(workdir, dirName, slug);
+  const destinationDir = isAbsolute(dirName) ? resolve3(dirName, slug) : resolve3(workdir, dirName, slug);
   const skillFile = join(destinationDir, "SKILL.md");
   const apiBase = resolveMarketplaceApiBase(options.apiBaseUrl);
   const item = await fetchMarketplaceSkillItem(apiBase, slug);
   if (item.install.kind === "builtin") {
-    if (!options.force && existsSync2(destinationDir)) {
-      if (existsSync2(skillFile)) {
+    if (!options.force && existsSync3(destinationDir)) {
+      if (existsSync3(skillFile)) {
         return {
           slug,
           destinationDir,
@@ -213,7 +425,7 @@ async function installMarketplaceSkill(options) {
       }
       throw new Error(`Skill directory already exists: ${destinationDir} (use --force)`);
     }
-    if (existsSync2(destinationDir) && options.force) {
+    if (existsSync3(destinationDir) && options.force) {
       rmSync2(destinationDir, { recursive: true, force: true });
     }
     installBuiltinSkill(workdir, destinationDir, slug);
@@ -224,7 +436,7 @@ async function installMarketplaceSkill(options) {
     };
   }
   const filesPayload = await fetchMarketplaceSkillFiles(apiBase, slug);
-  if (!options.force && existsSync2(destinationDir)) {
+  if (!options.force && existsSync3(destinationDir)) {
     const existingDirState = inspectMarketplaceSkillDirectory(destinationDir, filesPayload.files);
     if (existingDirState === "installed") {
       return {
@@ -240,12 +452,12 @@ async function installMarketplaceSkill(options) {
       throw new Error(`Skill directory already exists: ${destinationDir} (use --force)`);
     }
   }
-  if (existsSync2(destinationDir) && options.force) {
+  if (existsSync3(destinationDir) && options.force) {
     rmSync2(destinationDir, { recursive: true, force: true });
   }
   mkdirSync2(destinationDir, { recursive: true });
   for (const file of filesPayload.files) {
-    const targetPath = resolve2(destinationDir, ...file.path.split("/"));
+    const targetPath = resolve3(destinationDir, ...file.path.split("/"));
     const rel = relative(destinationDir, targetPath);
     if (rel.startsWith("..") || isAbsolute(rel)) {
       throw new Error(`Invalid marketplace file path: ${file.path}`);
@@ -254,7 +466,7 @@ async function installMarketplaceSkill(options) {
     const bytes = file.contentBase64 ? decodeMarketplaceFileContent(file.path, file.contentBase64) : await fetchMarketplaceSkillFileBlob(apiBase, slug, file);
     writeFileSync2(targetPath, bytes);
   }
-  if (!existsSync2(join(destinationDir, "SKILL.md"))) {
+  if (!existsSync3(join(destinationDir, "SKILL.md"))) {
     throw new Error(`Marketplace skill ${slug} does not include SKILL.md`);
   }
   return {
@@ -264,7 +476,7 @@ async function installMarketplaceSkill(options) {
   };
 }
 function inspectMarketplaceSkillDirectory(destinationDir, files) {
-  if (existsSync2(join(destinationDir, "SKILL.md"))) {
+  if (existsSync3(join(destinationDir, "SKILL.md"))) {
     return "installed";
   }
   const discoveredFiles = collectRelativeFiles(destinationDir);
@@ -300,28 +512,31 @@ function collectRelativeFiles(rootDir) {
   };
   return walk(rootDir) ? output : null;
 }
-function normalizeMarketplaceRelativePath(path) {
-  return path.replace(/\\/g, "/");
+function normalizeMarketplaceRelativePath(path2) {
+  return path2.replace(/\\/g, "/");
 }
-function isIgnorableMarketplaceResidue(path) {
-  return path === ".DS_Store";
+function isIgnorableMarketplaceResidue(path2) {
+  return path2 === ".DS_Store";
 }
 async function publishMarketplaceSkill(options) {
-  const skillDir = resolve2(options.skillDir);
-  if (!existsSync2(skillDir)) {
+  const skillDir = resolve3(options.skillDir);
+  if (!existsSync3(skillDir)) {
     throw new Error(`Skill directory not found: ${skillDir}`);
   }
   const files = collectFiles(skillDir);
   if (!files.some((file) => file.path === "SKILL.md")) {
     throw new Error(`Skill directory must include SKILL.md: ${skillDir}`);
   }
-  const parsedFrontmatter = parseSkillFrontmatter(readFileSync2(join(skillDir, "SKILL.md"), "utf8"));
-  const slug = validateSkillSlug(options.slug?.trim() || basename(skillDir), "slug");
-  const name = options.name?.trim() || parsedFrontmatter.name || slug;
-  const description = options.description?.trim() || parsedFrontmatter.description;
-  const summary = options.summary?.trim() || parsedFrontmatter.summary || description || `${slug} skill`;
-  const author = options.author?.trim() || parsedFrontmatter.author || "nextclaw";
-  const tags = normalizeTags(options.tags && options.tags.length > 0 ? options.tags : parsedFrontmatter.tags);
+  const parsedFrontmatter = parseSkillFrontmatter(readFileSync3(join(skillDir, "SKILL.md"), "utf8"));
+  const metadata = readMarketplaceMetadataFile(skillDir, options.metaFile);
+  const slug = validateSkillSlug(options.slug?.trim() || metadata.slug || basename(skillDir), "slug");
+  const name = options.name?.trim() || metadata.name || parsedFrontmatter.name || slug;
+  const description = options.description?.trim() || metadata.description || metadata.descriptionI18n?.en || parsedFrontmatter.description;
+  const summary = options.summary?.trim() || metadata.summary || metadata.summaryI18n?.en || parsedFrontmatter.summary || description || `${slug} skill`;
+  const summaryI18n = buildLocalizedTextMap(summary, parsedFrontmatter.summaryI18n, metadata.summaryI18n, options.summaryI18n);
+  const descriptionI18n = description ? buildLocalizedTextMap(description, parsedFrontmatter.descriptionI18n, metadata.descriptionI18n, options.descriptionI18n) : void 0;
+  const author = options.author?.trim() || metadata.author || parsedFrontmatter.author || "nextclaw";
+  const tags = normalizeTags(options.tags && options.tags.length > 0 ? options.tags : metadata.tags ?? parsedFrontmatter.tags);
   const apiBase = resolveMarketplaceApiBase(options.apiBaseUrl);
   const token = resolveMarketplaceAdminToken(options.token);
   if (options.requireExisting) {
@@ -337,13 +552,15 @@ async function publishMarketplaceSkill(options) {
       slug,
       name,
       summary,
+      summaryI18n,
       description,
+      descriptionI18n,
       author,
       tags,
-      sourceRepo: options.sourceRepo?.trim() || void 0,
-      homepage: options.homepage?.trim() || void 0,
-      publishedAt: options.publishedAt?.trim() || void 0,
-      updatedAt: options.updatedAt?.trim() || void 0,
+      sourceRepo: options.sourceRepo?.trim() || metadata.sourceRepo,
+      homepage: options.homepage?.trim() || metadata.homepage,
+      publishedAt: options.publishedAt?.trim() || metadata.publishedAt,
+      updatedAt: options.updatedAt?.trim() || metadata.updatedAt,
       files
     })
   });
@@ -372,7 +589,7 @@ function collectFiles(rootDir) {
       if (!entry.isFile()) {
         continue;
       }
-      const content = readFileSync2(absolute);
+      const content = readFileSync3(absolute);
       output.push({
         path: relativePath,
         contentBase64: content.toString("base64")
@@ -422,11 +639,11 @@ async function fetchMarketplaceSkillFiles(apiBase, slug) {
     const message = payload.error?.message || `marketplace skill file fetch failed: ${response.status}`;
     throw new Error(message);
   }
-  if (!isRecord(payload.data) || !Array.isArray(payload.data.files)) {
+  if (!isRecord2(payload.data) || !Array.isArray(payload.data.files)) {
     throw new Error("Invalid marketplace skill file manifest response");
   }
   const files = payload.data.files.map((entry, index) => {
-    if (!isRecord(entry) || typeof entry.path !== "string" || entry.path.trim().length === 0) {
+    if (!isRecord2(entry) || typeof entry.path !== "string" || entry.path.trim().length === 0) {
       throw new Error(`Invalid marketplace skill file manifest at index ${index}`);
     }
     const normalized = {
@@ -456,10 +673,10 @@ async function fetchMarketplaceSkillFileBlob(apiBase, slug, file) {
   const arrayBuffer = await response.arrayBuffer();
   return Buffer.from(arrayBuffer);
 }
-function decodeMarketplaceFileContent(path, contentBase64) {
+function decodeMarketplaceFileContent(path2, contentBase64) {
   const normalized = contentBase64.replace(/\s+/g, "");
   if (!normalized || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) {
-    throw new Error(`Invalid marketplace file contentBase64 for path: ${path}`);
+    throw new Error(`Invalid marketplace file contentBase64 for path: ${path2}`);
   }
   return Buffer.from(normalized, "base64");
 }
@@ -494,7 +711,7 @@ async function readMarketplaceEnvelope(response) {
   } catch {
     throw new Error(`Invalid marketplace response: ${response.status}`);
   }
-  if (!isRecord(payload) || typeof payload.ok !== "boolean") {
+  if (!isRecord2(payload) || typeof payload.ok !== "boolean") {
     throw new Error(`Invalid marketplace response shape: ${response.status}`);
   }
   return payload;
@@ -526,56 +743,17 @@ function normalizeTags(rawTags) {
   }
   return output.length > 0 ? output : ["skill"];
 }
-function parseSkillFrontmatter(raw) {
-  const normalized = raw.replace(/\r\n/g, "\n");
-  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
-  if (!match || !match[1]) {
-    return {};
-  }
-  const metadata = /* @__PURE__ */ new Map();
-  for (const line of match[1].split("\n")) {
-    const parsed = line.match(/^([A-Za-z0-9_-]+):\s*(.+)$/);
-    if (!parsed) {
-      continue;
-    }
-    const key = parsed[1]?.trim().toLowerCase();
-    const value = parsed[2]?.trim();
-    if (!key || !value) {
-      continue;
-    }
-    metadata.set(key, trimYamlString(value));
-  }
-  const rawTags = metadata.get("tags");
-  let tags;
-  if (rawTags) {
-    if (rawTags.startsWith("[") && rawTags.endsWith("]")) {
-      tags = rawTags.slice(1, -1).split(",").map((entry) => trimYamlString(entry)).filter(Boolean);
-    } else {
-      tags = rawTags.split(",").map((entry) => entry.trim()).filter(Boolean);
-    }
-  }
-  return {
-    name: metadata.get("name"),
-    summary: metadata.get("summary"),
-    description: metadata.get("description"),
-    author: metadata.get("author"),
-    tags
-  };
-}
-function trimYamlString(raw) {
-  return raw.replace(/^['"]/, "").replace(/['"]$/, "").trim();
-}
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/cli/update/runner.ts
 import { spawnSync } from "child_process";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 
 // src/cli/utils.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, rmSync as rmSync3 } from "fs";
-import { join as join2, resolve as resolve3 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, rmSync as rmSync3 } from "fs";
+import { join as join2, resolve as resolve4 } from "path";
 import { spawn } from "child_process";
 import { isIP } from "net";
 import { fileURLToPath } from "url";
@@ -628,33 +806,33 @@ function buildServeArgs(options) {
   return [cliPath, "serve", "--ui-port", String(options.uiPort)];
 }
 function readServiceState() {
-  const path = resolveServiceStatePath();
-  if (!existsSync3(path)) {
+  const path2 = resolveServiceStatePath();
+  if (!existsSync4(path2)) {
     return null;
   }
   try {
-    const raw = readFileSync3(path, "utf-8");
+    const raw = readFileSync4(path2, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function writeServiceState(state) {
-  const path = resolveServiceStatePath();
-  mkdirSync3(resolve3(path, ".."), { recursive: true });
-  writeFileSync3(path, JSON.stringify(state, null, 2));
+  const path2 = resolveServiceStatePath();
+  mkdirSync3(resolve4(path2, ".."), { recursive: true });
+  writeFileSync3(path2, JSON.stringify(state, null, 2));
 }
 function clearServiceState() {
-  const path = resolveServiceStatePath();
-  if (existsSync3(path)) {
-    rmSync3(path, { force: true });
+  const path2 = resolveServiceStatePath();
+  if (existsSync4(path2)) {
+    rmSync3(path2, { force: true });
   }
 }
 function resolveServiceStatePath() {
-  return resolve3(getDataDir2(), "run", "service.json");
+  return resolve4(getDataDir2(), "run", "service.json");
 }
 function resolveServiceLogPath() {
-  return resolve3(getDataDir2(), "logs", "service.log");
+  return resolve4(getDataDir2(), "logs", "service.log");
 }
 function isProcessRunning(pid) {
   try {
@@ -670,7 +848,7 @@ async function waitForExit(pid, timeoutMs) {
     if (!isProcessRunning(pid)) {
       return true;
     }
-    await new Promise((resolve10) => setTimeout(resolve10, 200));
+    await new Promise((resolve13) => setTimeout(resolve13, 200));
   }
   return !isProcessRunning(pid);
 }
@@ -680,8 +858,8 @@ function resolveUiStaticDir() {
   if (envDir) {
     candidates.push(envDir);
   }
-  const cliDir = resolve3(fileURLToPath(new URL(".", import.meta.url)));
-  const pkgRoot = resolve3(cliDir, "..", "..");
+  const cliDir = resolve4(fileURLToPath(new URL(".", import.meta.url)));
+  const pkgRoot = resolve4(cliDir, "..", "..");
   candidates.push(join2(pkgRoot, "ui-dist"));
   candidates.push(join2(pkgRoot, "ui"));
   candidates.push(join2(pkgRoot, "..", "ui-dist"));
@@ -693,7 +871,7 @@ function resolveUiStaticDir() {
   candidates.push(join2(pkgRoot, "..", "..", "packages", "nextclaw-ui", "dist"));
   candidates.push(join2(pkgRoot, "..", "..", "nextclaw-ui", "dist"));
   for (const dir of candidates) {
-    if (existsSync3(join2(dir, "index.html"))) {
+    if (existsSync4(join2(dir, "index.html"))) {
       return dir;
     }
   }
@@ -744,7 +922,7 @@ function findExecutableOnPath(binary, env = process.env, platform = process.plat
     return null;
   }
   if (target.includes("/") || target.includes("\\")) {
-    return existsSync3(target) ? target : null;
+    return existsSync4(target) ? target : null;
   }
   const rawPath = env.PATH ?? env.Path ?? env.path ?? "";
   if (!rawPath.trim()) {
@@ -754,7 +932,7 @@ function findExecutableOnPath(binary, env = process.env, platform = process.plat
   if (entries.length === 0) {
     return null;
   }
-  const checkCandidates = (candidate) => existsSync3(candidate) ? candidate : null;
+  const checkCandidates = (candidate) => existsSync4(candidate) ? candidate : null;
   for (const dir of entries) {
     const direct = checkCandidates(join2(dir, target));
     if (direct) {
@@ -776,12 +954,12 @@ function which(binary) {
   return findExecutableOnPath(binary) !== null;
 }
 function resolveVersionFromPackageTree(startDir, expectedName) {
-  let current = resolve3(startDir);
+  let current = resolve4(startDir);
   while (current.length > 0) {
     const pkgPath = join2(current, "package.json");
-    if (existsSync3(pkgPath)) {
+    if (existsSync4(pkgPath)) {
       try {
-        const raw = readFileSync3(pkgPath, "utf-8");
+        const raw = readFileSync4(pkgPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (typeof parsed.version === "string") {
           if (!expectedName || parsed.name === expectedName) {
@@ -791,7 +969,7 @@ function resolveVersionFromPackageTree(startDir, expectedName) {
       } catch {
       }
     }
-    const parent = resolve3(current, "..");
+    const parent = resolve4(current, "..");
     if (parent === current) {
       break;
     }
@@ -800,7 +978,7 @@ function resolveVersionFromPackageTree(startDir, expectedName) {
   return null;
 }
 function getPackageVersion() {
-  const cliDir = resolve3(fileURLToPath(new URL(".", import.meta.url)));
+  const cliDir = resolve4(fileURLToPath(new URL(".", import.meta.url)));
   return resolveVersionFromPackageTree(cliDir, "nextclaw") ?? resolveVersionFromPackageTree(cliDir) ?? getCorePackageVersion();
 }
 function printAgentResponse(response) {
@@ -809,8 +987,8 @@ function printAgentResponse(response) {
 async function prompt(rl, question) {
   rl.setPrompt(question);
   rl.prompt();
-  return new Promise((resolve10) => {
-    rl.once("line", (line) => resolve10(line));
+  return new Promise((resolve13) => {
+    rl.once("line", (line) => resolve13(line));
   });
 }
 
@@ -845,7 +1023,7 @@ function runSelfUpdate(options = {}) {
     return { ok: result.status === 0, code: result.status };
   };
   if (updateCommand) {
-    const cwd = options.cwd ? resolve4(options.cwd) : process.cwd();
+    const cwd = options.cwd ? resolve5(options.cwd) : process.cwd();
     const shellCommand = resolveShellCommand(updateCommand);
     const ok = runStep(shellCommand.cmd, shellCommand.args, cwd);
     if (!ok.ok) {
@@ -866,168 +1044,546 @@ function runSelfUpdate(options = {}) {
 
 // src/cli/commands/plugins.ts
 import {
-  addPluginLoadPath,
-  buildPluginStatusReport,
-  disablePluginInConfig,
-  enablePluginInConfig,
-  installPluginFromNpmSpec,
-  installPluginFromPath,
+  buildPluginStatusReport as buildPluginStatusReport2,
   loadOpenClawPlugins,
-  recordPluginInstall,
-  resolveUninstallDirectoryTarget,
-  uninstallPlugin
+  resolveUninstallDirectoryTargets
 } from "@nextclaw/openclaw-compat";
-import {
-  loadConfig,
-  saveConfig,
-  getWorkspacePath,
-  expandHome
-} from "@nextclaw/core";
+
+// src/cli/commands/plugin-command-utils.ts
 import { builtinProviderIds } from "@nextclaw/runtime";
-import { createInterface } from "readline";
-import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve5 } from "path";
 var RESERVED_PROVIDER_IDS = builtinProviderIds();
-function loadPluginRegistry(config2, workspaceDir) {
-  return loadOpenClawPlugins({
-    config: config2,
-    workspaceDir,
-    reservedToolNames: [
-      "read_file",
-      "write_file",
-      "edit_file",
-      "list_dir",
-      "exec",
-      "web_search",
-      "web_fetch",
-      "message",
-      "spawn",
-      "sessions_list",
-      "sessions_history",
-      "sessions_send",
-      "memory_search",
-      "memory_get",
-      "subagents",
-      "gateway",
-      "cron"
-    ],
+var RESERVED_TOOL_NAMES = [
+  "read_file",
+  "write_file",
+  "edit_file",
+  "list_dir",
+  "exec",
+  "web_search",
+  "web_fetch",
+  "message",
+  "spawn",
+  "sessions_list",
+  "sessions_history",
+  "sessions_send",
+  "memory_search",
+  "memory_get",
+  "subagents",
+  "gateway",
+  "cron"
+];
+function buildReservedPluginLoadOptions() {
+  return {
+    reservedToolNames: [...RESERVED_TOOL_NAMES],
     reservedChannelIds: [],
     reservedProviderIds: RESERVED_PROVIDER_IDS,
     reservedEngineKinds: ["native"],
-    logger: {
-      info: (message) => console.log(message),
-      warn: (message) => console.warn(message),
-      error: (message) => console.error(message),
-      debug: (message) => console.debug(message)
-    }
-  });
-}
-function toExtensionRegistry(pluginRegistry) {
-  return {
-    tools: pluginRegistry.tools.map((tool) => ({
-      extensionId: tool.pluginId,
-      factory: tool.factory,
-      names: tool.names,
-      optional: tool.optional,
-      source: tool.source
-    })),
-    channels: pluginRegistry.channels.map((channel) => ({
-      extensionId: channel.pluginId,
-      channel: channel.channel,
-      source: channel.source
-    })),
-    engines: pluginRegistry.engines.map((engine) => ({
-      extensionId: engine.pluginId,
-      kind: engine.kind,
-      factory: engine.factory,
-      source: engine.source
-    })),
-    diagnostics: pluginRegistry.diagnostics.map((diag) => ({
-      level: diag.level,
-      message: diag.message,
-      extensionId: diag.pluginId,
-      source: diag.source
-    }))
+    reservedNcpAgentRuntimeKinds: ["native"]
   };
 }
-function logPluginDiagnostics(registry) {
-  for (const diag of registry.diagnostics) {
-    const prefix = diag.pluginId ? `${diag.pluginId}: ` : "";
-    const text = `${prefix}${diag.message}`;
-    if (diag.level === "error") {
-      console.error(`[plugins] ${text}`);
-    } else {
-      console.warn(`[plugins] ${text}`);
-    }
+function appendPluginCapabilityLines(lines, plugin) {
+  if (plugin.toolNames.length > 0) {
+    lines.push(`Tools: ${plugin.toolNames.join(", ")}`);
+  }
+  if (plugin.channelIds.length > 0) {
+    lines.push(`Channels: ${plugin.channelIds.join(", ")}`);
+  }
+  if (plugin.providerIds.length > 0) {
+    lines.push(`Providers: ${plugin.providerIds.join(", ")}`);
+  }
+  if (plugin.engineKinds.length > 0) {
+    lines.push(`Engines: ${plugin.engineKinds.join(", ")}`);
+  }
+  if (plugin.ncpAgentRuntimeKinds.length > 0) {
+    lines.push(`NCP runtimes: ${plugin.ncpAgentRuntimeKinds.join(", ")}`);
   }
 }
-function toPluginConfigView(config2, bindings) {
-  const view = JSON.parse(JSON.stringify(config2));
-  const channels2 = view.channels && typeof view.channels === "object" && !Array.isArray(view.channels) ? { ...view.channels } : {};
-  for (const binding of bindings) {
-    const pluginConfig = config2.plugins.entries?.[binding.pluginId]?.config;
-    if (!pluginConfig || typeof pluginConfig !== "object" || Array.isArray(pluginConfig)) {
-      continue;
+
+// src/cli/commands/dev-first-party-plugin-load-paths.ts
+import fs from "fs";
+import path from "path";
+var readJsonFile = (filePath) => {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+var readString = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+};
+var hasOpenClawExtensions = (pkg) => {
+  const openclaw = pkg.openclaw;
+  if (!openclaw || typeof openclaw !== "object" || Array.isArray(openclaw)) {
+    return false;
+  }
+  const extensions = openclaw.extensions;
+  return Array.isArray(extensions) && extensions.some((entry) => typeof entry === "string" && entry.trim().length > 0);
+};
+var normalizePackageSpec = (spec) => {
+  const trimmed = spec.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.startsWith("@")) {
+    const slashIndex = trimmed.indexOf("/");
+    if (slashIndex < 0) {
+      return void 0;
     }
-    channels2[binding.channelId] = JSON.parse(JSON.stringify(pluginConfig));
+    const secondAtIndex = trimmed.indexOf("@", slashIndex + 1);
+    return secondAtIndex < 0 ? trimmed : trimmed.slice(0, secondAtIndex);
   }
-  view.channels = channels2;
-  return view;
-}
-function mergePluginConfigView(baseConfig, pluginViewConfig, bindings) {
-  const next = JSON.parse(JSON.stringify(baseConfig));
-  const pluginChannels = pluginViewConfig.channels && typeof pluginViewConfig.channels === "object" && !Array.isArray(pluginViewConfig.channels) ? pluginViewConfig.channels : {};
-  const entries = { ...next.plugins.entries ?? {} };
-  for (const binding of bindings) {
-    if (!Object.prototype.hasOwnProperty.call(pluginChannels, binding.channelId)) {
+  const versionIndex = trimmed.indexOf("@");
+  return versionIndex < 0 ? trimmed : trimmed.slice(0, versionIndex);
+};
+var readWorkspacePluginPackages = (workspaceExtensionsDir) => {
+  if (!workspaceExtensionsDir.trim() || !fs.existsSync(workspaceExtensionsDir)) {
+    return [];
+  }
+  const entries = fs.readdirSync(workspaceExtensionsDir, { withFileTypes: true });
+  const packages = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
       continue;
     }
-    const channelConfig = pluginChannels[binding.channelId];
-    if (!channelConfig || typeof channelConfig !== "object" || Array.isArray(channelConfig)) {
+    const packageDir = path.join(workspaceExtensionsDir, entry.name);
+    const pkg = readJsonFile(path.join(packageDir, "package.json"));
+    if (!pkg || !hasOpenClawExtensions(pkg)) {
       continue;
     }
-    entries[binding.pluginId] = {
-      ...entries[binding.pluginId] ?? {},
-      config: channelConfig
-    };
+    const packageName = readString(pkg.name);
+    if (!packageName?.startsWith("@nextclaw/")) {
+      continue;
+    }
+    packages.push({
+      packageName,
+      dir: packageDir
+    });
   }
-  next.plugins = {
-    ...next.plugins,
-    entries
-  };
-  return next;
-}
-var PluginCommands = class {
-  constructor() {
+  return packages;
+};
+var resolveDevFirstPartyPluginLoadPaths = (config2, workspaceExtensionsDir) => {
+  const rootDir = workspaceExtensionsDir?.trim();
+  if (!rootDir) {
+    return [];
   }
-  pluginsList(opts = {}) {
-    const config2 = loadConfig();
-    const workspaceDir = getWorkspacePath(config2.agents.defaults.workspace);
-    const report = buildPluginStatusReport({
-      config: config2,
-      workspaceDir,
-      reservedChannelIds: [],
-      reservedProviderIds: RESERVED_PROVIDER_IDS,
-      reservedEngineKinds: ["native"]
-    });
-    const list = opts.enabled ? report.plugins.filter((plugin) => plugin.status === "loaded") : report.plugins;
-    if (opts.json) {
-      console.log(
-        JSON.stringify(
-          {
-            workspaceDir,
-            plugins: list,
-            diagnostics: report.diagnostics
-          },
-          null,
-          2
-        )
-      );
-      return;
+  const workspacePackages = readWorkspacePluginPackages(rootDir);
+  if (workspacePackages.length === 0) {
+    return [];
+  }
+  const packageDirByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry.dir]));
+  const loadPaths = [];
+  const installs = config2.plugins.installs ?? {};
+  for (const installRecord of Object.values(installs)) {
+    const packageName = normalizePackageSpec(installRecord.spec ?? "");
+    if (!packageName) {
+      continue;
     }
-    if (list.length === 0) {
-      console.log("No plugins discovered.");
-      return;
+    const packageDir = packageDirByName.get(packageName);
+    if (!packageDir || loadPaths.includes(packageDir)) {
+      continue;
+    }
+    loadPaths.push(packageDir);
+  }
+  return loadPaths;
+};
+var resolveDevFirstPartyPluginInstallRoots = (config2, workspaceExtensionsDir) => {
+  const rootDir = workspaceExtensionsDir?.trim();
+  if (!rootDir) {
+    return [];
+  }
+  const workspacePackages = readWorkspacePluginPackages(rootDir);
+  if (workspacePackages.length === 0) {
+    return [];
+  }
+  const packageNames = new Set(workspacePackages.map((entry) => entry.packageName));
+  const installRoots = [];
+  for (const installRecord of Object.values(config2.plugins.installs ?? {})) {
+    const packageName = normalizePackageSpec(installRecord.spec ?? "");
+    if (!packageName || !packageNames.has(packageName)) {
+      continue;
+    }
+    const installPath = readString(installRecord.installPath);
+    if (!installPath || installRoots.includes(installPath)) {
+      continue;
+    }
+    installRoots.push(installPath);
+  }
+  return installRoots;
+};
+var applyDevFirstPartyPluginLoadPaths = (config2, workspaceExtensionsDir) => {
+  const devLoadPaths = resolveDevFirstPartyPluginLoadPaths(config2, workspaceExtensionsDir);
+  if (devLoadPaths.length === 0) {
+    return config2;
+  }
+  const existingLoadPaths = Array.isArray(config2.plugins.load?.paths) ? config2.plugins.load.paths.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+  const mergedLoadPaths = [...devLoadPaths];
+  for (const entry of existingLoadPaths) {
+    if (!mergedLoadPaths.includes(entry)) {
+      mergedLoadPaths.push(entry);
+    }
+  }
+  return {
+    ...config2,
+    plugins: {
+      ...config2.plugins,
+      load: {
+        ...config2.plugins.load,
+        paths: mergedLoadPaths
+      }
+    }
+  };
+};
+
+// src/cli/commands/plugins.ts
+import {
+  loadConfig as loadConfig2,
+  getWorkspacePath as getWorkspacePath2
+} from "@nextclaw/core";
+import { createInterface } from "readline";
+import { resolve as resolve7 } from "path";
+
+// src/cli/commands/plugin-mutation-actions.ts
+import {
+  addPluginLoadPath,
+  buildPluginStatusReport,
+  disablePluginInConfig,
+  enablePluginInConfig,
+  installPluginFromNpmSpec,
+  installPluginFromPath,
+  recordPluginInstall,
+  uninstallPlugin
+} from "@nextclaw/openclaw-compat";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve6 } from "path";
+import { expandHome, getWorkspacePath, loadConfig, saveConfig } from "@nextclaw/core";
+function resolveFileNpmSpecToLocalPath(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed.toLowerCase().startsWith("file:")) {
+    return null;
+  }
+  const rest = trimmed.slice("file:".length);
+  if (!rest) {
+    return { ok: false, error: "unsupported file: spec: missing path" };
+  }
+  if (rest.startsWith("///")) {
+    return { ok: true, path: rest.slice(2) };
+  }
+  if (rest.startsWith("//localhost/")) {
+    return { ok: true, path: rest.slice("//localhost".length) };
+  }
+  if (rest.startsWith("//")) {
+    return {
+      ok: false,
+      error: 'unsupported file: URL host (expected "file:<path>" or "file:///abs/path")'
+    };
+  }
+  return { ok: true, path: rest };
+}
+function looksLikePath(raw) {
+  return raw.startsWith(".") || raw.startsWith("~") || raw.startsWith("/") || raw.endsWith(".ts") || raw.endsWith(".js") || raw.endsWith(".mjs") || raw.endsWith(".cjs") || raw.endsWith(".tgz") || raw.endsWith(".tar.gz") || raw.endsWith(".tar") || raw.endsWith(".zip");
+}
+function isArchivePath(filePath) {
+  const lower = filePath.toLowerCase();
+  return lower.endsWith(".zip") || lower.endsWith(".tgz") || lower.endsWith(".tar.gz") || lower.endsWith(".tar");
+}
+async function enablePluginMutation(id) {
+  const config2 = loadConfig();
+  const next = enablePluginInConfig(config2, id);
+  saveConfig(next);
+  return {
+    message: `Enabled plugin "${id}".`
+  };
+}
+async function disablePluginMutation(id) {
+  const config2 = loadConfig();
+  const next = disablePluginInConfig(config2, id);
+  saveConfig(next);
+  return {
+    message: `Disabled plugin "${id}".`
+  };
+}
+async function uninstallPluginMutation(id, opts = {}) {
+  const config2 = loadConfig();
+  const workspaceDir = getWorkspacePath(config2.agents.defaults.workspace);
+  const report = buildPluginStatusReport({
+    config: config2,
+    workspaceDir,
+    ...buildReservedPluginLoadOptions()
+  });
+  const keepFiles = Boolean(opts.keepFiles || opts.keepConfig);
+  const plugin = report.plugins.find((entry) => entry.id === id || entry.name === id);
+  const pluginId = plugin?.id ?? id;
+  const hasEntry = pluginId in (config2.plugins.entries ?? {});
+  const hasInstall = pluginId in (config2.plugins.installs ?? {});
+  if (!hasEntry && !hasInstall) {
+    if (plugin) {
+      throw new Error(
+        `Plugin "${pluginId}" is not managed by plugins config/install records and cannot be uninstalled.`
+      );
+    }
+    throw new Error(`Plugin not found: ${id}`);
+  }
+  const result = await uninstallPlugin({
+    config: config2,
+    pluginId,
+    deleteFiles: !keepFiles
+  });
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  saveConfig(result.config);
+  const removed = [];
+  if (result.actions.entry) {
+    removed.push("config entry");
+  }
+  if (result.actions.install) {
+    removed.push("install record");
+  }
+  if (result.actions.allowlist) {
+    removed.push("allowlist");
+  }
+  if (result.actions.loadPath) {
+    removed.push("load path");
+  }
+  if (result.actions.directory) {
+    removed.push("directory");
+  }
+  return {
+    message: `Uninstalled plugin "${pluginId}". Removed: ${removed.length > 0 ? removed.join(", ") : "nothing"}.`,
+    warnings: result.warnings
+  };
+}
+async function installPluginMutation(pathOrSpec, opts = {}) {
+  const fileSpec = resolveFileNpmSpecToLocalPath(pathOrSpec);
+  if (fileSpec && !fileSpec.ok) {
+    throw new Error(fileSpec.error);
+  }
+  const normalized = fileSpec && fileSpec.ok ? fileSpec.path : pathOrSpec;
+  const resolved = resolve6(expandHome(normalized));
+  const config2 = loadConfig();
+  if (existsSync5(resolved)) {
+    if (opts.link) {
+      const probe = await installPluginFromPath({ path: resolved, dryRun: true });
+      if (!probe.ok) {
+        throw new Error(probe.error);
+      }
+      let next3 = addPluginLoadPath(config2, resolved);
+      next3 = enablePluginInConfig(next3, probe.pluginId);
+      next3 = recordPluginInstall(next3, {
+        pluginId: probe.pluginId,
+        source: "path",
+        sourcePath: resolved,
+        installPath: resolved,
+        version: probe.version
+      });
+      saveConfig(next3);
+      return {
+        message: `Linked plugin path: ${resolved}`
+      };
+    }
+    const result2 = await installPluginFromPath({
+      path: resolved,
+      logger: {
+        info: (message) => console.log(message),
+        warn: (message) => console.warn(message)
+      }
+    });
+    if (!result2.ok) {
+      throw new Error(result2.error);
+    }
+    let next2 = enablePluginInConfig(config2, result2.pluginId);
+    next2 = recordPluginInstall(next2, {
+      pluginId: result2.pluginId,
+      source: isArchivePath(resolved) ? "archive" : "path",
+      sourcePath: resolved,
+      installPath: result2.targetDir,
+      version: result2.version
+    });
+    saveConfig(next2);
+    return {
+      message: `Installed plugin: ${result2.pluginId}`
+    };
+  }
+  if (opts.link) {
+    throw new Error("`--link` requires a local path.");
+  }
+  if (looksLikePath(pathOrSpec)) {
+    throw new Error(`Path not found: ${resolved}`);
+  }
+  const result = await installPluginFromNpmSpec({
+    spec: pathOrSpec,
+    logger: {
+      info: (message) => console.log(message),
+      warn: (message) => console.warn(message)
+    }
+  });
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  let next = enablePluginInConfig(config2, result.pluginId);
+  next = recordPluginInstall(next, {
+    pluginId: result.pluginId,
+    source: "npm",
+    spec: pathOrSpec,
+    installPath: result.targetDir,
+    version: result.version
+  });
+  saveConfig(next);
+  return {
+    message: `Installed plugin: ${result.pluginId}`
+  };
+}
+
+// src/cli/commands/plugins.ts
+function loadPluginRegistry(config2, workspaceDir) {
+  const workspaceExtensionsDir = process.env.NEXTCLAW_DEV_FIRST_PARTY_PLUGIN_DIR;
+  const configWithDevPluginPaths = applyDevFirstPartyPluginLoadPaths(
+    config2,
+    workspaceExtensionsDir
+  );
+  const excludedRoots = resolveDevFirstPartyPluginInstallRoots(config2, workspaceExtensionsDir);
+  return loadOpenClawPlugins({
+    config: configWithDevPluginPaths,
+    workspaceDir,
+    excludeRoots: excludedRoots,
+    ...buildReservedPluginLoadOptions(),
+    logger: {
+      info: (message) => console.log(message),
+      warn: (message) => console.warn(message),
+      error: (message) => console.error(message),
+      debug: (message) => console.debug(message)
+    }
+  });
+}
+function toExtensionRegistry(pluginRegistry) {
+  return {
+    tools: pluginRegistry.tools.map((tool) => ({
+      extensionId: tool.pluginId,
+      factory: tool.factory,
+      names: tool.names,
+      optional: tool.optional,
+      source: tool.source
+    })),
+    channels: pluginRegistry.channels.map((channel) => ({
+      extensionId: channel.pluginId,
+      channel: channel.channel,
+      source: channel.source
+    })),
+    engines: pluginRegistry.engines.map((engine) => ({
+      extensionId: engine.pluginId,
+      kind: engine.kind,
+      factory: engine.factory,
+      source: engine.source
+    })),
+    ncpAgentRuntimes: pluginRegistry.ncpAgentRuntimes.map((runtime2) => ({
+      pluginId: runtime2.pluginId,
+      kind: runtime2.kind,
+      label: runtime2.label,
+      createRuntime: runtime2.createRuntime,
+      source: runtime2.source
+    })),
+    diagnostics: pluginRegistry.diagnostics.map((diag) => ({
+      level: diag.level,
+      message: diag.message,
+      extensionId: diag.pluginId,
+      source: diag.source
+    }))
+  };
+}
+function logPluginDiagnostics(registry) {
+  for (const diag of registry.diagnostics) {
+    const prefix = diag.pluginId ? `${diag.pluginId}: ` : "";
+    const text = `${prefix}${diag.message}`;
+    if (diag.level === "error") {
+      console.error(`[plugins] ${text}`);
+    } else {
+      console.warn(`[plugins] ${text}`);
+    }
+  }
+}
+function toPluginConfigView(config2, bindings) {
+  const view = JSON.parse(JSON.stringify(config2));
+  const channels2 = view.channels && typeof view.channels === "object" && !Array.isArray(view.channels) ? { ...view.channels } : {};
+  for (const binding of bindings) {
+    const pluginConfig = config2.plugins.entries?.[binding.pluginId]?.config;
+    if (!pluginConfig || typeof pluginConfig !== "object" || Array.isArray(pluginConfig)) {
+      continue;
+    }
+    channels2[binding.channelId] = JSON.parse(JSON.stringify(pluginConfig));
+  }
+  view.channels = channels2;
+  return view;
+}
+function mergePluginConfigView(baseConfig, pluginViewConfig, bindings) {
+  const next = JSON.parse(JSON.stringify(baseConfig));
+  const pluginChannels = pluginViewConfig.channels && typeof pluginViewConfig.channels === "object" && !Array.isArray(pluginViewConfig.channels) ? pluginViewConfig.channels : {};
+  const entries = { ...next.plugins.entries ?? {} };
+  for (const binding of bindings) {
+    if (!Object.prototype.hasOwnProperty.call(pluginChannels, binding.channelId)) {
+      continue;
+    }
+    const channelConfig = pluginChannels[binding.channelId];
+    if (!channelConfig || typeof channelConfig !== "object" || Array.isArray(channelConfig)) {
+      continue;
+    }
+    entries[binding.pluginId] = {
+      ...entries[binding.pluginId] ?? {},
+      config: channelConfig
+    };
+  }
+  next.plugins = {
+    ...next.plugins,
+    entries
+  };
+  return next;
+}
+var PluginCommands = class {
+  constructor() {
+  }
+  async enablePlugin(id) {
+    return await enablePluginMutation(id);
+  }
+  async disablePlugin(id) {
+    return await disablePluginMutation(id);
+  }
+  async uninstallPlugin(id, opts = {}) {
+    return await uninstallPluginMutation(id, opts);
+  }
+  async installPlugin(pathOrSpec, opts = {}) {
+    return await installPluginMutation(pathOrSpec, opts);
+  }
+  pluginsList(opts = {}) {
+    const config2 = loadConfig2();
+    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const report = buildPluginStatusReport2({
+      config: config2,
+      workspaceDir,
+      ...buildReservedPluginLoadOptions()
+    });
+    const list = opts.enabled ? report.plugins.filter((plugin) => plugin.status === "loaded") : report.plugins;
+    if (opts.json) {
+      console.log(
+        JSON.stringify(
+          {
+            workspaceDir,
+            plugins: list,
+            diagnostics: report.diagnostics
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (list.length === 0) {
+      console.log("No plugins discovered.");
+      return;
     }
     for (const plugin of list) {
       const status = plugin.status === "loaded" ? "loaded" : plugin.status === "disabled" ? "disabled" : "error";
@@ -1043,17 +1599,10 @@ var PluginCommands = class {
       if (plugin.version) {
         console.log(`  version: ${plugin.version}`);
       }
-      if (plugin.toolNames.length > 0) {
-        console.log(`  tools: ${plugin.toolNames.join(", ")}`);
-      }
-      if (plugin.channelIds.length > 0) {
-        console.log(`  channels: ${plugin.channelIds.join(", ")}`);
-      }
-      if (plugin.providerIds.length > 0) {
-        console.log(`  providers: ${plugin.providerIds.join(", ")}`);
-      }
-      if (plugin.engineKinds.length > 0) {
-        console.log(`  engines: ${plugin.engineKinds.join(", ")}`);
+      const capabilityLines = [];
+      appendPluginCapabilityLines(capabilityLines, plugin);
+      for (const line of capabilityLines) {
+        console.log(`  ${line.toLowerCase()}`);
       }
       if (plugin.error) {
         console.log(`  error: ${plugin.error}`);
@@ -1062,14 +1611,12 @@ var PluginCommands = class {
     }
   }
   pluginsInfo(id, opts = {}) {
-    const config2 = loadConfig();
-    const workspaceDir = getWorkspacePath(config2.agents.defaults.workspace);
-    const report = buildPluginStatusReport({
+    const config2 = loadConfig2();
+    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const report = buildPluginStatusReport2({
       config: config2,
       workspaceDir,
-      reservedChannelIds: [],
-      reservedProviderIds: RESERVED_PROVIDER_IDS,
-      reservedEngineKinds: ["native"]
+      ...buildReservedPluginLoadOptions()
     });
     const plugin = report.plugins.find((entry) => entry.id === id || entry.name === id);
     if (!plugin) {
@@ -1096,18 +1643,7 @@ var PluginCommands = class {
     if (plugin.version) {
       lines.push(`Version: ${plugin.version}`);
     }
-    if (plugin.toolNames.length > 0) {
-      lines.push(`Tools: ${plugin.toolNames.join(", ")}`);
-    }
-    if (plugin.channelIds.length > 0) {
-      lines.push(`Channels: ${plugin.channelIds.join(", ")}`);
-    }
-    if (plugin.providerIds.length > 0) {
-      lines.push(`Providers: ${plugin.providerIds.join(", ")}`);
-    }
-    if (plugin.engineKinds.length > 0) {
-      lines.push(`Engines: ${plugin.engineKinds.join(", ")}`);
-    }
+    appendPluginCapabilityLines(lines, plugin);
     if (plugin.error) {
       lines.push(`Error: ${plugin.error}`);
     }
@@ -1133,33 +1669,37 @@ var PluginCommands = class {
     console.log(lines.join("\n"));
   }
   async pluginsEnable(id) {
-    const config2 = loadConfig();
-    const next = enablePluginInConfig(config2, id);
-    saveConfig(next);
-    console.log(`Enabled plugin "${id}".`);
+    try {
+      const result = await this.enablePlugin(id);
+      console.log(result.message);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
     console.log("If gateway is running, plugin changes are hot-applied automatically.");
   }
   async pluginsDisable(id) {
-    const config2 = loadConfig();
-    const next = disablePluginInConfig(config2, id);
-    saveConfig(next);
-    console.log(`Disabled plugin "${id}".`);
+    try {
+      const result = await this.disablePlugin(id);
+      console.log(result.message);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
     console.log("If gateway is running, plugin changes are hot-applied automatically.");
   }
   async pluginsUninstall(id, opts = {}) {
-    const config2 = loadConfig();
-    const workspaceDir = getWorkspacePath(config2.agents.defaults.workspace);
-    const report = buildPluginStatusReport({
+    if (opts.keepConfig) {
+      console.log("`--keep-config` is deprecated, use `--keep-files`.");
+    }
+    const config2 = loadConfig2();
+    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const report = buildPluginStatusReport2({
       config: config2,
       workspaceDir,
-      reservedChannelIds: [],
-      reservedProviderIds: RESERVED_PROVIDER_IDS,
-      reservedEngineKinds: ["native"]
+      ...buildReservedPluginLoadOptions()
     });
     const keepFiles = Boolean(opts.keepFiles || opts.keepConfig);
-    if (opts.keepConfig) {
-      console.log("`--keep-config` is deprecated, use `--keep-files`.");
-    }
     const plugin = report.plugins.find((entry) => entry.id === id || entry.name === id);
     const pluginId = plugin?.id ?? id;
     const hasEntry = pluginId in (config2.plugins.entries ?? {});
@@ -1175,7 +1715,7 @@ var PluginCommands = class {
       process.exit(1);
     }
     const install = config2.plugins.installs?.[pluginId];
-    const isLinked = install?.source === "path" && (!install.installPath || !install.sourcePath || resolve5(install.installPath) === resolve5(install.sourcePath));
+    const isLinked = install?.source === "path" && (!install.installPath || !install.sourcePath || resolve7(install.installPath) === resolve7(install.sourcePath));
     const preview = [];
     if (hasEntry) {
       preview.push("config entry");
@@ -1189,12 +1729,13 @@ var PluginCommands = class {
     if (isLinked && install?.sourcePath && config2.plugins.load?.paths?.includes(install.sourcePath)) {
       preview.push("load path");
     }
-    const deleteTarget = !keepFiles ? resolveUninstallDirectoryTarget({
+    const deleteTargets = !keepFiles ? resolveUninstallDirectoryTargets({
+      config: config2,
       pluginId,
       hasInstall,
       installRecord: install
-    }) : null;
-    if (deleteTarget) {
+    }) : [];
+    for (const deleteTarget of deleteTargets) {
       preview.push(`directory: ${deleteTarget}`);
     }
     const pluginName = plugin?.name || pluginId;
@@ -1212,132 +1753,35 @@ var PluginCommands = class {
         return;
       }
     }
-    const result = await uninstallPlugin({
-      config: config2,
-      pluginId,
-      deleteFiles: !keepFiles
-    });
-    if (!result.ok) {
-      console.error(result.error);
+    try {
+      const result = await this.uninstallPlugin(id, opts);
+      for (const warning of result.warnings) {
+        console.warn(warning);
+      }
+      console.log(result.message);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
       process.exit(1);
     }
-    for (const warning of result.warnings) {
-      console.warn(warning);
-    }
-    saveConfig(result.config);
-    const removed = [];
-    if (result.actions.entry) {
-      removed.push("config entry");
-    }
-    if (result.actions.install) {
-      removed.push("install record");
-    }
-    if (result.actions.allowlist) {
-      removed.push("allowlist");
-    }
-    if (result.actions.loadPath) {
-      removed.push("load path");
-    }
-    if (result.actions.directory) {
-      removed.push("directory");
-    }
-    console.log(`Uninstalled plugin "${pluginId}". Removed: ${removed.length > 0 ? removed.join(", ") : "nothing"}.`);
     console.log("If gateway is running, plugin changes are hot-applied automatically.");
   }
   async pluginsInstall(pathOrSpec, opts = {}) {
-    const fileSpec = this.resolveFileNpmSpecToLocalPath(pathOrSpec);
-    if (fileSpec && !fileSpec.ok) {
-      console.error(fileSpec.error);
-      process.exit(1);
-    }
-    const normalized = fileSpec && fileSpec.ok ? fileSpec.path : pathOrSpec;
-    const resolved = resolve5(expandHome(normalized));
-    const config2 = loadConfig();
-    if (existsSync4(resolved)) {
-      if (opts.link) {
-        const probe = await installPluginFromPath({ path: resolved, dryRun: true });
-        if (!probe.ok) {
-          console.error(probe.error);
-          process.exit(1);
-        }
-        let next3 = addPluginLoadPath(config2, resolved);
-        next3 = enablePluginInConfig(next3, probe.pluginId);
-        next3 = recordPluginInstall(next3, {
-          pluginId: probe.pluginId,
-          source: "path",
-          sourcePath: resolved,
-          installPath: resolved,
-          version: probe.version
-        });
-        saveConfig(next3);
-        console.log(`Linked plugin path: ${resolved}`);
-        console.log("If gateway is running, plugin changes are hot-applied automatically.");
-        return;
-      }
-      const result2 = await installPluginFromPath({
-        path: resolved,
-        logger: {
-          info: (message) => console.log(message),
-          warn: (message) => console.warn(message)
-        }
-      });
-      if (!result2.ok) {
-        console.error(result2.error);
-        process.exit(1);
-      }
-      let next2 = enablePluginInConfig(config2, result2.pluginId);
-      next2 = recordPluginInstall(next2, {
-        pluginId: result2.pluginId,
-        source: this.isArchivePath(resolved) ? "archive" : "path",
-        sourcePath: resolved,
-        installPath: result2.targetDir,
-        version: result2.version
-      });
-      saveConfig(next2);
-      console.log(`Installed plugin: ${result2.pluginId}`);
-      console.log("If gateway is running, plugin changes are hot-applied automatically.");
-      return;
-    }
-    if (opts.link) {
-      console.error("`--link` requires a local path.");
-      process.exit(1);
-    }
-    if (this.looksLikePath(pathOrSpec)) {
-      console.error(`Path not found: ${resolved}`);
-      process.exit(1);
-    }
-    const result = await installPluginFromNpmSpec({
-      spec: pathOrSpec,
-      logger: {
-        info: (message) => console.log(message),
-        warn: (message) => console.warn(message)
-      }
-    });
-    if (!result.ok) {
-      console.error(result.error);
+    try {
+      const result = await this.installPlugin(pathOrSpec, opts);
+      console.log(result.message);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
       process.exit(1);
     }
-    let next = enablePluginInConfig(config2, result.pluginId);
-    next = recordPluginInstall(next, {
-      pluginId: result.pluginId,
-      source: "npm",
-      spec: pathOrSpec,
-      installPath: result.targetDir,
-      version: result.version
-    });
-    saveConfig(next);
-    console.log(`Installed plugin: ${result.pluginId}`);
     console.log("If gateway is running, plugin changes are hot-applied automatically.");
   }
   pluginsDoctor() {
-    const config2 = loadConfig();
-    const workspaceDir = getWorkspacePath(config2.agents.defaults.workspace);
-    const report = buildPluginStatusReport({
+    const config2 = loadConfig2();
+    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const report = buildPluginStatusReport2({
       config: config2,
       workspaceDir,
-      reservedChannelIds: [],
-      reservedProviderIds: RESERVED_PROVIDER_IDS,
-      reservedEngineKinds: ["native"]
+      ...buildReservedPluginLoadOptions()
     });
     const pluginErrors = report.plugins.filter((plugin) => plugin.status === "error");
     const diagnostics = report.diagnostics.filter((diag) => diag.level === "error");
@@ -1367,47 +1811,17 @@ var PluginCommands = class {
       input: process.stdin,
       output: process.stdout
     });
-    const answer = await new Promise((resolve10) => {
-      rl.question(`${question} [y/N] `, (line) => resolve10(line));
+    const answer = await new Promise((resolve13) => {
+      rl.question(`${question} [y/N] `, (line) => resolve13(line));
     });
     rl.close();
     const normalized = answer.trim().toLowerCase();
     return normalized === "y" || normalized === "yes";
   }
-  resolveFileNpmSpecToLocalPath(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed.toLowerCase().startsWith("file:")) {
-      return null;
-    }
-    const rest = trimmed.slice("file:".length);
-    if (!rest) {
-      return { ok: false, error: "unsupported file: spec: missing path" };
-    }
-    if (rest.startsWith("///")) {
-      return { ok: true, path: rest.slice(2) };
-    }
-    if (rest.startsWith("//localhost/")) {
-      return { ok: true, path: rest.slice("//localhost".length) };
-    }
-    if (rest.startsWith("//")) {
-      return {
-        ok: false,
-        error: 'unsupported file: URL host (expected "file:<path>" or "file:///abs/path")'
-      };
-    }
-    return { ok: true, path: rest };
-  }
-  looksLikePath(raw) {
-    return raw.startsWith(".") || raw.startsWith("~") || raw.startsWith("/") || raw.endsWith(".ts") || raw.endsWith(".js") || raw.endsWith(".mjs") || raw.endsWith(".cjs") || raw.endsWith(".tgz") || raw.endsWith(".tar.gz") || raw.endsWith(".tar") || raw.endsWith(".zip");
-  }
-  isArchivePath(filePath) {
-    const lower = filePath.toLowerCase();
-    return lower.endsWith(".zip") || lower.endsWith(".tgz") || lower.endsWith(".tar.gz") || lower.endsWith(".tar");
-  }
 };
 
 // src/cli/commands/config.ts
-import { buildReloadPlan, diffConfigPaths, loadConfig as loadConfig2, saveConfig as saveConfig2 } from "@nextclaw/core";
+import { buildReloadPlan, diffConfigPaths, loadConfig as loadConfig3, saveConfig as saveConfig2 } from "@nextclaw/core";
 
 // src/cli/config-path.ts
 function isIndexSegment(raw) {
@@ -1602,7 +2016,7 @@ var ConfigCommands = class {
     this.deps = deps;
   }
   configGet(pathExpr, opts = {}) {
-    const config2 = loadConfig2();
+    const config2 = loadConfig3();
     let parsedPath;
     try {
       parsedPath = parseRequiredConfigPath(pathExpr);
@@ -1644,7 +2058,7 @@ var ConfigCommands = class {
       process.exit(1);
       return;
     }
-    const prevConfig = loadConfig2();
+    const prevConfig = loadConfig3();
     const nextConfig = structuredClone(prevConfig);
     try {
       setAtConfigPath(nextConfig, parsedPath, parsedValue);
@@ -1670,7 +2084,7 @@ var ConfigCommands = class {
       process.exit(1);
       return;
     }
-    const prevConfig = loadConfig2();
+    const prevConfig = loadConfig3();
     const nextConfig = structuredClone(prevConfig);
     const removed = unsetAtConfigPath(nextConfig, parsedPath);
     if (!removed) {
@@ -1703,12 +2117,12 @@ var ConfigCommands = class {
 };
 
 // src/cli/commands/secrets.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import {
   buildReloadPlan as buildReloadPlan2,
   diffConfigPaths as diffConfigPaths2,
   getConfigPath,
-  loadConfig as loadConfig3,
+  loadConfig as loadConfig4,
   resolveConfigSecrets,
   saveConfig as saveConfig3
 } from "@nextclaw/core";
@@ -1761,17 +2175,17 @@ function parseRefsPatch(raw) {
     throw new Error("refs patch must be an object");
   }
   const output = {};
-  for (const [path, value] of Object.entries(raw)) {
+  for (const [path2, value] of Object.entries(raw)) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`invalid ref for ${path}`);
+      throw new Error(`invalid ref for ${path2}`);
     }
     const source = normalizeSecretSource(value.source);
     const id = normalizeOptionalString(value.id);
     const provider = normalizeOptionalString(value.provider);
     if (!source || !id) {
-      throw new Error(`invalid ref for ${path}: source/id is required`);
+      throw new Error(`invalid ref for ${path2}: source/id is required`);
     }
-    output[path] = { source, ...provider ? { provider } : {}, id };
+    output[path2] = { source, ...provider ? { provider } : {}, id };
   }
   return output;
 }
@@ -1804,21 +2218,21 @@ var SecretsCommands = class {
     this.deps = deps;
   }
   secretsAudit(opts = {}) {
-    const config2 = loadConfig3();
+    const config2 = loadConfig4();
     const configPath = getConfigPath();
     const refs = config2.secrets.refs;
     const items = [];
-    for (const [path, ref] of Object.entries(refs)) {
+    for (const [path2, ref] of Object.entries(refs)) {
       const provider = inferProviderAlias(config2, ref);
       const scopedConfig = structuredClone(config2);
-      scopedConfig.secrets.refs = { [path]: ref };
+      scopedConfig.secrets.refs = { [path2]: ref };
       try {
         const resolved = resolveConfigSecrets(scopedConfig, { configPath });
-        const parsedPath = parseRequiredConfigPath(path);
+        const parsedPath = parseRequiredConfigPath(path2);
         const target = getAtConfigPath(resolved, parsedPath);
         if (!target.found) {
           items.push({
-            path,
+            path: path2,
             source: ref.source,
             provider,
             id: ref.id,
@@ -1830,7 +2244,7 @@ var SecretsCommands = class {
         const resolvedValue = target.value;
         const detail = typeof resolvedValue === "string" ? `resolved (length=${resolvedValue.length})` : `resolved (${typeof resolvedValue})`;
         items.push({
-          path,
+          path: path2,
           source: ref.source,
           provider,
           id: ref.id,
@@ -1839,7 +2253,7 @@ var SecretsCommands = class {
         });
       } catch (error) {
         items.push({
-          path,
+          path: path2,
           source: ref.source,
           provider,
           id: ref.id,
@@ -1872,7 +2286,7 @@ var SecretsCommands = class {
     if (!alias) {
       throw new Error("provider alias is required");
     }
-    const prevConfig = loadConfig3();
+    const prevConfig = loadConfig4();
     const nextConfig = structuredClone(prevConfig);
     const remove = Boolean(opts.remove);
     if (remove) {
@@ -1893,13 +2307,13 @@ var SecretsCommands = class {
           ...normalizeOptionalString(opts.prefix) ? { prefix: normalizeOptionalString(opts.prefix) } : {}
         };
       } else if (source === "file") {
-        const path = normalizeOptionalString(opts.path);
-        if (!path) {
+        const path2 = normalizeOptionalString(opts.path);
+        if (!path2) {
           throw new Error("file source requires --path");
         }
         nextConfig.secrets.providers[alias] = {
           source,
-          path,
+          path: path2,
           format: "json"
         };
       } else {
@@ -1934,7 +2348,7 @@ var SecretsCommands = class {
     console.log(`Secrets provider ${remove ? "removed" : "configured"}: ${alias}`);
   }
   async secretsApply(opts) {
-    const prevConfig = loadConfig3();
+    const prevConfig = loadConfig4();
     const nextConfig = structuredClone(prevConfig);
     if (opts.enable && opts.disable) {
       throw new Error("cannot set --enable and --disable at the same time");
@@ -1946,7 +2360,7 @@ var SecretsCommands = class {
       nextConfig.secrets.enabled = false;
     }
     if (opts.file) {
-      const raw = readFileSync4(opts.file, "utf-8");
+      const raw = readFileSync5(opts.file, "utf-8");
       const patch = parseApplyFile(raw);
       if (patch.defaults) {
         nextConfig.secrets.defaults = patch.defaults;
@@ -1962,12 +2376,12 @@ var SecretsCommands = class {
       }
     }
     if (opts.path) {
-      const path = opts.path.trim();
-      if (!path) {
+      const path2 = opts.path.trim();
+      if (!path2) {
         throw new Error("path is empty");
       }
       if (opts.remove) {
-        delete nextConfig.secrets.refs[path];
+        delete nextConfig.secrets.refs[path2];
       } else {
         const source = normalizeSecretSource(opts.source);
         const id = normalizeOptionalString(opts.id);
@@ -1975,7 +2389,7 @@ var SecretsCommands = class {
           throw new Error("apply single ref requires --source and --id");
         }
         const provider = normalizeOptionalString(opts.provider);
-        nextConfig.secrets.refs[path] = {
+        nextConfig.secrets.refs[path2] = {
           source,
           id,
           ...provider ? { provider } : {}
@@ -1999,7 +2413,7 @@ var SecretsCommands = class {
     console.log("Secrets applied.");
   }
   async secretsReload(opts = {}) {
-    const config2 = loadConfig3();
+    const config2 = loadConfig4();
     const configPath = getConfigPath();
     resolveConfigSecrets(config2, { configPath });
     saveConfig3(config2);
@@ -2027,9 +2441,9 @@ var SecretsCommands = class {
 
 // src/cli/commands/channels.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { getWorkspacePath as getWorkspacePath2, loadConfig as loadConfig4, saveConfig as saveConfig4 } from "@nextclaw/core";
+import { getWorkspacePath as getWorkspacePath3, loadConfig as loadConfig5, saveConfig as saveConfig4 } from "@nextclaw/core";
 import { BUILTIN_CHANNEL_PLUGIN_IDS, builtinProviderIds as builtinProviderIds2 } from "@nextclaw/runtime";
-import { buildPluginStatusReport as buildPluginStatusReport2, enablePluginInConfig as enablePluginInConfig2, getPluginChannelBindings } from "@nextclaw/openclaw-compat";
+import { buildPluginStatusReport as buildPluginStatusReport3, enablePluginInConfig as enablePluginInConfig2, getPluginChannelBindings } from "@nextclaw/openclaw-compat";
 var CHANNEL_LABELS = {
   telegram: "Telegram",
   whatsapp: "WhatsApp",
@@ -2048,7 +2462,7 @@ var ChannelCommands = class {
     this.deps = deps;
   }
   channelsStatus() {
-    const config2 = loadConfig4();
+    const config2 = loadConfig5();
     console.log("Channel Status");
     const channelConfig = config2.channels;
     for (const channelId of BUILTIN_CHANNEL_PLUGIN_IDS) {
@@ -2056,8 +2470,8 @@ var ChannelCommands = class {
       const enabled = channelConfig[channelId]?.enabled === true;
       console.log(`${label}: ${enabled ? "\u2713" : "\u2717"}`);
     }
-    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
-    const report = buildPluginStatusReport2({
+    const workspaceDir = getWorkspacePath3(config2.agents.defaults.workspace);
+    const report = buildPluginStatusReport3({
       config: config2,
       workspaceDir,
       reservedChannelIds: [],
@@ -2087,8 +2501,8 @@ var ChannelCommands = class {
       console.error("--channel is required");
       process.exit(1);
     }
-    const config2 = loadConfig4();
-    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const config2 = loadConfig5();
+    const workspaceDir = getWorkspacePath3(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspaceDir);
     const bindings = getPluginChannelBindings(pluginRegistry);
     const binding = bindings.find((entry) => entry.channelId === channelId || entry.pluginId === channelId);
@@ -2217,15 +2631,15 @@ var CronCommands = class {
 
 // src/cli/commands/diagnostics.ts
 import { createServer as createNetServer } from "net";
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve8 } from "path";
 import {
   APP_NAME,
   getConfigPath as getConfigPath2,
   getDataDir as getDataDir4,
-  getWorkspacePath as getWorkspacePath3,
+  getWorkspacePath as getWorkspacePath4,
   hasSecretRef,
-  loadConfig as loadConfig5
+  loadConfig as loadConfig6
 } from "@nextclaw/core";
 import { listBuiltinProviders } from "@nextclaw/runtime";
 var DiagnosticsCommands = class {
@@ -2387,9 +2801,9 @@ var DiagnosticsCommands = class {
   }
   async collectRuntimeStatus(params) {
     const configPath = getConfigPath2();
-    const config2 = loadConfig5();
-    const workspacePath = getWorkspacePath3(config2.agents.defaults.workspace);
-    const serviceStatePath = resolve6(getDataDir4(), "run", "service.json");
+    const config2 = loadConfig6();
+    const workspacePath = getWorkspacePath4(config2.agents.defaults.workspace);
+    const serviceStatePath = resolve8(getDataDir4(), "run", "service.json");
     const fixActions = [];
     let serviceState = readServiceState();
     if (params.fix && serviceState && !isProcessRunning(serviceState.pid)) {
@@ -2429,11 +2843,11 @@ var DiagnosticsCommands = class {
     });
     const issues = [];
     const recommendations = [];
-    if (!existsSync5(configPath)) {
+    if (!existsSync6(configPath)) {
       issues.push("Config file is missing.");
       recommendations.push(`Run ${APP_NAME} init to create config files.`);
     }
-    if (!existsSync5(workspacePath)) {
+    if (!existsSync6(workspacePath)) {
       issues.push("Workspace directory does not exist.");
       recommendations.push(`Run ${APP_NAME} init to create workspace templates.`);
     }
@@ -2466,13 +2880,13 @@ var DiagnosticsCommands = class {
     return {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       configPath,
-      configExists: existsSync5(configPath),
+      configExists: existsSync6(configPath),
       workspacePath,
-      workspaceExists: existsSync5(workspacePath),
+      workspaceExists: existsSync6(workspacePath),
       model: config2.agents.defaults.model,
       providers,
       serviceStatePath,
-      serviceStateExists: existsSync5(serviceStatePath),
+      serviceStateExists: existsSync6(serviceStatePath),
       fixActions,
       process: {
         managedByState,
@@ -2521,12 +2935,12 @@ var DiagnosticsCommands = class {
       clearTimeout(timer);
     }
   }
-  readLogTail(path, maxLines = 25) {
-    if (!existsSync5(path)) {
+  readLogTail(path2, maxLines = 25) {
+    if (!existsSync6(path2)) {
       return [];
     }
     try {
-      const lines = readFileSync5(path, "utf-8").split(/\r?\n/).filter(Boolean);
+      const lines = readFileSync6(path2, "utf-8").split(/\r?\n/).filter(Boolean);
       if (lines.length <= maxLines) {
         return lines;
       }
@@ -2536,17 +2950,17 @@ var DiagnosticsCommands = class {
     }
   }
   async checkPortAvailability(params) {
-    return await new Promise((resolve10) => {
+    return await new Promise((resolve13) => {
       const server = createNetServer();
       server.once("error", (error) => {
-        resolve10({
+        resolve13({
           available: false,
           detail: `bind failed on ${params.host}:${params.port} (${String(error)})`
         });
       });
       server.listen(params.port, params.host, () => {
         server.close(() => {
-          resolve10({
+          resolve13({
             available: true,
             detail: `bind ok on ${params.host}:${params.port}`
           });
@@ -2559,24 +2973,24 @@ var DiagnosticsCommands = class {
 // src/cli/commands/service.ts
 import * as NextclawCore from "@nextclaw/core";
 import {
-  getPluginChannelBindings as getPluginChannelBindings2,
+  getPluginChannelBindings as getPluginChannelBindings3,
   resolvePluginChannelMessageToolHints,
   setPluginRuntimeBridge,
-  startPluginChannelGateways,
-  stopPluginChannelGateways
+  startPluginChannelGateways as startPluginChannelGateways2,
+  stopPluginChannelGateways as stopPluginChannelGateways2
 } from "@nextclaw/openclaw-compat";
 import { startUiServer } from "@nextclaw/server";
-import { appendFileSync, closeSync, cpSync as cpSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, openSync, rmSync as rmSync4 } from "fs";
-import { dirname as dirname2, join as join5, resolve as resolve7 } from "path";
+import { appendFileSync, closeSync, cpSync as cpSync2, existsSync as existsSync9, mkdirSync as mkdirSync5, openSync, rmSync as rmSync4 } from "fs";
+import { dirname as dirname2, join as join5, resolve as resolve10 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { createServer as createNetServer2 } from "net";
 import chokidar from "chokidar";
 
 // src/cli/gateway/controller.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import {
   buildConfigSchema,
   ConfigSchema,
@@ -2585,11 +2999,11 @@ import {
 } from "@nextclaw/core";
 var hashRaw = (raw) => createHash("sha256").update(raw).digest("hex");
 var readConfigSnapshot = (getConfigPath5) => {
-  const path = getConfigPath5();
+  const path2 = getConfigPath5();
   let raw = "";
   let parsed = {};
-  if (existsSync6(path)) {
-    raw = readFileSync6(path, "utf-8");
+  if (existsSync7(path2)) {
+    raw = readFileSync7(path2, "utf-8");
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -2900,11 +3314,15 @@ var ConfigReloader = class {
     this.currentConfig = nextConfig;
     this.options.providerManager?.setConfig(nextConfig);
     const plan = buildReloadPlan3(changedPaths);
+    let reloadPluginsResult = void 0;
     if (plan.reloadPlugins) {
-      await this.reloadPlugins(nextConfig);
+      reloadPluginsResult = await this.reloadPlugins({
+        config: nextConfig,
+        changedPaths
+      });
       console.log("Config reload: plugins reloaded.");
     }
-    if (plan.restartChannels) {
+    if (plan.restartChannels || reloadPluginsResult?.restartChannels) {
       await this.reloadChannels(nextConfig);
       console.log("Config reload: channels restarted.");
     }
@@ -2999,11 +3417,11 @@ var ConfigReloader = class {
       this.providerReloadTask = null;
     }
   }
-  async reloadPlugins(nextConfig) {
+  async reloadPlugins(params) {
     if (!this.options.reloadPlugins) {
       return;
     }
-    await this.options.reloadPlugins(nextConfig);
+    return await this.options.reloadPlugins(params);
   }
 };
 
@@ -3025,6 +3443,104 @@ var MissingProvider = class extends LLMProvider {
   }
 };
 
+// src/cli/commands/service-plugin-reload.ts
+import { getWorkspacePath as getWorkspacePath5 } from "@nextclaw/core";
+import {
+  getPluginChannelBindings as getPluginChannelBindings2,
+  startPluginChannelGateways,
+  stopPluginChannelGateways
+} from "@nextclaw/openclaw-compat";
+
+// src/cli/commands/plugin-reload.ts
+function buildPluginChannelBindingSignature(binding) {
+  return `${binding.pluginId}:${binding.channelId}`;
+}
+function buildSortedBindingSignatures(bindings) {
+  return bindings.map(buildPluginChannelBindingSignature).sort();
+}
+function buildSortedExtensionChannelIds(channels2) {
+  return channels2.map((registration) => registration.channel.id).filter((id) => typeof id === "string" && id.trim().length > 0).sort();
+}
+function areSortedStringListsEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function readPluginIdFromPluginsEntryPath(path2) {
+  const prefix = "plugins.entries.";
+  if (!path2.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = path2.slice(prefix.length);
+  const [pluginId] = suffix.split(".");
+  return pluginId?.trim() ? pluginId.trim() : null;
+}
+function shouldRestartChannelsForPluginReload(params) {
+  const currentBindingSignatures = buildSortedBindingSignatures(params.currentPluginChannelBindings);
+  const nextBindingSignatures = buildSortedBindingSignatures(params.nextPluginChannelBindings);
+  if (!areSortedStringListsEqual(currentBindingSignatures, nextBindingSignatures)) {
+    return true;
+  }
+  const currentExtensionChannelIds = buildSortedExtensionChannelIds(params.currentExtensionChannels);
+  const nextExtensionChannelIds = buildSortedExtensionChannelIds(params.nextExtensionChannels);
+  if (!areSortedStringListsEqual(currentExtensionChannelIds, nextExtensionChannelIds)) {
+    return true;
+  }
+  const channelPluginIds = /* @__PURE__ */ new Set();
+  for (const binding of params.currentPluginChannelBindings) {
+    channelPluginIds.add(binding.pluginId);
+  }
+  for (const binding of params.nextPluginChannelBindings) {
+    channelPluginIds.add(binding.pluginId);
+  }
+  for (const path2 of params.changedPaths) {
+    const pluginId = readPluginIdFromPluginsEntryPath(path2);
+    if (pluginId && channelPluginIds.has(pluginId)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/cli/commands/service-plugin-reload.ts
+async function reloadServicePlugins(params) {
+  const nextWorkspace = getWorkspacePath5(params.nextConfig.agents.defaults.workspace);
+  const nextPluginRegistry = loadPluginRegistry(params.nextConfig, nextWorkspace);
+  const nextExtensionRegistry = toExtensionRegistry(nextPluginRegistry);
+  const nextPluginChannelBindings = getPluginChannelBindings2(nextPluginRegistry);
+  const shouldRestartChannels = shouldRestartChannelsForPluginReload({
+    changedPaths: params.changedPaths,
+    currentPluginChannelBindings: params.pluginChannelBindings,
+    nextPluginChannelBindings,
+    currentExtensionChannels: params.extensionRegistry.channels,
+    nextExtensionChannels: nextExtensionRegistry.channels
+  });
+  logPluginDiagnostics(nextPluginRegistry);
+  let pluginGatewayHandles = params.pluginGatewayHandles;
+  if (shouldRestartChannels) {
+    await stopPluginChannelGateways(pluginGatewayHandles);
+    const startedPluginGateways = await startPluginChannelGateways({
+      registry: nextPluginRegistry,
+      logger: params.pluginGatewayLogger
+    });
+    pluginGatewayHandles = startedPluginGateways.handles;
+    params.logPluginGatewayDiagnostics(startedPluginGateways.diagnostics);
+  }
+  return {
+    pluginRegistry: nextPluginRegistry,
+    extensionRegistry: nextExtensionRegistry,
+    pluginChannelBindings: nextPluginChannelBindings,
+    pluginGatewayHandles,
+    restartChannels: shouldRestartChannels
+  };
+}
+
 // src/cli/commands/agent-runtime-pool.ts
 import {
   NativeAgentEngine,
@@ -3032,7 +3548,7 @@ import {
   createAssistantStreamDeltaControlMessage,
   createAssistantStreamResetControlMessage,
   AgentRouteResolver,
-  getWorkspacePath as getWorkspacePath4,
+  getWorkspacePath as getWorkspacePath6,
   parseAgentScopedSessionKey
 } from "@nextclaw/core";
 function normalizeAgentId(value) {
@@ -3077,7 +3593,7 @@ function resolveAgentProfiles(config2) {
   }
   return Array.from(unique.values()).map((entry) => ({
     id: entry.id,
-    workspace: getWorkspacePath4(entry.workspace ?? defaults.workspace),
+    workspace: getWorkspacePath6(entry.workspace ?? defaults.workspace),
     model: entry.model ?? defaults.model,
     engine: normalizeEngineKind(entry.engine ?? defaults.engine),
     engineConfig: entry.engineConfig ?? toRecord(defaults.engineConfig),
@@ -3342,7 +3858,7 @@ var GatewayAgentRuntimePool = class {
     const normalizedAgentId = normalizeAgentId(agentId);
     return this.resolvedProfiles.find((profile) => profile.id === normalizedAgentId) ?? this.resolvedProfiles.find((profile) => profile.id === this.defaultAgentId) ?? this.resolvedProfiles[0] ?? {
       id: this.defaultAgentId,
-      workspace: getWorkspacePath4(this.options.config.agents.defaults.workspace),
+      workspace: getWorkspacePath6(this.options.config.agents.defaults.workspace),
       model: this.options.config.agents.defaults.model,
       maxIterations: this.options.config.agents.defaults.maxToolIterations,
       contextTokens: this.options.config.agents.defaults.contextTokens,
@@ -3455,72 +3971,1400 @@ var GatewayAgentRuntimePool = class {
         engine
       });
     }
-    this.runtimes = nextRuntimes;
-    this.dynamicEngineRuntimes.clear();
+    this.runtimes = nextRuntimes;
+    this.dynamicEngineRuntimes.clear();
+  }
+};
+function parseCommandArgsFromText(commandName, rawTail, specs) {
+  if (!rawTail) {
+    return {};
+  }
+  const command = specs.find((item) => item.name.trim().toLowerCase() === commandName);
+  const options = command?.options;
+  if (!options || options.length === 0) {
+    return {};
+  }
+  const tokens = rawTail.split(/\s+/).filter(Boolean);
+  const args = {};
+  let cursor = 0;
+  for (let i = 0; i < options.length; i += 1) {
+    if (cursor >= tokens.length) {
+      break;
+    }
+    const option = options[i];
+    const isLastOption = i === options.length - 1;
+    const rawValue = isLastOption ? tokens.slice(cursor).join(" ") : tokens[cursor];
+    cursor += isLastOption ? tokens.length - cursor : 1;
+    const parsedValue = parseCommandOptionValue(option.type, rawValue);
+    if (parsedValue !== void 0) {
+      args[option.name] = parsedValue;
+    }
+  }
+  return args;
+}
+function parseCommandOptionValue(type, rawValue) {
+  const value = rawValue.trim();
+  if (!value) {
+    return void 0;
+  }
+  if (type === "number") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  if (type === "boolean") {
+    const lowered = value.toLowerCase();
+    if (["1", "true", "yes", "on"].includes(lowered)) {
+      return true;
+    }
+    if (["0", "false", "no", "off"].includes(lowered)) {
+      return false;
+    }
+    return void 0;
+  }
+  return value;
+}
+function formatUserFacingError(error, maxChars = 320) {
+  const raw = error instanceof Error ? error.message || error.name || "Unknown error" : String(error ?? "Unknown error");
+  const normalized = raw.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return "Unknown error";
+  }
+  if (normalized.length <= maxChars) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+
+// src/cli/commands/cli-subcommand-launch.ts
+import { createRequire } from "module";
+import { extname, resolve as resolve9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var require2 = createRequire(import.meta.url);
+var resolveCliSubcommandEntry = (params) => {
+  const argvEntry = params.argvEntry?.trim();
+  if (argvEntry) {
+    return resolve9(argvEntry);
+  }
+  return fileURLToPath2(new URL("../index.js", params.importMetaUrl));
+};
+
+// src/cli/commands/ncp/create-ui-ncp-agent.ts
+import {
+  DisposableStore
+} from "@nextclaw/core";
+import { DefaultNcpAgentRuntime } from "@nextclaw/ncp-agent-runtime";
+import {
+  readAssistantReasoningNormalizationMode,
+  readAssistantReasoningNormalizationModeFromMetadata,
+  writeAssistantReasoningNormalizationModeToMetadata
+} from "@nextclaw/ncp";
+import { createAgentClientFromServer, DefaultNcpAgentBackend } from "@nextclaw/ncp-toolkit";
+
+// src/cli/commands/ncp/nextclaw-ncp-context-builder.ts
+import {
+  ContextBuilder,
+  InputBudgetPruner,
+  getWorkspacePath as getWorkspacePath7,
+  parseThinkingLevel,
+  resolveThinkingLevel
+} from "@nextclaw/core";
+
+// src/cli/commands/ncp/nextclaw-ncp-message-bridge.ts
+import {
+  sanitizeAssistantReplyTags
+} from "@nextclaw/ncp";
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function cloneMetadata(value) {
+  return isRecord3(value) ? structuredClone(value) : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const deduped = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    const normalized = normalizeString(item);
+    if (normalized) {
+      deduped.add(normalized);
+    }
+  }
+  return [...deduped];
+}
+function mergeSessionMetadata(currentMetadata, inputMetadata) {
+  if (!inputMetadata) {
+    return currentMetadata;
+  }
+  const nextMetadata = {
+    ...currentMetadata,
+    ...structuredClone(inputMetadata)
+  };
+  const model = normalizeString(inputMetadata.model) ?? normalizeString(inputMetadata.preferred_model) ?? normalizeString(inputMetadata.preferredModel);
+  if (model) {
+    nextMetadata.model = model;
+    nextMetadata.preferred_model = model;
+  }
+  const thinking = normalizeString(inputMetadata.thinking) ?? normalizeString(inputMetadata.preferred_thinking) ?? normalizeString(inputMetadata.thinking_level) ?? normalizeString(inputMetadata.thinkingLevel);
+  if (thinking) {
+    nextMetadata.thinking = thinking;
+    nextMetadata.preferred_thinking = thinking;
+  }
+  const sessionType = normalizeString(inputMetadata.session_type) ?? normalizeString(inputMetadata.sessionType);
+  if (sessionType) {
+    nextMetadata.session_type = sessionType;
+  }
+  const label = normalizeString(inputMetadata.label) ?? normalizeString(inputMetadata.session_label);
+  if (label) {
+    nextMetadata.label = label;
+  }
+  const requestedSkills = readStringArray(inputMetadata.requested_skills) ?? readStringArray(inputMetadata.requestedSkills);
+  if (requestedSkills) {
+    nextMetadata.requested_skills = requestedSkills;
+  }
+  return nextMetadata;
+}
+function extractMessageMetadata(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    const metadata = cloneMetadata(message.metadata);
+    if (metadata) {
+      return metadata;
+    }
+  }
+  return void 0;
+}
+function ensureIsoTimestamp(value, fallback) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) {
+    return fallback;
+  }
+  return new Date(timestamp).toISOString();
+}
+function serializeToolArgs(args) {
+  if (typeof args === "string") {
+    return args;
+  }
+  return JSON.stringify(args ?? {});
+}
+function serializeLegacyContent(parts) {
+  const text = parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+  if (text.length > 0) {
+    return text;
+  }
+  if (parts.length === 0) {
+    return "";
+  }
+  return structuredClone(parts);
+}
+function extractTextFromNcpMessage(message) {
+  if (!message) {
+    return "";
+  }
+  const normalizedMessage = message.role === "assistant" ? sanitizeAssistantReplyTags(message) : message;
+  return normalizedMessage.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function toLegacyMessages(messages) {
+  const legacyMessages = [];
+  for (const rawMessage of messages) {
+    const message = rawMessage.role === "assistant" ? sanitizeAssistantReplyTags(rawMessage) : rawMessage;
+    const timestamp = ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+    if (message.role === "assistant") {
+      const textContent = extractTextFromNcpMessage(message);
+      const reasoningContent = message.parts.filter((part) => part.type === "reasoning").map((part) => part.text).join("");
+      const toolInvocations = message.parts.filter(
+        (part) => part.type === "tool-invocation"
+      );
+      const assistantMessage = {
+        role: "assistant",
+        content: textContent,
+        timestamp,
+        ncp_message_id: message.id,
+        ncp_parts: structuredClone(message.parts)
+      };
+      if (typeof message.metadata?.reply_to === "string" && message.metadata.reply_to.trim().length > 0) {
+        assistantMessage.reply_to = message.metadata.reply_to.trim();
+      }
+      if (reasoningContent.length > 0) {
+        assistantMessage.reasoning_content = reasoningContent;
+      }
+      if (toolInvocations.length > 0) {
+        assistantMessage.tool_calls = toolInvocations.map((toolInvocation, index) => ({
+          id: toolInvocation.toolCallId ?? `${message.id}:tool:${index}`,
+          type: "function",
+          function: {
+            name: toolInvocation.toolName,
+            arguments: serializeToolArgs(toolInvocation.args)
+          }
+        }));
+      }
+      legacyMessages.push(assistantMessage);
+      for (const toolInvocation of toolInvocations) {
+        if (toolInvocation.state !== "result") {
+          continue;
+        }
+        legacyMessages.push({
+          role: "tool",
+          name: toolInvocation.toolName,
+          tool_call_id: toolInvocation.toolCallId,
+          content: typeof toolInvocation.result === "string" ? toolInvocation.result : JSON.stringify(toolInvocation.result ?? null),
+          timestamp,
+          ncp_message_id: message.id
+        });
+      }
+      continue;
+    }
+    legacyMessages.push({
+      role: message.role,
+      content: serializeLegacyContent(message.parts),
+      timestamp,
+      ncp_message_id: message.id
+    });
+  }
+  return legacyMessages;
+}
+
+// src/cli/commands/ncp/nextclaw-ncp-tool-registry.ts
+import {
+  CronTool,
+  EditFileTool,
+  ExecTool,
+  ExtensionToolAdapter,
+  GatewayTool,
+  ListDirTool,
+  MemoryGetTool,
+  MemorySearchTool,
+  MessageTool,
+  ReadFileTool,
+  SessionsHistoryTool,
+  SessionsListTool,
+  SessionsSendTool,
+  SpawnTool,
+  SubagentManager,
+  SubagentsTool,
+  ToolRegistry,
+  WebFetchTool,
+  WebSearchTool,
+  WriteFileTool
+} from "@nextclaw/core";
+function toToolParams(args) {
+  if (isRecord3(args)) {
+    return args;
+  }
+  if (typeof args === "string") {
+    try {
+      const parsed = JSON.parse(args);
+      return isRecord3(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function readMetadataAccountId(metadata, sessionMetadata) {
+  const candidates = [
+    metadata.accountId,
+    metadata.account_id,
+    sessionMetadata.last_account_id
+  ];
+  for (const candidate of candidates) {
+    const normalized = normalizeString(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+var CoreToolNcpAdapter = class {
+  constructor(tool, executeTool) {
+    this.tool = tool;
+    this.executeTool = executeTool;
+  }
+  get name() {
+    return this.tool.name;
+  }
+  get description() {
+    return this.tool.description;
+  }
+  get parameters() {
+    return this.tool.parameters;
+  }
+  async execute(args) {
+    return this.executeTool(this.tool.name, args);
+  }
+};
+var NextclawNcpToolRegistry = class {
+  constructor(options) {
+    this.options = options;
+    const initialConfig = this.options.getConfig();
+    this.subagents = new SubagentManager({
+      providerManager: this.options.providerManager,
+      workspace: initialConfig.agents.defaults.workspace,
+      bus: this.options.bus,
+      model: initialConfig.agents.defaults.model,
+      contextTokens: initialConfig.agents.defaults.contextTokens,
+      searchConfig: initialConfig.search,
+      execConfig: initialConfig.tools.exec,
+      restrictToWorkspace: initialConfig.tools.restrictToWorkspace
+    });
+  }
+  subagents;
+  registry = new ToolRegistry();
+  tools = /* @__PURE__ */ new Map();
+  currentExtensionToolContext = {};
+  prepareForRun(context) {
+    this.subagents.updateRuntimeOptions({
+      model: context.model,
+      maxTokens: context.maxTokens,
+      contextTokens: context.contextTokens,
+      searchConfig: context.searchConfig,
+      execConfig: { timeout: context.execTimeoutSeconds },
+      restrictToWorkspace: context.restrictToWorkspace
+    });
+    this.currentExtensionToolContext = {
+      config: context.config,
+      workspaceDir: context.workspace,
+      sessionKey: context.sessionId,
+      channel: context.channel,
+      chatId: context.chatId,
+      sandboxed: context.restrictToWorkspace
+    };
+    this.registry = new ToolRegistry();
+    this.tools.clear();
+    this.registerDefaultTools(context);
+    this.registerExtensionTools(context);
+  }
+  listTools() {
+    return [...this.tools.values()];
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getToolDefinitions() {
+    return this.listTools().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }));
+  }
+  async execute(toolCallId, toolName, args) {
+    return this.registry.execute(toolName, toToolParams(args), toolCallId);
+  }
+  registerDefaultTools(context) {
+    const allowedDir = context.restrictToWorkspace ? context.workspace : void 0;
+    this.registerTool(new ReadFileTool(allowedDir));
+    this.registerTool(new WriteFileTool(allowedDir));
+    this.registerTool(new EditFileTool(allowedDir));
+    this.registerTool(new ListDirTool(allowedDir));
+    const execTool = new ExecTool({
+      workingDir: context.workspace,
+      timeout: context.execTimeoutSeconds,
+      restrictToWorkspace: context.restrictToWorkspace
+    });
+    execTool.setContext({
+      sessionKey: context.sessionId,
+      channel: context.channel,
+      chatId: context.chatId
+    });
+    this.registerTool(execTool);
+    this.registerTool(new WebSearchTool(context.searchConfig));
+    this.registerTool(new WebFetchTool());
+    const messageTool = new MessageTool((message) => this.options.bus.publishOutbound(message));
+    messageTool.setContext(context.channel, context.chatId);
+    this.registerTool(messageTool);
+    const spawnTool = new SpawnTool(this.subagents);
+    spawnTool.setContext(
+      context.channel,
+      context.chatId,
+      context.model,
+      context.sessionId,
+      context.agentId
+    );
+    this.registerTool(spawnTool);
+    this.registerTool(new SessionsListTool(this.options.sessionManager));
+    this.registerTool(new SessionsHistoryTool(this.options.sessionManager));
+    const sessionsSendTool = new SessionsSendTool(this.options.sessionManager, this.options.bus);
+    sessionsSendTool.setContext({
+      currentSessionKey: context.sessionId,
+      currentAgentId: context.agentId,
+      channel: context.channel,
+      chatId: context.chatId,
+      maxPingPongTurns: context.config.session?.agentToAgent?.maxPingPongTurns ?? 0,
+      currentHandoffDepth: context.handoffDepth
+    });
+    this.registerTool(sessionsSendTool);
+    this.registerTool(new MemorySearchTool(context.workspace));
+    this.registerTool(new MemoryGetTool(context.workspace));
+    this.registerTool(new SubagentsTool(this.subagents));
+    const gatewayTool = new GatewayTool(this.options.gatewayController);
+    gatewayTool.setContext({ sessionKey: context.sessionId });
+    this.registerTool(gatewayTool);
+    if (this.options.cronService) {
+      const cronTool = new CronTool(this.options.cronService);
+      cronTool.setContext(context.channel, context.chatId);
+      this.registerTool(cronTool);
+    }
+  }
+  registerExtensionTools(context) {
+    const extensionRegistry = this.options.getExtensionRegistry?.();
+    if (!extensionRegistry || extensionRegistry.tools.length === 0) {
+      return;
+    }
+    const seen = new Set(this.registry.toolNames);
+    for (const registration of extensionRegistry.tools) {
+      for (const alias of registration.names) {
+        if (seen.has(alias)) {
+          continue;
+        }
+        seen.add(alias);
+        this.registerTool(
+          new ExtensionToolAdapter({
+            registration,
+            alias,
+            config: context.config,
+            workspaceDir: context.workspace,
+            contextProvider: () => this.currentExtensionToolContext,
+            diagnostics: extensionRegistry.diagnostics
+          })
+        );
+      }
+    }
+  }
+  registerTool(tool) {
+    this.registry.register(tool);
+    this.tools.set(
+      tool.name,
+      new CoreToolNcpAdapter(tool, async (toolName, args) => this.registry.execute(toolName, toToolParams(args)))
+    );
+  }
+};
+function resolveAgentHandoffDepth(metadata) {
+  const rawDepth = Number(metadata.agent_handoff_depth ?? 0);
+  if (!Number.isFinite(rawDepth) || rawDepth < 0) {
+    return 0;
+  }
+  return Math.trunc(rawDepth);
+}
+function readAccountIdForHints(metadata, sessionMetadata) {
+  return readMetadataAccountId(metadata, sessionMetadata);
+}
+
+// src/cli/commands/ncp/nextclaw-ncp-context-builder.ts
+var TIME_HINT_TRIGGER_PATTERNS = [
+  /\b(now|right now|current time|what time|today|tonight|tomorrow|yesterday|this morning|this afternoon|this evening|date)\b/i,
+  /(现在|此刻|当前时间|现在几点|几点了|今天|今晚|今早|今晨|明天|昨天|日期)/
+];
+function isRecord4(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeInputMetadata(input) {
+  const messageMetadata = input.messages.slice().reverse().find((message) => isRecord4(message.metadata))?.metadata;
+  return {
+    ...isRecord4(messageMetadata) ? structuredClone(messageMetadata) : {},
+    ...isRecord4(input.metadata) ? structuredClone(input.metadata) : {}
+  };
+}
+function resolveRequestedSkillNames(metadata) {
+  const rawValue = metadata.requested_skills ?? metadata.requestedSkills;
+  const values = [];
+  if (Array.isArray(rawValue)) {
+    for (const item of rawValue) {
+      const normalized = normalizeString(item);
+      if (normalized) {
+        values.push(normalized);
+      }
+    }
+  } else if (typeof rawValue === "string") {
+    values.push(
+      ...rawValue.split(/[,\s]+/g).map((item) => item.trim()).filter(Boolean)
+    );
+  }
+  return Array.from(new Set(values)).slice(0, 8);
+}
+function resolveRequestedToolNames(metadata) {
+  const rawValue = metadata.requested_tools ?? metadata.requestedTools;
+  if (!Array.isArray(rawValue)) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      rawValue.map((item) => normalizeString(item)).filter((item) => Boolean(item))
+    )
+  );
+}
+function normalizeOptionalString2(value) {
+  return normalizeString(value) ?? void 0;
+}
+function readMetadataModel(metadata) {
+  const candidates = [metadata.model, metadata.llm_model, metadata.agent_model, metadata.session_model];
+  for (const candidate of candidates) {
+    const normalized = normalizeString(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return null;
+}
+function readMetadataThinking(metadata) {
+  const candidates = [
+    metadata.thinking,
+    metadata.thinking_level,
+    metadata.thinkingLevel,
+    metadata.thinking_effort,
+    metadata.thinkingEffort
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string") {
+      continue;
+    }
+    const normalized = candidate.trim().toLowerCase();
+    if (!normalized) {
+      continue;
+    }
+    if (normalized === "clear" || normalized === "reset" || normalized === "off!") {
+      return "__clear__";
+    }
+    const level = parseThinkingLevel(normalized);
+    if (level) {
+      return level;
+    }
+  }
+  return null;
+}
+function resolvePrimaryAgentProfile(config2) {
+  const configuredDefaultAgentId = config2.agents.list.find((entry) => entry.default)?.id?.trim() || config2.agents.list[0]?.id?.trim() || "main";
+  const profile = config2.agents.list.find((entry) => entry.id.trim() === configuredDefaultAgentId);
+  return {
+    agentId: configuredDefaultAgentId,
+    workspace: getWorkspacePath7(profile?.workspace ?? config2.agents.defaults.workspace),
+    model: profile?.model ?? config2.agents.defaults.model,
+    maxIterations: profile?.maxToolIterations ?? config2.agents.defaults.maxToolIterations,
+    contextTokens: profile?.contextTokens ?? config2.agents.defaults.contextTokens,
+    restrictToWorkspace: config2.tools.restrictToWorkspace,
+    searchConfig: config2.search,
+    execTimeoutSeconds: config2.tools.exec.timeout
+  };
+}
+function shouldAppendTimeHint(content) {
+  const normalized = content.trim();
+  if (!normalized) {
+    return false;
+  }
+  return TIME_HINT_TRIGGER_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function buildMinutePrecisionTimeHint(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absMinutes = Math.abs(offsetMinutes);
+  const offsetHour = String(Math.floor(absMinutes / 60)).padStart(2, "0");
+  const offsetMinute = String(absMinutes % 60).padStart(2, "0");
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "local";
+  return `${year}-${month}-${day} ${hour}:${minute} ${sign}${offsetHour}:${offsetMinute} (${timezone})`;
+}
+function appendTimeHintForPrompt(content, timestamp) {
+  if (!shouldAppendTimeHint(content)) {
+    return content;
+  }
+  const date = Number.isNaN(timestamp.getTime()) ? /* @__PURE__ */ new Date() : timestamp;
+  return `${content}
+
+[time_hint_local_minute] ${buildMinutePrecisionTimeHint(date)}`;
+}
+function prependRequestedSkills(content, requestedSkillNames) {
+  if (requestedSkillNames.length === 0) {
+    return content;
+  }
+  return `[Requested skills for this turn: ${requestedSkillNames.join(", ")}]
+
+${content}`;
+}
+function filterTools(toolDefinitions, requestedToolNames) {
+  if (toolDefinitions.length === 0) {
+    return void 0;
+  }
+  if (requestedToolNames.length === 0) {
+    return [...toolDefinitions];
+  }
+  const requested = new Set(requestedToolNames);
+  const filtered = toolDefinitions.filter((tool) => requested.has(tool.function.name));
+  return filtered.length > 0 ? filtered : void 0;
+}
+var NextclawNcpContextBuilder = class {
+  constructor(options) {
+    this.options = options;
+  }
+  inputBudgetPruner = new InputBudgetPruner();
+  prepare(input, _options) {
+    const config2 = this.options.getConfig();
+    const profile = resolvePrimaryAgentProfile(config2);
+    const requestMetadata = mergeInputMetadata(input);
+    const session = this.options.sessionManager.getOrCreate(input.sessionId);
+    const clearModel = requestMetadata.clear_model === true || requestMetadata.reset_model === true;
+    if (clearModel) {
+      delete session.metadata.preferred_model;
+    }
+    const inboundModel = readMetadataModel(requestMetadata);
+    if (inboundModel) {
+      session.metadata.preferred_model = inboundModel;
+    }
+    const effectiveModel = normalizeOptionalString2(session.metadata.preferred_model) ?? profile.model;
+    const clearThinking = requestMetadata.clear_thinking === true || requestMetadata.reset_thinking === true;
+    if (clearThinking) {
+      delete session.metadata.preferred_thinking;
+    }
+    const inboundThinking = readMetadataThinking(requestMetadata);
+    if (inboundThinking === "__clear__") {
+      delete session.metadata.preferred_thinking;
+    } else if (inboundThinking) {
+      session.metadata.preferred_thinking = inboundThinking;
+    }
+    const runtimeThinking = resolveThinkingLevel({
+      config: config2,
+      agentId: profile.agentId,
+      model: effectiveModel,
+      sessionThinkingLevel: parseThinkingLevel(session.metadata.preferred_thinking) ?? null
+    });
+    const channel = normalizeOptionalString2(requestMetadata.channel) ?? normalizeOptionalString2(session.metadata.last_channel) ?? "ui";
+    const chatId = normalizeOptionalString2(requestMetadata.chatId) ?? normalizeOptionalString2(requestMetadata.chat_id) ?? normalizeOptionalString2(session.metadata.last_to) ?? "web-ui";
+    session.metadata.last_channel = channel;
+    session.metadata.last_to = chatId;
+    const requestedSkillNames = resolveRequestedSkillNames(requestMetadata);
+    const requestedToolNames = resolveRequestedToolNames(requestMetadata);
+    const currentUserText = extractTextFromNcpMessage(input.messages[input.messages.length - 1]);
+    const currentMessage = appendTimeHintForPrompt(
+      prependRequestedSkills(currentUserText, requestedSkillNames),
+      new Date(
+        ensureIsoTimestamp(
+          input.messages[input.messages.length - 1]?.timestamp,
+          (/* @__PURE__ */ new Date()).toISOString()
+        )
+      )
+    );
+    this.options.toolRegistry.prepareForRun({
+      sessionId: input.sessionId,
+      channel,
+      chatId,
+      agentId: profile.agentId,
+      config: config2,
+      contextTokens: profile.contextTokens,
+      execTimeoutSeconds: profile.execTimeoutSeconds,
+      handoffDepth: resolveAgentHandoffDepth(requestMetadata),
+      maxTokens: void 0,
+      metadata: requestMetadata,
+      model: effectiveModel,
+      restrictToWorkspace: profile.restrictToWorkspace,
+      searchConfig: profile.searchConfig,
+      workspace: profile.workspace
+    });
+    const accountId = readAccountIdForHints(requestMetadata, session.metadata);
+    const messageToolHints = this.options.resolveMessageToolHints?.({
+      sessionKey: input.sessionId,
+      channel,
+      chatId,
+      accountId: accountId ?? null
+    });
+    const contextBuilder = new ContextBuilder(profile.workspace, config2.agents.context);
+    const sessionMessages = _options?.sessionMessages ?? [];
+    const messages = contextBuilder.buildMessages({
+      history: toLegacyMessages([...sessionMessages]),
+      currentMessage,
+      channel,
+      chatId,
+      sessionKey: input.sessionId,
+      thinkingLevel: runtimeThinking,
+      skillNames: requestedSkillNames,
+      messageToolHints
+    });
+    const pruned = this.inputBudgetPruner.prune({
+      messages,
+      contextTokens: profile.contextTokens
+    });
+    const toolDefinitions = this.options.toolRegistry.getToolDefinitions().map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }));
+    return {
+      messages: pruned.messages,
+      tools: filterTools(toolDefinitions, requestedToolNames),
+      model: effectiveModel,
+      thinkingLevel: runtimeThinking
+    };
+  }
+};
+
+// src/cli/commands/ncp/nextclaw-agent-session-store.ts
+import { sanitizeAssistantReplyTags as sanitizeAssistantReplyTags2 } from "@nextclaw/ncp";
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function toTextPart(text) {
+  return text.length > 0 ? { type: "text", text } : null;
+}
+function contentToParts(content) {
+  if (typeof content === "string") {
+    const textPart = toTextPart(content);
+    return textPart ? [textPart] : [];
+  }
+  if (Array.isArray(content)) {
+    return content.length > 0 ? [
+      {
+        type: "extension",
+        extensionType: "nextclaw.legacy.content-array",
+        data: structuredClone(content)
+      }
+    ] : [];
+  }
+  if (content && typeof content === "object") {
+    return [
+      {
+        type: "extension",
+        extensionType: "nextclaw.legacy.content-object",
+        data: structuredClone(content)
+      }
+    ];
+  }
+  return [];
+}
+function parseLegacyToolCalls(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      return null;
+    }
+    const toolCall = entry;
+    const id = normalizeString(toolCall.id);
+    const rawFunction = toolCall.function;
+    if (!id || !rawFunction || typeof rawFunction !== "object" || Array.isArray(rawFunction)) {
+      return null;
+    }
+    const fn = rawFunction;
+    const name = normalizeString(fn.name);
+    const args = typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments ?? {});
+    if (!name) {
+      return null;
+    }
+    return {
+      id,
+      type: "function",
+      function: {
+        name,
+        arguments: args
+      }
+    };
+  }).filter((entry) => entry !== null);
+}
+function createMessageId(sessionId, index, role, timestamp) {
+  const safeRole = role.trim().toLowerCase() || "message";
+  return `${sessionId}:${safeRole}:${index}:${timestamp}`;
+}
+function isNcpMessagePart(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && typeof value.type === "string";
+}
+function readStoredNcpParts(message) {
+  const rawParts = message.ncp_parts;
+  if (!Array.isArray(rawParts)) {
+    return null;
+  }
+  const parts = rawParts.filter((part) => isNcpMessagePart(part));
+  if (parts.length !== rawParts.length) {
+    return null;
+  }
+  return structuredClone(parts);
+}
+function buildAssistantMessage(params) {
+  const timestamp = ensureIsoTimestamp(params.message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+  const replyTo = typeof params.message.reply_to === "string" && params.message.reply_to.trim().length > 0 ? params.message.reply_to.trim() : void 0;
+  const storedParts = readStoredNcpParts(params.message);
+  if (storedParts) {
+    return sanitizeAssistantReplyTags2({
+      id: createMessageId(params.sessionId, params.index, "assistant", timestamp),
+      sessionId: params.sessionId,
+      role: "assistant",
+      status: "final",
+      timestamp,
+      parts: storedParts,
+      metadata: replyTo ? { reply_to: replyTo } : void 0
+    });
+  }
+  const toolCalls = parseLegacyToolCalls(params.message.tool_calls);
+  const parts = [...contentToParts(params.message.content)];
+  const reasoning = normalizeString(params.message.reasoning_content);
+  if (reasoning) {
+    parts.push({
+      type: "reasoning",
+      text: reasoning
+    });
+  }
+  for (const toolCall of toolCalls) {
+    parts.push({
+      type: "tool-invocation",
+      toolCallId: toolCall.id,
+      toolName: toolCall.function.name,
+      state: "call",
+      args: tryParseJson(toolCall.function.arguments)
+    });
+  }
+  return sanitizeAssistantReplyTags2({
+    id: createMessageId(params.sessionId, params.index, "assistant", timestamp),
+    sessionId: params.sessionId,
+    role: "assistant",
+    status: "final",
+    timestamp,
+    parts,
+    metadata: replyTo ? { reply_to: replyTo } : void 0
+  });
+}
+function buildGenericMessage(params) {
+  const timestamp = ensureIsoTimestamp(params.message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+  return {
+    id: createMessageId(params.sessionId, params.index, params.role, timestamp),
+    sessionId: params.sessionId,
+    role: params.role,
+    status: "final",
+    timestamp,
+    parts: contentToParts(params.message.content)
+  };
+}
+function attachToolResult(target, toolCallId, result, toolName) {
+  target.parts = target.parts.map((part) => {
+    if (part.type !== "tool-invocation" || part.toolCallId !== toolCallId) {
+      return part;
+    }
+    return {
+      ...part,
+      toolName: toolName ?? part.toolName,
+      state: "result",
+      result
+    };
+  });
+}
+function toNcpMessages(sessionId, messages) {
+  const ncpMessages = [];
+  const assistantIndexByToolCallId = /* @__PURE__ */ new Map();
+  messages.forEach((message, index) => {
+    const role = normalizeString(message.role)?.toLowerCase() ?? "assistant";
+    if (role === "tool") {
+      const toolCallId = normalizeString(message.tool_call_id);
+      if (toolCallId) {
+        const assistantIndex = assistantIndexByToolCallId.get(toolCallId);
+        if (assistantIndex !== void 0) {
+          attachToolResult(
+            ncpMessages[assistantIndex],
+            toolCallId,
+            structuredClone(message.content),
+            normalizeString(message.name) ?? void 0
+          );
+          return;
+        }
+      }
+      ncpMessages.push(
+        buildGenericMessage({
+          sessionId,
+          index,
+          role: "tool",
+          message
+        })
+      );
+      return;
+    }
+    if (role === "assistant") {
+      const assistant = buildAssistantMessage({ sessionId, index, message });
+      const assistantPosition = ncpMessages.push(assistant) - 1;
+      for (const part of assistant.parts) {
+        if (part.type === "tool-invocation" && part.toolCallId) {
+          assistantIndexByToolCallId.set(part.toolCallId, assistantPosition);
+        }
+      }
+      return;
+    }
+    const normalizedRole = role === "system" || role === "user" || role === "service" ? role : "user";
+    ncpMessages.push(
+      buildGenericMessage({
+        sessionId,
+        index,
+        role: normalizedRole,
+        message
+      })
+    );
+  });
+  return ncpMessages;
+}
+function resolveLegacyEventType(message) {
+  const role = normalizeString(message.role)?.toLowerCase() ?? "";
+  if (role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+    return "assistant.tool_call";
+  }
+  if (role === "tool") {
+    return "tool.result";
+  }
+  if (role === "assistant") {
+    return "message.assistant";
+  }
+  if (role === "user") {
+    return "message.user";
+  }
+  if (role === "system") {
+    return "message.system";
+  }
+  return `message.${role || "other"}`;
+}
+var NextclawAgentSessionStore = class {
+  constructor(sessionManager, options = {}) {
+    this.sessionManager = sessionManager;
+    this.options = options;
+  }
+  async getSession(sessionId) {
+    const session = this.sessionManager.getIfExists(sessionId);
+    if (!session) {
+      return null;
+    }
+    return {
+      sessionId,
+      messages: toNcpMessages(sessionId, session.messages),
+      updatedAt: session.updatedAt.toISOString(),
+      metadata: structuredClone(session.metadata)
+    };
+  }
+  async listSessions() {
+    const records = this.sessionManager.listSessions();
+    const sessions = [];
+    for (const record of records) {
+      const sessionId = normalizeString(record.key);
+      if (!sessionId) {
+        continue;
+      }
+      const session = this.sessionManager.getIfExists(sessionId);
+      if (!session) {
+        continue;
+      }
+      sessions.push({
+        sessionId,
+        messages: toNcpMessages(sessionId, session.messages),
+        updatedAt: session.updatedAt.toISOString(),
+        metadata: structuredClone(session.metadata)
+      });
+    }
+    sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    return sessions;
+  }
+  async saveSession(sessionRecord) {
+    if (this.options.writeMode === "runtime-owned") {
+      return;
+    }
+    const session = this.sessionManager.getIfExists(sessionRecord.sessionId) ?? this.sessionManager.getOrCreate(sessionRecord.sessionId);
+    const legacyMessages = toLegacyMessages(sessionRecord.messages);
+    const nextMetadata = mergeSessionMetadata(
+      session.metadata,
+      extractMessageMetadata(sessionRecord.messages)
+    );
+    session.metadata = mergeSessionMetadata(nextMetadata, cloneMetadata(sessionRecord.metadata));
+    this.sessionManager.clear(session);
+    for (const message of legacyMessages) {
+      this.sessionManager.appendEvent(session, {
+        type: resolveLegacyEventType(message),
+        timestamp: ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString()),
+        data: {
+          message
+        }
+      });
+    }
+    if (legacyMessages.length === 0) {
+      session.updatedAt = new Date(ensureIsoTimestamp(sessionRecord.updatedAt, (/* @__PURE__ */ new Date()).toISOString()));
+    }
+    this.sessionManager.save(session);
+  }
+  async deleteSession(sessionId) {
+    const existing = await this.getSession(sessionId);
+    if (!existing) {
+      return null;
+    }
+    this.sessionManager.delete(sessionId);
+    return existing;
+  }
+};
+
+// src/cli/commands/ncp/provider-manager-ncp-llm-api.ts
+import { parseThinkingLevel as parseThinkingLevel2 } from "@nextclaw/core";
+function normalizeModel(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeThinkingLevel(value) {
+  return parseThinkingLevel2(value);
+}
+function normalizeFinishReason(value) {
+  if (typeof value !== "string") {
+    return "stop";
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : "stop";
+}
+function toToolCallDelta(toolCall, index) {
+  return {
+    index,
+    id: toolCall.id,
+    type: "function",
+    function: {
+      name: toolCall.name,
+      arguments: JSON.stringify(toolCall.arguments ?? {})
+    }
+  };
+}
+function toFinalChunk(response, options) {
+  const delta = {};
+  if (options.includeText && typeof response.content === "string" && response.content.length > 0) {
+    delta.content = response.content;
+  }
+  if (options.includeReasoning && typeof response.reasoningContent === "string" && response.reasoningContent.length > 0) {
+    delta.reasoning_content = response.reasoningContent;
+  }
+  if (options.includeToolCalls && response.toolCalls.length > 0) {
+    delta.tool_calls = response.toolCalls.map((toolCall, index) => toToolCallDelta(toolCall, index));
+  }
+  return {
+    choices: [
+      {
+        delta,
+        finish_reason: normalizeFinishReason(response.finishReason)
+      }
+    ],
+    usage: response.usage
+  };
+}
+var ProviderManagerNcpLLMApi = class {
+  constructor(providerManager) {
+    this.providerManager = providerManager;
+  }
+  async *generate(input, options) {
+    const model = normalizeModel(input.model) ?? this.providerManager.get(null).getDefaultModel();
+    const thinkingLevel = normalizeThinkingLevel(input.thinkingLevel);
+    let sawTextDelta = false;
+    let sawReasoningDelta = false;
+    let sawToolCallDelta = false;
+    for await (const event of this.providerManager.chatStream({
+      messages: input.messages,
+      tools: input.tools,
+      model,
+      ...thinkingLevel ? { thinkingLevel } : {},
+      maxTokens: input.max_tokens,
+      signal: options?.signal
+    })) {
+      if (event.type === "delta") {
+        sawTextDelta = true;
+        yield {
+          choices: [
+            {
+              delta: {
+                content: event.delta
+              }
+            }
+          ]
+        };
+        continue;
+      }
+      if (event.type === "reasoning_delta") {
+        sawReasoningDelta = true;
+        yield {
+          choices: [
+            {
+              delta: {
+                reasoning_content: event.delta
+              }
+            }
+          ]
+        };
+        continue;
+      }
+      if (event.type === "tool_call_delta") {
+        sawToolCallDelta = true;
+        yield {
+          choices: [
+            {
+              delta: {
+                tool_calls: event.toolCalls
+              }
+            }
+          ]
+        };
+        continue;
+      }
+      yield toFinalChunk(event.response, {
+        includeText: !sawTextDelta,
+        includeReasoning: !sawReasoningDelta,
+        includeToolCalls: !sawToolCallDelta
+      });
+    }
   }
 };
-function parseCommandArgsFromText(commandName, rawTail, specs) {
-  if (!rawTail) {
-    return {};
+
+// src/cli/commands/ncp/ui-ncp-runtime-registry.ts
+import { toDisposable } from "@nextclaw/core";
+var DEFAULT_UI_NCP_RUNTIME_KIND = "native";
+function normalizeRuntimeKind(value) {
+  if (typeof value !== "string") {
+    return null;
   }
-  const command = specs.find((item) => item.name.trim().toLowerCase() === commandName);
-  const options = command?.options;
-  if (!options || options.length === 0) {
-    return {};
+  const normalized = value.trim().toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+function readRequestedRuntimeKind(sessionMetadata) {
+  return normalizeRuntimeKind(sessionMetadata.session_type) ?? normalizeRuntimeKind(sessionMetadata.sessionType) ?? null;
+}
+var UiNcpRuntimeRegistry = class {
+  constructor(defaultKind = DEFAULT_UI_NCP_RUNTIME_KIND) {
+    this.defaultKind = defaultKind;
+  }
+  registrations = /* @__PURE__ */ new Map();
+  register(registration) {
+    const normalizedKind = normalizeRuntimeKind(registration.kind);
+    if (!normalizedKind) {
+      throw new Error("ui ncp runtime kind must be a non-empty string");
+    }
+    const token = Symbol(normalizedKind);
+    this.registrations.set(normalizedKind, {
+      ...registration,
+      kind: normalizedKind,
+      token
+    });
+    return toDisposable(() => {
+      const current = this.registrations.get(normalizedKind);
+      if (!current || current.token !== token) {
+        return;
+      }
+      this.registrations.delete(normalizedKind);
+    });
   }
-  const tokens = rawTail.split(/\s+/).filter(Boolean);
-  const args = {};
-  let cursor = 0;
-  for (let i = 0; i < options.length; i += 1) {
-    if (cursor >= tokens.length) {
-      break;
-    }
-    const option = options[i];
-    const isLastOption = i === options.length - 1;
-    const rawValue = isLastOption ? tokens.slice(cursor).join(" ") : tokens[cursor];
-    cursor += isLastOption ? tokens.length - cursor : 1;
-    const parsedValue = parseCommandOptionValue(option.type, rawValue);
-    if (parsedValue !== void 0) {
-      args[option.name] = parsedValue;
+  createRuntime(params) {
+    const requestedKind = readRequestedRuntimeKind(params.sessionMetadata) ?? this.defaultKind;
+    const registration = this.registrations.get(requestedKind);
+    if (!registration) {
+      throw new Error(`ncp runtime unavailable: ${requestedKind}`);
     }
+    const nextSessionMetadata = {
+      ...params.sessionMetadata,
+      session_type: registration.kind
+    };
+    params.setSessionMetadata(nextSessionMetadata);
+    return registration.createRuntime({
+      ...params,
+      sessionMetadata: nextSessionMetadata
+    });
   }
-  return args;
+  listSessionTypes() {
+    const options = [...this.registrations.values()].map((registration) => ({
+      value: registration.kind,
+      label: registration.label
+    })).sort((left, right) => {
+      if (left.value === this.defaultKind) {
+        return -1;
+      }
+      if (right.value === this.defaultKind) {
+        return 1;
+      }
+      return left.value.localeCompare(right.value);
+    });
+    return {
+      defaultType: this.defaultKind,
+      options
+    };
+  }
+};
+
+// src/cli/commands/ncp/create-ui-ncp-agent.ts
+function isRecord5(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function parseCommandOptionValue(type, rawValue) {
-  const value = rawValue.trim();
-  if (!value) {
-    return void 0;
+function resolveNativeReasoningNormalizationMode(params) {
+  const runtimeEntry = params.config.ui.ncp.runtimes.native;
+  const runtimeMetadata = isRecord5(runtimeEntry) ? runtimeEntry : {};
+  return readAssistantReasoningNormalizationModeFromMetadata(params.sessionMetadata) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoningNormalization) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoning_normalization) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoningNormalizationMode) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoning_normalization_mode) ?? "think-tags";
+}
+function buildPluginRuntimeSnapshotKey(extensionRegistry) {
+  const registrations = extensionRegistry?.ncpAgentRuntimes ?? [];
+  return registrations.map((registration) => [
+    registration.pluginId,
+    registration.kind,
+    registration.label,
+    registration.source
+  ].join(":")).join("|");
+}
+async function createUiNcpAgent(params) {
+  const sessionStore = new NextclawAgentSessionStore(params.sessionManager);
+  const runtimeRegistry = new UiNcpRuntimeRegistry();
+  runtimeRegistry.register({
+    kind: "native",
+    label: "Native",
+    createRuntime: ({ stateManager, sessionMetadata, setSessionMetadata }) => {
+      const reasoningNormalizationMode = resolveNativeReasoningNormalizationMode({
+        config: params.getConfig(),
+        sessionMetadata
+      });
+      if (reasoningNormalizationMode !== "off" && readAssistantReasoningNormalizationModeFromMetadata(sessionMetadata) !== reasoningNormalizationMode) {
+        setSessionMetadata(
+          writeAssistantReasoningNormalizationModeToMetadata(
+            sessionMetadata,
+            reasoningNormalizationMode
+          )
+        );
+      }
+      const toolRegistry = new NextclawNcpToolRegistry({
+        bus: params.bus,
+        providerManager: params.providerManager,
+        sessionManager: params.sessionManager,
+        cronService: params.cronService,
+        gatewayController: params.gatewayController,
+        getConfig: params.getConfig,
+        getExtensionRegistry: params.getExtensionRegistry
+      });
+      return new DefaultNcpAgentRuntime({
+        contextBuilder: new NextclawNcpContextBuilder({
+          sessionManager: params.sessionManager,
+          toolRegistry,
+          getConfig: params.getConfig,
+          resolveMessageToolHints: params.resolveMessageToolHints
+        }),
+        llmApi: new ProviderManagerNcpLLMApi(params.providerManager),
+        toolRegistry,
+        stateManager,
+        reasoningNormalizationMode
+      });
+    }
+  });
+  const pluginRuntimeScopes = /* @__PURE__ */ new Map();
+  let pluginRuntimeSnapshotKey = "";
+  let activeExtensionRegistry;
+  const syncPluginRuntimeRegistrations = (extensionRegistry) => {
+    const nextSnapshotKey = buildPluginRuntimeSnapshotKey(extensionRegistry);
+    if (nextSnapshotKey === pluginRuntimeSnapshotKey) {
+      return;
+    }
+    pluginRuntimeSnapshotKey = nextSnapshotKey;
+    for (const scope of pluginRuntimeScopes.values()) {
+      scope.dispose();
+    }
+    pluginRuntimeScopes.clear();
+    for (const registration of extensionRegistry?.ncpAgentRuntimes ?? []) {
+      const pluginId = registration.pluginId.trim() || registration.kind;
+      let scope = pluginRuntimeScopes.get(pluginId);
+      if (!scope) {
+        scope = new DisposableStore();
+        pluginRuntimeScopes.set(pluginId, scope);
+      }
+      scope.add(runtimeRegistry.register({
+        kind: registration.kind,
+        label: registration.label,
+        createRuntime: registration.createRuntime
+      }));
+    }
+  };
+  const resolveActiveExtensionRegistry = () => activeExtensionRegistry ?? params.getExtensionRegistry?.();
+  const refreshPluginRuntimeRegistrations = () => {
+    syncPluginRuntimeRegistrations(resolveActiveExtensionRegistry());
+  };
+  refreshPluginRuntimeRegistrations();
+  const backend = new DefaultNcpAgentBackend({
+    endpointId: "nextclaw-ui-agent",
+    sessionStore,
+    createRuntime: (runtimeParams) => {
+      refreshPluginRuntimeRegistrations();
+      return runtimeRegistry.createRuntime(runtimeParams);
+    }
+  });
+  await backend.start();
+  return {
+    basePath: "/api/ncp/agent",
+    agentClientEndpoint: createAgentClientFromServer(backend),
+    streamProvider: backend,
+    sessionApi: backend,
+    listSessionTypes: () => {
+      refreshPluginRuntimeRegistrations();
+      return runtimeRegistry.listSessionTypes();
+    },
+    applyExtensionRegistry: (extensionRegistry) => {
+      activeExtensionRegistry = extensionRegistry;
+      syncPluginRuntimeRegistrations(extensionRegistry);
+    }
+  };
+}
+
+// src/cli/commands/service-marketplace-helpers.ts
+var containsAbsoluteFsPath = (line) => {
+  const normalized = line.trim();
+  if (!normalized) {
+    return false;
   }
-  if (type === "number") {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : void 0;
+  const lowered = normalized.toLowerCase();
+  if (lowered.includes("http://") || lowered.includes("https://")) {
+    return false;
   }
-  if (type === "boolean") {
-    const lowered = value.toLowerCase();
-    if (["1", "true", "yes", "on"].includes(lowered)) {
-      return true;
+  if (/^[A-Za-z]:\\/.test(normalized)) {
+    return true;
+  }
+  return /(?:^|\s)(?:~\/|\/[^\s]+)/.test(normalized);
+};
+var pickUserFacingCommandSummary = (output, fallback) => {
+  const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) {
+    return fallback;
+  }
+  const visibleLines = lines.filter((line) => {
+    if (/^(path|install path|source path|destination|location)\s*:/i.test(line)) {
+      return false;
     }
-    if (["0", "false", "no", "off"].includes(lowered)) {
+    if (containsAbsoluteFsPath(line)) {
       return false;
     }
-    return void 0;
-  }
-  return value;
-}
-function formatUserFacingError(error, maxChars = 320) {
-  const raw = error instanceof Error ? error.message || error.name || "Unknown error" : String(error ?? "Unknown error");
-  const normalized = raw.replace(/\s+/g, " ").trim();
-  if (!normalized) {
-    return "Unknown error";
+    return true;
+  });
+  if (visibleLines.length === 0) {
+    return fallback;
   }
-  if (normalized.length <= maxChars) {
-    return normalized;
+  const preferred = [...visibleLines].reverse().find(
+    (line) => /\b(installed|enabled|disabled|uninstalled|published|updated|already installed|removed)\b/i.test(line)
+  );
+  return preferred ?? visibleLines[visibleLines.length - 1] ?? fallback;
+};
+var buildMarketplaceSkillInstallArgs = (params) => {
+  const args = ["skills", "install", params.slug, "--workdir", params.workspace];
+  if (params.force) {
+    args.push("--force");
   }
-  return `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
-}
+  return args;
+};
 
 // src/cli/commands/ui-chat-run-coordinator.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
 import {
   getDataDir as getDataDir5,
@@ -3536,7 +5380,7 @@ function createRunId() {
   const rand = Math.random().toString(36).slice(2, 10);
   return `run-${now}-${rand}`;
 }
-function isRecord2(value) {
+function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readOptionalString(value) {
@@ -3726,7 +5570,7 @@ var UiChatRunCoordinator = class {
     const parsedAgentId = parseAgentScopedSessionKey2(sessionKey)?.agentId;
     const agentId = explicitAgentId ?? readOptionalString(parsedAgentId);
     const model = readOptionalString(input.model);
-    const metadata = isRecord2(input.metadata) ? { ...input.metadata } : {};
+    const metadata = isRecord6(input.metadata) ? { ...input.metadata } : {};
     if (model) {
       metadata.model = model;
     }
@@ -3947,14 +5791,14 @@ var UiChatRunCoordinator = class {
     this.emitRunUpdated(run);
   }
   waitForRunUpdate(run, signal) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve13) => {
       const wake = () => {
         cleanup();
-        resolve10();
+        resolve13();
       };
       const onAbort = () => {
         cleanup();
-        resolve10();
+        resolve13();
       };
       const cleanup = () => {
         run.waiters.delete(wake);
@@ -4075,16 +5919,16 @@ var UiChatRunCoordinator = class {
 `);
   }
   loadPersistedRuns() {
-    if (!existsSync7(RUNS_DIR)) {
+    if (!existsSync8(RUNS_DIR)) {
       return;
     }
     for (const entry of readdirSync2(RUNS_DIR, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
         continue;
       }
-      const path = join4(RUNS_DIR, entry.name);
+      const path2 = join4(RUNS_DIR, entry.name);
       try {
-        const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+        const parsed = JSON.parse(readFileSync8(path2, "utf-8"));
         const runId = readOptionalString(parsed.runId);
         const sessionKey = readOptionalString(parsed.sessionKey);
         if (!runId || !sessionKey) {
@@ -4147,10 +5991,10 @@ var {
   getDataDir: getDataDir6,
   getProvider,
   getProviderName,
-  getWorkspacePath: getWorkspacePath5,
+  getWorkspacePath: getWorkspacePath8,
   HeartbeatService,
   LiteLLMProvider,
-  loadConfig: loadConfig6,
+  loadConfig: loadConfig7,
   MessageBus,
   ProviderManager,
   resolveConfigSecrets: resolveConfigSecrets2,
@@ -4165,64 +6009,18 @@ function createSkillsLoader(workspace) {
   }
   return new ctor(workspace);
 }
-function containsAbsoluteFsPath(line) {
-  const normalized = line.trim();
-  if (!normalized) {
-    return false;
-  }
-  const lowered = normalized.toLowerCase();
-  if (lowered.includes("http://") || lowered.includes("https://")) {
-    return false;
-  }
-  if (/^[A-Za-z]:\\/.test(normalized)) {
-    return true;
-  }
-  return /(?:^|\s)(?:~\/|\/[^\s]+)/.test(normalized);
-}
-function pickUserFacingCommandSummary(output, fallback) {
-  const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
-  if (lines.length === 0) {
-    return fallback;
-  }
-  const visibleLines = lines.filter((line) => {
-    if (/^(path|install path|source path|destination|location)\s*:/i.test(line)) {
-      return false;
-    }
-    if (containsAbsoluteFsPath(line)) {
-      return false;
-    }
-    return true;
-  });
-  if (visibleLines.length === 0) {
-    return fallback;
-  }
-  const preferred = [...visibleLines].reverse().find(
-    (line) => /\b(installed|enabled|disabled|uninstalled|published|updated|already installed|removed)\b/i.test(line)
-  );
-  return preferred ?? visibleLines[visibleLines.length - 1] ?? fallback;
-}
-function buildMarketplaceSkillInstallArgs(params) {
-  const args = ["skills", "install", params.slug, "--workdir", params.workspace];
-  if (params.force) {
-    args.push("--force");
-  }
-  return args;
-}
-function resolveCliSubcommandEntry(params) {
-  const argvEntry = params.argvEntry?.trim();
-  if (argvEntry) {
-    return resolve7(argvEntry);
-  }
-  return fileURLToPath2(new URL("../index.js", params.importMetaUrl));
-}
 var ServiceCommands = class {
   constructor(deps) {
     this.deps = deps;
   }
+  applyLiveConfigReload = null;
+  liveUiNcpAgent = null;
   async startGateway(options = {}) {
+    this.applyLiveConfigReload = null;
+    this.liveUiNcpAgent = null;
     const runtimeConfigPath = getConfigPath3();
-    const config2 = resolveConfigSecrets2(loadConfig6(), { configPath: runtimeConfigPath });
-    const workspace = getWorkspacePath5(config2.agents.defaults.workspace);
+    const config2 = resolveConfigSecrets2(loadConfig7(), { configPath: runtimeConfigPath });
+    const workspace = getWorkspacePath8(config2.agents.defaults.workspace);
     let pluginRegistry = loadPluginRegistry(config2, workspace);
     let extensionRegistry = toExtensionRegistry(pluginRegistry);
     logPluginDiagnostics(pluginRegistry);
@@ -4266,7 +6064,7 @@ var ServiceCommands = class {
       sessionManager,
       providerManager,
       makeProvider: (nextConfig) => this.makeProvider(nextConfig, { allowMissing: true }) ?? this.makeMissingProvider(nextConfig),
-      loadConfig: () => resolveConfigSecrets2(loadConfig6(), { configPath: runtimeConfigPath }),
+      loadConfig: () => resolveConfigSecrets2(loadConfig7(), { configPath: runtimeConfigPath }),
       getExtensionChannels: () => extensionRegistry.channels,
       onRestartRequired: (paths) => {
         void this.deps.requestRestart({
@@ -4276,6 +6074,9 @@ var ServiceCommands = class {
         });
       }
     });
+    this.applyLiveConfigReload = async () => {
+      await reloader.applyReloadPlan(resolveConfigSecrets2(loadConfig7(), { configPath: runtimeConfigPath }));
+    };
     const gatewayController = new GatewayControllerImpl({
       reloader,
       cron: cron2,
@@ -4307,38 +6108,42 @@ var ServiceCommands = class {
       resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints({
         registry: pluginRegistry,
         channel,
-        cfg: resolveConfigSecrets2(loadConfig6(), { configPath: runtimeConfigPath }),
+        cfg: resolveConfigSecrets2(loadConfig7(), { configPath: runtimeConfigPath }),
         accountId
       })
     });
     reloader.setApplyAgentRuntimeConfig((nextConfig) => runtimePool.applyRuntimeConfig(nextConfig));
-    reloader.setReloadPlugins(async (nextConfig) => {
-      const nextWorkspace = getWorkspacePath5(nextConfig.agents.defaults.workspace);
-      const nextPluginRegistry = loadPluginRegistry(nextConfig, nextWorkspace);
-      const nextExtensionRegistry = toExtensionRegistry(nextPluginRegistry);
-      logPluginDiagnostics(nextPluginRegistry);
-      await stopPluginChannelGateways(pluginGatewayHandles);
-      const startedPluginGateways = await startPluginChannelGateways({
-        registry: nextPluginRegistry,
-        logger: pluginGatewayLogger
+    reloader.setReloadPlugins(async ({ config: nextConfig, changedPaths }) => {
+      const result = await reloadServicePlugins({
+        nextConfig,
+        changedPaths,
+        pluginRegistry,
+        extensionRegistry,
+        pluginChannelBindings,
+        pluginGatewayHandles,
+        pluginGatewayLogger,
+        logPluginGatewayDiagnostics
       });
-      pluginGatewayHandles = startedPluginGateways.handles;
-      logPluginGatewayDiagnostics(startedPluginGateways.diagnostics);
-      pluginRegistry = nextPluginRegistry;
-      extensionRegistry = nextExtensionRegistry;
-      pluginChannelBindings = getPluginChannelBindings2(nextPluginRegistry);
-      runtimePool.applyExtensionRegistry(nextExtensionRegistry);
+      pluginRegistry = result.pluginRegistry;
+      extensionRegistry = result.extensionRegistry;
+      pluginChannelBindings = result.pluginChannelBindings;
+      pluginGatewayHandles = result.pluginGatewayHandles;
+      runtimePool.applyExtensionRegistry(result.extensionRegistry);
+      this.liveUiNcpAgent?.applyExtensionRegistry?.(result.extensionRegistry);
       runtimePool.applyRuntimeConfig(nextConfig);
-      console.log("Config reload: plugin channel gateways restarted.");
+      if (result.restartChannels) {
+        console.log("Config reload: plugin channel gateways restarted.");
+      }
+      return { restartChannels: result.restartChannels };
     });
-    let pluginChannelBindings = getPluginChannelBindings2(pluginRegistry);
+    let pluginChannelBindings = getPluginChannelBindings3(pluginRegistry);
     setPluginRuntimeBridge({
-      loadConfig: () => toPluginConfigView(resolveConfigSecrets2(loadConfig6(), { configPath: runtimeConfigPath }), pluginChannelBindings),
+      loadConfig: () => toPluginConfigView(resolveConfigSecrets2(loadConfig7(), { configPath: runtimeConfigPath }), pluginChannelBindings),
       writeConfigFile: async (nextConfigView) => {
         if (!nextConfigView || typeof nextConfigView !== "object" || Array.isArray(nextConfigView)) {
           throw new Error("plugin runtime writeConfigFile expects an object config");
         }
-        const current = loadConfig6();
+        const current = loadConfig7();
         const next = mergePluginConfigView(current, nextConfigView, pluginChannelBindings);
         saveConfig5(next);
       },
@@ -4405,19 +6210,36 @@ var ServiceCommands = class {
     } else {
       console.log("Warning: No channels enabled");
     }
-    this.startUiIfEnabled(uiConfig, uiStaticDir, cron2, runtimePool, sessionManager);
+    await this.startUiIfEnabled(
+      uiConfig,
+      uiStaticDir,
+      cron2,
+      runtimePool,
+      sessionManager,
+      providerManager,
+      bus,
+      gatewayController,
+      () => resolveConfigSecrets2(loadConfig7(), { configPath: runtimeConfigPath }),
+      () => extensionRegistry,
+      ({ channel, accountId }) => resolvePluginChannelMessageToolHints({
+        registry: pluginRegistry,
+        channel,
+        cfg: resolveConfigSecrets2(loadConfig7(), { configPath: runtimeConfigPath }),
+        accountId
+      })
+    );
     const cronStatus = cron2.status();
     if (cronStatus.jobs > 0) {
       console.log(`\u2713 Cron: ${cronStatus.jobs} scheduled jobs`);
     }
     console.log("\u2713 Heartbeat: every 30m");
-    const configPath = resolve7(getConfigPath3());
+    const configPath = resolve10(getConfigPath3());
     const watcher = chokidar.watch(configPath, {
       ignoreInitial: true,
       awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
     });
     watcher.on("all", (event, changedPath) => {
-      if (resolve7(changedPath) !== configPath) {
+      if (resolve10(changedPath) !== configPath) {
         return;
       }
       if (event === "add") {
@@ -4435,7 +6257,7 @@ var ServiceCommands = class {
     await cron2.start();
     await heartbeat.start();
     try {
-      const startedPluginGateways = await startPluginChannelGateways({
+      const startedPluginGateways = await startPluginChannelGateways2({
         registry: pluginRegistry,
         logger: pluginGatewayLogger
       });
@@ -4445,7 +6267,9 @@ var ServiceCommands = class {
       await this.wakeFromRestartSentinel({ bus, sessionManager });
       await runtimePool.run();
     } finally {
-      await stopPluginChannelGateways(pluginGatewayHandles);
+      this.applyLiveConfigReload = null;
+      this.liveUiNcpAgent = null;
+      await stopPluginChannelGateways2(pluginGatewayHandles);
       setPluginRuntimeBridge(null);
     }
   }
@@ -4509,7 +6333,7 @@ var ServiceCommands = class {
     if (!sentinel) {
       return;
     }
-    await new Promise((resolve10) => setTimeout(resolve10, 750));
+    await new Promise((resolve13) => setTimeout(resolve13, 750));
     const payload = sentinel.payload;
     const summary = formatRestartSentinelMessage(payload);
     const sentinelSessionKey = this.normalizeOptionalString(payload.sessionKey);
@@ -4555,7 +6379,7 @@ var ServiceCommands = class {
     });
   }
   async runForeground(options) {
-    const config2 = loadConfig6();
+    const config2 = loadConfig7();
     const uiConfig = resolveUiConfig(config2, options.uiOverrides);
     const uiUrl = resolveUiApiBase(uiConfig.host, uiConfig.port);
     if (options.open) {
@@ -4568,7 +6392,7 @@ var ServiceCommands = class {
     });
   }
   async startService(options) {
-    const config2 = loadConfig6();
+    const config2 = loadConfig7();
     const uiConfig = resolveUiConfig(config2, options.uiOverrides);
     const uiUrl = resolveUiApiBase(uiConfig.host, uiConfig.port);
     const apiUrl = `${uiUrl}/api`;
@@ -4616,8 +6440,19 @@ var ServiceCommands = class {
     if (!staticDir) {
       console.log("Warning: UI frontend not found in package assets.");
     }
+    const healthUrl = `${apiUrl}/health`;
+    const portPreflight = await this.checkUiPortPreflight({
+      host: uiConfig.host,
+      port: uiConfig.port,
+      healthUrl
+    });
+    if (!portPreflight.ok) {
+      console.error(`Error: Cannot start ${APP_NAME2} because UI port ${uiConfig.port} is already occupied.`);
+      console.error(portPreflight.message);
+      return;
+    }
     const logPath = resolveServiceLogPath();
-    const logDir = resolve7(logPath, "..");
+    const logDir = resolve10(logPath, "..");
     mkdirSync5(logDir, { recursive: true });
     const logFd = openSync(logPath, "a");
     const readinessTimeoutMs = this.resolveStartupTimeoutMs(options.startupTimeoutMs);
@@ -4645,13 +6480,12 @@ var ServiceCommands = class {
       this.printStartupFailureDiagnostics({
         uiUrl,
         apiUrl,
-        healthUrl: `${apiUrl}/health`,
+        healthUrl,
         logPath,
         lastProbeError: null
       });
       return;
     }
-    const healthUrl = `${apiUrl}/health`;
     this.appendStartupStage(logPath, `health probe started: ${healthUrl} (phase=quick, timeoutMs=${quickPhaseTimeoutMs})`);
     let readiness = await this.waitForBackgroundServiceReady({
       pid: child.pid,
@@ -4766,14 +6600,14 @@ var ServiceCommands = class {
       const probe = await this.probeHealthEndpoint(params.healthUrl);
       if (!probe.healthy) {
         lastProbeError = probe.error;
-        await new Promise((resolve10) => setTimeout(resolve10, 200));
+        await new Promise((resolve13) => setTimeout(resolve13, 200));
         continue;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, 300));
+      await new Promise((resolve13) => setTimeout(resolve13, 300));
       if (isProcessRunning(params.pid)) {
         return { ready: true, lastProbeError: null };
       }
-      await new Promise((resolve10) => setTimeout(resolve10, 200));
+      await new Promise((resolve13) => setTimeout(resolve13, 200));
     }
     return { ready: false, lastProbeError };
   }
@@ -4810,6 +6644,58 @@ var ServiceCommands = class {
     }
     console.error(lines.join("\n"));
   }
+  async checkUiPortPreflight(params) {
+    const availability = await this.checkPortAvailability({
+      host: params.host,
+      port: params.port
+    });
+    if (availability.available) {
+      return { ok: true };
+    }
+    const probe = await this.probeHealthEndpoint(params.healthUrl);
+    const lines = [
+      `Port probe: ${availability.detail}`
+    ];
+    if (probe.healthy) {
+      lines.push(
+        `Health probe: ${params.healthUrl} is already healthy. Another process is already serving this UI/API port.`
+      );
+    } else if (probe.error) {
+      lines.push(`Health probe: ${probe.error}`);
+      lines.push(
+        "The port is occupied by a process that does not answer as a healthy NextClaw HTTP server."
+      );
+    }
+    lines.push(
+      `Fix: free port ${params.port} or start NextClaw with another port via --ui-port <port>.`
+    );
+    lines.push(
+      `Inspect locally with: ss -ltnp | grep ${params.port} || lsof -iTCP:${params.port} -sTCP:LISTEN -n -P`
+    );
+    return {
+      ok: false,
+      message: lines.join("\n")
+    };
+  }
+  async checkPortAvailability(params) {
+    return await new Promise((resolve13) => {
+      const server = createNetServer2();
+      server.once("error", (error) => {
+        resolve13({
+          available: false,
+          detail: `bind failed on ${params.host}:${params.port} (${String(error)})`
+        });
+      });
+      server.listen(params.port, params.host, () => {
+        server.close(() => {
+          resolve13({
+            available: true,
+            detail: `bind ok on ${params.host}:${params.port}`
+          });
+        });
+      });
+    });
+  }
   getHeaderValue(headers, key) {
     const value = headers[key];
     if (typeof value === "string") {
@@ -4838,7 +6724,7 @@ var ServiceCommands = class {
       return { healthy: false, error: "invalid health URL" };
     }
     const requestImpl = parsed.protocol === "https:" ? httpsRequest : httpRequest;
-    return new Promise((resolve10) => {
+    return new Promise((resolve13) => {
       const req = requestImpl(
         {
           protocol: parsed.protocol,
@@ -4874,19 +6760,19 @@ var ServiceCommands = class {
               if (bodySnippet) {
                 details.push(`body=${bodySnippet}`);
               }
-              resolve10({ healthy: false, error: details.join("; ") });
+              resolve13({ healthy: false, error: details.join("; ") });
               return;
             }
             try {
               const payload = JSON.parse(responseText);
               const healthy = payload?.ok === true && payload?.data?.status === "ok";
               if (!healthy) {
-                resolve10({ healthy: false, error: "health payload not ok" });
+                resolve13({ healthy: false, error: "health payload not ok" });
                 return;
               }
-              resolve10({ healthy: true, error: null });
+              resolve13({ healthy: true, error: null });
             } catch {
-              resolve10({ healthy: false, error: "invalid health JSON response" });
+              resolve13({ healthy: false, error: "invalid health JSON response" });
             }
           });
         }
@@ -4895,7 +6781,7 @@ var ServiceCommands = class {
         req.destroy(new Error("probe timeout"));
       });
       req.on("error", (error) => {
-        resolve10({ healthy: false, error: error.message || String(error) });
+        resolve13({ healthy: false, error: error.message || String(error) });
       });
       req.end();
     });
@@ -4945,13 +6831,22 @@ var ServiceCommands = class {
     const publicBase = `http://${publicIp}:${port}`;
     console.log(`Public UI (if firewall/NAT allows): ${publicBase}`);
     console.log(`Public API (if firewall/NAT allows): ${publicBase}/api`);
+    console.log(
+      `Public deploy note: NextClaw serves plain HTTP on ${port}.`
+    );
+    console.log(
+      `For https:// or standard 80/443 access, terminate TLS in Nginx/Caddy and proxy to http://127.0.0.1:${port}.`
+    );
+    console.log(
+      `If a reverse proxy returns 502, verify its upstream is http://127.0.0.1:${port} (not https://, not a stale port, and not a stopped process).`
+    );
   }
   printServiceControlHints() {
     console.log("Service controls:");
     console.log(`  - Check status: ${APP_NAME2} status`);
     console.log(`  - If you need to stop the service, run: ${APP_NAME2} stop`);
   }
-  startUiIfEnabled(uiConfig, uiStaticDir, cronService, runtimePool, sessionManager) {
+  async startUiIfEnabled(uiConfig, uiStaticDir, cronService, runtimePool, sessionManager, providerManager, bus, gatewayController, getConfig, getExtensionRegistry, resolveMessageToolHints) {
     if (!uiConfig.enabled) {
       return;
     }
@@ -4991,13 +6886,7 @@ var ServiceCommands = class {
       if (sessionType === "native") {
         return "Native";
       }
-      if (sessionType === "codex-sdk") {
-        return "Codex";
-      }
-      if (sessionType === "claude-agent-sdk") {
-        return "Claude Code";
-      }
-      return sessionType;
+      return sessionType.trim().split(/[-_]+/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ") || sessionType;
     };
     let publishUiEvent = null;
     runtimePool.setSystemSessionUpdatedHandler(({ sessionKey, message }) => {
@@ -5022,6 +6911,20 @@ var ServiceCommands = class {
         publishUiEvent?.({ type: "run.updated", payload: { run } });
       }
     });
+    const ncpAgent = await createUiNcpAgent({
+      bus,
+      providerManager,
+      sessionManager,
+      cronService,
+      gatewayController,
+      getConfig,
+      getExtensionRegistry,
+      resolveMessageToolHints: ({ channel, accountId }) => resolveMessageToolHints({
+        channel,
+        accountId
+      })
+    });
+    this.liveUiNcpAgent = ncpAgent;
     const uiServer = startUiServer({
       host: uiConfig.host,
       port: uiConfig.port,
@@ -5040,6 +6943,7 @@ var ServiceCommands = class {
           uninstallSkill: (slug) => this.uninstallMarketplaceSkill(slug)
         }
       },
+      ncpAgent,
       chatRuntime: {
         listSessionTypes: async () => {
           const options = runtimePool.listAvailableEngineKinds().map((value) => ({
@@ -5119,9 +7023,9 @@ var ServiceCommands = class {
     }
   }
   async installMarketplacePlugin(spec) {
-    const output = await this.runCliSubcommand(["plugins", "install", spec]);
-    const summary = pickUserFacingCommandSummary(output, `Installed plugin: ${spec}`);
-    return { message: summary };
+    const result = await installPluginMutation(spec);
+    await this.applyLiveConfigReload?.();
+    return { message: result.message };
   }
   async installMarketplaceSkill(params) {
     if (params.kind === "builtin") {
@@ -5134,7 +7038,7 @@ var ServiceCommands = class {
     if (params.kind && params.kind !== "marketplace") {
       throw new Error(`Unsupported marketplace skill kind: ${params.kind}`);
     }
-    const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
+    const workspace = getWorkspacePath8(loadConfig7().agents.defaults.workspace);
     const args = buildMarketplaceSkillInstallArgs({
       slug: params.slug,
       workspace,
@@ -5153,24 +7057,26 @@ var ServiceCommands = class {
     }
   }
   async enableMarketplacePlugin(id) {
-    const output = await this.runCliSubcommand(["plugins", "enable", id]);
-    const summary = pickUserFacingCommandSummary(output, `Enabled plugin: ${id}`);
-    return { message: summary };
+    const result = await enablePluginMutation(id);
+    await this.applyLiveConfigReload?.();
+    return { message: result.message };
   }
   async disableMarketplacePlugin(id) {
-    const output = await this.runCliSubcommand(["plugins", "disable", id]);
-    const summary = pickUserFacingCommandSummary(output, `Disabled plugin: ${id}`);
-    return { message: summary };
+    const result = await disablePluginMutation(id);
+    await this.applyLiveConfigReload?.();
+    return { message: result.message };
   }
   async uninstallMarketplacePlugin(id) {
-    const output = await this.runCliSubcommand(["plugins", "uninstall", id, "--force"]);
-    const summary = pickUserFacingCommandSummary(output, `Uninstalled plugin: ${id}`);
-    return { message: summary };
+    await disablePluginMutation(id);
+    await this.applyLiveConfigReload?.();
+    const result = await uninstallPluginMutation(id, { force: true });
+    await this.applyLiveConfigReload?.();
+    return { message: result.message };
   }
   async uninstallMarketplaceSkill(slug) {
-    const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
+    const workspace = getWorkspacePath8(loadConfig7().agents.defaults.workspace);
     const targetDir = join5(workspace, "skills", slug);
-    if (!existsSync8(targetDir)) {
+    if (!existsSync9(targetDir)) {
       throw new Error(`Skill not installed in workspace: ${slug}`);
     }
     rmSync4(targetDir, { recursive: true, force: true });
@@ -5179,10 +7085,10 @@ var ServiceCommands = class {
     };
   }
   installBuiltinMarketplaceSkill(slug, force) {
-    const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
+    const workspace = getWorkspacePath8(loadConfig7().agents.defaults.workspace);
     const destination = join5(workspace, "skills", slug);
     const destinationSkillFile = join5(destination, "SKILL.md");
-    if (existsSync8(destinationSkillFile) && !force) {
+    if (existsSync9(destinationSkillFile) && !force) {
       return {
         message: `${slug} is already installed`
       };
@@ -5190,7 +7096,7 @@ var ServiceCommands = class {
     const loader = createSkillsLoader(workspace);
     const builtin = (loader?.listSkills(false) ?? []).find((skill) => skill.name === slug && skill.source === "builtin");
     if (!builtin) {
-      if (existsSync8(destinationSkillFile)) {
+      if (existsSync9(destinationSkillFile)) {
         return {
           message: `${slug} is already installed`
         };
@@ -5257,9 +7163,9 @@ ${stderr}`.trim();
 };
 
 // src/cli/workspace.ts
-import { cpSync as cpSync3, existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8, readdirSync as readdirSync3, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
-import { createRequire } from "module";
-import { dirname as dirname3, join as join6, resolve as resolve8 } from "path";
+import { cpSync as cpSync3, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync9, readdirSync as readdirSync3, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname3, join as join6, resolve as resolve11 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { APP_NAME as APP_NAME3, getDataDir as getDataDir7 } from "@nextclaw/core";
 import { spawnSync as spawnSync3 } from "child_process";
@@ -5290,27 +7196,27 @@ var WorkspaceManager = class {
     ];
     for (const entry of templateFiles) {
       const filePath = join6(workspace, entry.target);
-      if (!force && existsSync9(filePath)) {
+      if (!force && existsSync10(filePath)) {
         continue;
       }
       const templatePath = join6(templateDir, entry.source);
-      if (!existsSync9(templatePath)) {
+      if (!existsSync10(templatePath)) {
         console.warn(`Warning: Template file missing: ${templatePath}`);
         continue;
       }
-      const raw = readFileSync8(templatePath, "utf-8");
+      const raw = readFileSync9(templatePath, "utf-8");
       const content = raw.replace(/\$\{APP_NAME\}/g, APP_NAME3);
       mkdirSync6(dirname3(filePath), { recursive: true });
       writeFileSync5(filePath, content);
       created.push(entry.target);
     }
     const memoryDir = join6(workspace, "memory");
-    if (!existsSync9(memoryDir)) {
+    if (!existsSync10(memoryDir)) {
       mkdirSync6(memoryDir, { recursive: true });
       created.push(join6("memory", ""));
     }
     const skillsDir = join6(workspace, "skills");
-    if (!existsSync9(skillsDir)) {
+    if (!existsSync10(skillsDir)) {
       mkdirSync6(skillsDir, { recursive: true });
       created.push(join6("skills", ""));
     }
@@ -5332,11 +7238,11 @@ var WorkspaceManager = class {
         continue;
       }
       const src = join6(sourceDir, entry.name);
-      if (!existsSync9(join6(src, "SKILL.md"))) {
+      if (!existsSync10(join6(src, "SKILL.md"))) {
         continue;
       }
       const dest = join6(targetDir, entry.name);
-      if (!force && existsSync9(dest)) {
+      if (!force && existsSync10(dest)) {
         continue;
       }
       try {
@@ -5351,15 +7257,15 @@ var WorkspaceManager = class {
   }
   resolveBuiltinSkillsDir() {
     try {
-      const require2 = createRequire(import.meta.url);
-      const entry = require2.resolve("@nextclaw/core");
-      const pkgRoot = resolve8(dirname3(entry), "..");
+      const require3 = createRequire2(import.meta.url);
+      const entry = require3.resolve("@nextclaw/core");
+      const pkgRoot = resolve11(dirname3(entry), "..");
       const distSkills = join6(pkgRoot, "dist", "skills");
-      if (existsSync9(distSkills)) {
+      if (existsSync10(distSkills)) {
         return distSkills;
       }
       const srcSkills = join6(pkgRoot, "src", "agent", "skills");
-      if (existsSync9(srcSkills)) {
+      if (existsSync10(srcSkills)) {
         return srcSkills;
       }
       return null;
@@ -5372,11 +7278,11 @@ var WorkspaceManager = class {
     if (override) {
       return override;
     }
-    const cliDir = resolve8(fileURLToPath3(new URL(".", import.meta.url)));
-    const pkgRoot = resolve8(cliDir, "..", "..");
+    const cliDir = resolve11(fileURLToPath3(new URL(".", import.meta.url)));
+    const pkgRoot = resolve11(cliDir, "..", "..");
     const candidates = [join6(pkgRoot, "templates")];
     for (const candidate of candidates) {
-      if (existsSync9(candidate)) {
+      if (existsSync10(candidate)) {
         return candidate;
       }
     }
@@ -5384,21 +7290,21 @@ var WorkspaceManager = class {
   }
   getBridgeDir() {
     const userBridge = join6(getDataDir7(), "bridge");
-    if (existsSync9(join6(userBridge, "dist", "index.js"))) {
+    if (existsSync10(join6(userBridge, "dist", "index.js"))) {
       return userBridge;
     }
     if (!which("npm")) {
       console.error("npm not found. Please install Node.js >= 18.");
       process.exit(1);
     }
-    const cliDir = resolve8(fileURLToPath3(new URL(".", import.meta.url)));
-    const pkgRoot = resolve8(cliDir, "..", "..");
+    const cliDir = resolve11(fileURLToPath3(new URL(".", import.meta.url)));
+    const pkgRoot = resolve11(cliDir, "..", "..");
     const pkgBridge = join6(pkgRoot, "bridge");
     const srcBridge = join6(pkgRoot, "..", "..", "bridge");
     let source = null;
-    if (existsSync9(join6(pkgBridge, "package.json"))) {
+    if (existsSync10(join6(pkgBridge, "package.json"))) {
       source = pkgBridge;
-    } else if (existsSync9(join6(srcBridge, "package.json"))) {
+    } else if (existsSync10(join6(srcBridge, "package.json"))) {
       source = srcBridge;
     }
     if (!source) {
@@ -5406,8 +7312,8 @@ var WorkspaceManager = class {
       process.exit(1);
     }
     console.log(`${this.logo} Setting up bridge...`);
-    mkdirSync6(resolve8(userBridge, ".."), { recursive: true });
-    if (existsSync9(userBridge)) {
+    mkdirSync6(resolve11(userBridge, ".."), { recursive: true });
+    if (existsSync10(userBridge)) {
       rmSync5(userBridge, { recursive: true, force: true });
     }
     cpSync3(source, userBridge, {
@@ -5443,7 +7349,7 @@ function resolveSkillsInstallWorkdir(params) {
   if (params.explicitWorkdir) {
     return expandHome2(params.explicitWorkdir);
   }
-  return getWorkspacePath6(params.configuredWorkspace);
+  return getWorkspacePath9(params.configuredWorkspace);
 }
 var CliRuntime = class {
   logo;
@@ -5542,7 +7448,7 @@ var CliRuntime = class {
     const delayMs = typeof params.delayMs === "number" && Number.isFinite(params.delayMs) ? Math.max(0, Math.floor(params.delayMs)) : 100;
     const cliPath = process.env.NEXTCLAW_SELF_RELAUNCH_CLI?.trim() || fileURLToPath4(new URL("./index.js", import.meta.url));
     const startArgs = [cliPath, "start", "--ui-port", String(uiPort)];
-    const serviceStatePath = resolve9(getDataDir8(), "run", "service.json");
+    const serviceStatePath = resolve12(getDataDir8(), "run", "service.json");
     const helperScript = [
       'const { spawnSync } = require("node:child_process");',
       'const { readFileSync } = require("node:fs");',
@@ -5672,15 +7578,15 @@ var CliRuntime = class {
     const force = Boolean(options.force);
     const configPath = getConfigPath4();
     let createdConfig = false;
-    if (!existsSync10(configPath)) {
+    if (!existsSync11(configPath)) {
       const config3 = ConfigSchema2.parse({});
       saveConfig6(config3);
       createdConfig = true;
     }
-    const config2 = loadConfig7();
+    const config2 = loadConfig8();
     const workspaceSetting = config2.agents.defaults.workspace;
     const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join7(getDataDir8(), DEFAULT_WORKSPACE_DIR) : expandHome2(workspaceSetting);
-    const workspaceExisted = existsSync10(workspacePath);
+    const workspaceExisted = existsSync11(workspacePath);
     mkdirSync7(workspacePath, { recursive: true });
     const templateResult = this.workspaceManager.createWorkspaceTemplates(
       workspacePath,
@@ -5713,7 +7619,7 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
   async login(opts = {}) {
     await this.init({ source: "login", auto: true });
     const configPath = getConfigPath4();
-    const config2 = loadConfig7(configPath);
+    const config2 = loadConfig8(configPath);
     const providers = config2.providers;
     const nextclawProvider = providers.nextclaw ?? {
       displayName: "",
@@ -5870,15 +7776,15 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
   }
   async agent(opts) {
     const configPath = getConfigPath4();
-    const config2 = resolveConfigSecrets3(loadConfig7(), { configPath });
-    const workspace = getWorkspacePath6(config2.agents.defaults.workspace);
+    const config2 = resolveConfigSecrets3(loadConfig8(), { configPath });
+    const workspace = getWorkspacePath9(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspace);
     const extensionRegistry = toExtensionRegistry(pluginRegistry);
     logPluginDiagnostics(pluginRegistry);
-    const pluginChannelBindings = getPluginChannelBindings3(pluginRegistry);
+    const pluginChannelBindings = getPluginChannelBindings4(pluginRegistry);
     setPluginRuntimeBridge2({
       loadConfig: () => toPluginConfigView(
-        resolveConfigSecrets3(loadConfig7(), { configPath }),
+        resolveConfigSecrets3(loadConfig8(), { configPath }),
         pluginChannelBindings
       ),
       writeConfigFile: async (nextConfigView) => {
@@ -5887,7 +7793,7 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
             "plugin runtime writeConfigFile expects an object config"
           );
         }
-        const current = loadConfig7();
+        const current = loadConfig8();
         const next = mergePluginConfigView(
           current,
           nextConfigView,
@@ -5919,7 +7825,7 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
         resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints2({
           registry: pluginRegistry,
           channel,
-          cfg: resolveConfigSecrets3(loadConfig7(), { configPath }),
+          cfg: resolveConfigSecrets3(loadConfig8(), { configPath }),
           accountId
         })
       });
@@ -5939,9 +7845,9 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
 `
       );
       const historyFile = join7(getDataDir8(), "history", "cli_history");
-      const historyDir = resolve9(historyFile, "..");
+      const historyDir = resolve12(historyFile, "..");
       mkdirSync7(historyDir, { recursive: true });
-      const history = existsSync10(historyFile) ? readFileSync9(historyFile, "utf-8").split("\n").filter(Boolean) : [];
+      const history = existsSync11(historyFile) ? readFileSync10(historyFile, "utf-8").split("\n").filter(Boolean) : [];
       const rl = createInterface2({
         input: process.stdin,
         output: process.stdout
@@ -6096,7 +8002,7 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
     await this.diagnosticsCommands.doctor(opts);
   }
   async skillsInstall(options) {
-    const config2 = loadConfig7();
+    const config2 = loadConfig8();
     const workdir = resolveSkillsInstallWorkdir({
       explicitWorkdir: options.workdir,
       configuredWorkspace: config2.agents.defaults.workspace
@@ -6118,6 +8024,7 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
   async skillsPublish(options) {
     const result = await publishMarketplaceSkill({
       skillDir: expandHome2(options.dir),
+      metaFile: options.meta ? expandHome2(options.meta) : void 0,
       slug: options.slug,
       name: options.name,
       summary: options.summary,
@@ -6131,12 +8038,13 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
       apiBaseUrl: options.apiBaseUrl,
       token: options.token
     });
-    console.log(result.created ? `\u2713 Published new skill: ${result.slug}` : `\u2713 Updated skill: ${result.slug}`);
-    console.log(`  Files: ${result.fileCount}`);
+    console.log(`${result.created ? `\u2713 Published new skill: ${result.slug}` : `\u2713 Updated skill: ${result.slug}`}
+  Files: ${result.fileCount}`);
   }
   async skillsUpdate(options) {
     const result = await publishMarketplaceSkill({
       skillDir: expandHome2(options.dir),
+      metaFile: options.meta ? expandHome2(options.meta) : void 0,
       slug: options.slug,
       name: options.name,
       summary: options.summary,
@@ -6173,8 +8081,8 @@ program.command("update").description(`Update ${APP_NAME5}`).option("--timeout <
 var skills = program.command("skills").description("Manage skills");
 skills.command("install <slug>").description("Install a skill from NextClaw marketplace").option("--api-base <url>", "Marketplace API base URL").option("--workdir <dir>", "Workspace directory to install into").option("--dir <dir>", "Skills directory name (default: skills)").option("-f, --force", "Overwrite existing skill files", false).action(async (slug, opts) => runtime.skillsInstall({ slug, ...opts, apiBaseUrl: opts.apiBase }));
 var withRepeatableTag = (value, previous = []) => [...previous, value];
-skills.command("publish <dir>").description("Upload or create a skill in marketplace").option("--slug <slug>", "Skill slug (default: directory name)").option("--name <name>", "Skill display name").option("--summary <summary>", "Skill summary").option("--description <description>", "Skill description").option("--author <author>", "Skill author").option("--tag <tag>", "Skill tag (repeatable)", withRepeatableTag, []).option("--source-repo <url>", "Source repository URL").option("--homepage <url>", "Homepage URL").option("--published-at <datetime>", "Published time (ISO datetime)").option("--updated-at <datetime>", "Updated time (ISO datetime)").option("--api-base <url>", "Marketplace API base URL").option("--token <token>", "Marketplace admin token").action(async (dir, opts) => runtime.skillsPublish({ dir, ...opts, apiBaseUrl: opts.apiBase }));
-skills.command("update <dir>").description("Update an existing skill in marketplace").option("--slug <slug>", "Skill slug (default: directory name)").option("--name <name>", "Skill display name").option("--summary <summary>", "Skill summary").option("--description <description>", "Skill description").option("--author <author>", "Skill author").option("--tag <tag>", "Skill tag (repeatable)", withRepeatableTag, []).option("--source-repo <url>", "Source repository URL").option("--homepage <url>", "Homepage URL").option("--updated-at <datetime>", "Updated time (ISO datetime)").option("--api-base <url>", "Marketplace API base URL").option("--token <token>", "Marketplace admin token").action(async (dir, opts) => runtime.skillsUpdate({ dir, ...opts, apiBaseUrl: opts.apiBase }));
+skills.command("publish <dir>").description("Upload or create a skill in marketplace").option("--meta <path>", "Marketplace metadata file (default: <dir>/marketplace.json)").option("--slug <slug>", "Skill slug (default: directory name)").option("--name <name>", "Skill display name").option("--summary <summary>", "Skill summary").option("--description <description>", "Skill description").option("--author <author>", "Skill author").option("--tag <tag>", "Skill tag (repeatable)", withRepeatableTag, []).option("--source-repo <url>", "Source repository URL").option("--homepage <url>", "Homepage URL").option("--published-at <datetime>", "Published time (ISO datetime)").option("--updated-at <datetime>", "Updated time (ISO datetime)").option("--api-base <url>", "Marketplace API base URL").option("--token <token>", "Marketplace admin token").action(async (dir, opts) => runtime.skillsPublish({ dir, ...opts, apiBaseUrl: opts.apiBase }));
+skills.command("update <dir>").description("Update an existing skill in marketplace").option("--meta <path>", "Marketplace metadata file (default: <dir>/marketplace.json)").option("--slug <slug>", "Skill slug (default: directory name)").option("--name <name>", "Skill display name").option("--summary <summary>", "Skill summary").option("--description <description>", "Skill description").option("--author <author>", "Skill author").option("--tag <tag>", "Skill tag (repeatable)", withRepeatableTag, []).option("--source-repo <url>", "Source repository URL").option("--homepage <url>", "Homepage URL").option("--updated-at <datetime>", "Updated time (ISO datetime)").option("--api-base <url>", "Marketplace API base URL").option("--token <token>", "Marketplace admin token").action(async (dir, opts) => runtime.skillsUpdate({ dir, ...opts, apiBaseUrl: opts.apiBase }));
 var plugins = program.command("plugins").description("Manage OpenClaw-compatible plugins");
 plugins.command("list").description("List discovered plugins").option("--json", "Print JSON").option("--enabled", "Only show enabled plugins", false).option("--verbose", "Show detailed entries", false).action((opts) => runtime.pluginsList(opts));
 plugins.command("info <id>").description("Show plugin details").option("--json", "Print JSON").action((id, opts) => runtime.pluginsInfo(id, opts));
@@ -6184,9 +8092,9 @@ plugins.command("uninstall <id>").description("Uninstall a plugin").option("--ke
 plugins.command("install <path-or-spec>").description("Install a plugin (path, archive, or npm spec)").option("-l, --link", "Link a local path instead of copying", false).action(async (pathOrSpec, opts) => runtime.pluginsInstall(pathOrSpec, opts));
 plugins.command("doctor").description("Report plugin load issues").action(() => runtime.pluginsDoctor());
 var config = program.command("config").description("Manage config values");
-config.command("get <path>").description("Get a config value by dot path").option("--json", "Output JSON", false).action((path, opts) => runtime.configGet(path, opts));
-config.command("set <path> <value>").description("Set a config value by dot path").option("--json", "Parse value as JSON", false).action((path, value, opts) => runtime.configSet(path, value, opts));
-config.command("unset <path>").description("Remove a config value by dot path").action((path) => runtime.configUnset(path));
+config.command("get <path>").description("Get a config value by dot path").option("--json", "Output JSON", false).action((path2, opts) => runtime.configGet(path2, opts));
+config.command("set <path> <value>").description("Set a config value by dot path").option("--json", "Parse value as JSON", false).action((path2, value, opts) => runtime.configSet(path2, value, opts));
+config.command("unset <path>").description("Remove a config value by dot path").action((path2) => runtime.configUnset(path2));
 var secrets = program.command("secrets").description("Manage secrets refs/providers");
 secrets.command("audit").description("Audit secret refs resolution status").option("--json", "Output JSON", false).option("--strict", "Exit non-zero when unresolved refs exist", false).action((opts) => runtime.secretsAudit(opts));
 secrets.command("configure").description("Configure a secret provider alias").requiredOption("--provider <alias>", "Provider alias").option("--source <source>", "Provider source (env|file|exec)").option("--prefix <prefix>", "Env key prefix (env source)").option("--path <path>", "Secret JSON file path (file source)").option("--command <command>", "Command for exec source").option(