nextclaw 0.10.0 → 0.11.0

package/dist/cli/index.js

@@ -11,7 +11,7 @@ import {
   getConfigPath as getConfigPath4,
   getDataDir as getDataDir8,
   ConfigSchema as ConfigSchema2,
-  getWorkspacePath as getWorkspacePath6,
+  getWorkspacePath as getWorkspacePath7,
   expandHome as expandHome2,
   MessageBus as MessageBus2,
   AgentLoop,
@@ -26,8 +26,8 @@ import {
   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 resolve10 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { spawn as spawn3 } from "child_process";
@@ -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);
@@ -307,21 +519,24 @@ function isIgnorableMarketplaceResidue(path) {
   return path === ".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 = {
@@ -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";
@@ -629,11 +807,11 @@ function buildServeArgs(options) {
 }
 function readServiceState() {
   const path = resolveServiceStatePath();
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return null;
   }
   try {
-    const raw = readFileSync3(path, "utf-8");
+    const raw = readFileSync4(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -641,20 +819,20 @@ function readServiceState() {
 }
 function writeServiceState(state) {
   const path = resolveServiceStatePath();
-  mkdirSync3(resolve3(path, ".."), { recursive: true });
+  mkdirSync3(resolve4(path, ".."), { recursive: true });
   writeFileSync3(path, JSON.stringify(state, null, 2));
 }
 function clearServiceState() {
   const path = resolveServiceStatePath();
-  if (existsSync3(path)) {
+  if (existsSync4(path)) {
     rmSync3(path, { 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((resolve11) => setTimeout(resolve11, 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((resolve11) => {
+    rl.once("line", (line) => resolve11(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) {
@@ -885,8 +1063,8 @@ import {
 } from "@nextclaw/core";
 import { builtinProviderIds } from "@nextclaw/runtime";
 import { createInterface } from "readline";
-import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve6 } from "path";
 var RESERVED_PROVIDER_IDS = builtinProviderIds();
 function loadPluginRegistry(config2, workspaceDir) {
   return loadOpenClawPlugins({
@@ -1175,7 +1353,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 || resolve6(install.installPath) === resolve6(install.sourcePath));
     const preview = [];
     if (hasEntry) {
       preview.push("config entry");
@@ -1251,9 +1429,9 @@ var PluginCommands = class {
       process.exit(1);
     }
     const normalized = fileSpec && fileSpec.ok ? fileSpec.path : pathOrSpec;
-    const resolved = resolve5(expandHome(normalized));
+    const resolved = resolve6(expandHome(normalized));
     const config2 = loadConfig();
-    if (existsSync4(resolved)) {
+    if (existsSync5(resolved)) {
       if (opts.link) {
         const probe = await installPluginFromPath({ path: resolved, dryRun: true });
         if (!probe.ok) {
@@ -1367,8 +1545,8 @@ 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((resolve11) => {
+      rl.question(`${question} [y/N] `, (line) => resolve11(line));
     });
     rl.close();
     const normalized = answer.trim().toLowerCase();
@@ -1703,7 +1881,7 @@ 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,
@@ -1946,7 +2124,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;
@@ -2217,8 +2395,8 @@ 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 resolve7 } from "path";
 import {
   APP_NAME,
   getConfigPath as getConfigPath2,
@@ -2389,7 +2567,7 @@ var DiagnosticsCommands = class {
     const configPath = getConfigPath2();
     const config2 = loadConfig5();
     const workspacePath = getWorkspacePath3(config2.agents.defaults.workspace);
-    const serviceStatePath = resolve6(getDataDir4(), "run", "service.json");
+    const serviceStatePath = resolve7(getDataDir4(), "run", "service.json");
     const fixActions = [];
     let serviceState = readServiceState();
     if (params.fix && serviceState && !isProcessRunning(serviceState.pid)) {
@@ -2429,11 +2607,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 +2644,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,
@@ -2522,11 +2700,11 @@ var DiagnosticsCommands = class {
     }
   }
   readLogTail(path, maxLines = 25) {
-    if (!existsSync5(path)) {
+    if (!existsSync6(path)) {
       return [];
     }
     try {
-      const lines = readFileSync5(path, "utf-8").split(/\r?\n/).filter(Boolean);
+      const lines = readFileSync6(path, "utf-8").split(/\r?\n/).filter(Boolean);
       if (lines.length <= maxLines) {
         return lines;
       }
@@ -2536,17 +2714,17 @@ var DiagnosticsCommands = class {
     }
   }
   async checkPortAvailability(params) {
-    return await new Promise((resolve10) => {
+    return await new Promise((resolve11) => {
       const server = createNetServer();
       server.once("error", (error) => {
-        resolve10({
+        resolve11({
           available: false,
           detail: `bind failed on ${params.host}:${params.port} (${String(error)})`
         });
       });
       server.listen(params.port, params.host, () => {
         server.close(() => {
-          resolve10({
+          resolve11({
             available: true,
             detail: `bind ok on ${params.host}:${params.port}`
           });
@@ -2566,17 +2744,18 @@ import {
   stopPluginChannelGateways
 } 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 resolve8 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
+import { createServer as createNetServer2 } from "net";
 import { fileURLToPath as fileURLToPath2 } from "url";
 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,
@@ -2588,8 +2767,8 @@ var readConfigSnapshot = (getConfigPath5) => {
   const path = getConfigPath5();
   let raw = "";
   let parsed = {};
-  if (existsSync6(path)) {
-    raw = readFileSync6(path, "utf-8");
+  if (existsSync7(path)) {
+    raw = readFileSync7(path, "utf-8");
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -3519,8 +3698,1118 @@ function formatUserFacingError(error, maxChars = 320) {
   return `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
 }
 
+// src/cli/commands/ncp/create-ui-ncp-agent.ts
+import { DefaultNcpAgentRuntime } from "@nextclaw/ncp-agent-runtime";
+import { createAgentClientFromServer, DefaultNcpAgentBackend } from "@nextclaw/ncp-toolkit";
+
+// src/cli/commands/ncp/nextclaw-ncp-context-builder.ts
+import {
+  ContextBuilder,
+  InputBudgetPruner,
+  getWorkspacePath as getWorkspacePath5,
+  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: getWorkspacePath5(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
+      });
+    }
+  }
+};
+
+// src/cli/commands/ncp/create-ui-ncp-agent.ts
+async function createUiNcpAgent(params) {
+  const sessionStore = new NextclawAgentSessionStore(params.sessionManager);
+  const backend = new DefaultNcpAgentBackend({
+    endpointId: "nextclaw-ui-agent",
+    sessionStore,
+    createRuntime: ({ sessionId: _sessionId, stateManager }) => {
+      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
+      });
+    }
+  });
+  await backend.start();
+  return {
+    basePath: "/api/ncp/agent",
+    agentClientEndpoint: createAgentClientFromServer(backend),
+    streamProvider: backend,
+    sessionApi: backend
+  };
+}
+
 // 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 +4825,7 @@ function createRunId() {
   const rand = Math.random().toString(36).slice(2, 10);
   return `run-${now}-${rand}`;
 }
-function isRecord2(value) {
+function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readOptionalString(value) {
@@ -3726,7 +5015,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 = isRecord5(input.metadata) ? { ...input.metadata } : {};
     if (model) {
       metadata.model = model;
     }
@@ -3947,14 +5236,14 @@ var UiChatRunCoordinator = class {
     this.emitRunUpdated(run);
   }
   waitForRunUpdate(run, signal) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve11) => {
       const wake = () => {
         cleanup();
-        resolve10();
+        resolve11();
       };
       const onAbort = () => {
         cleanup();
-        resolve10();
+        resolve11();
       };
       const cleanup = () => {
         run.waiters.delete(wake);
@@ -4075,7 +5364,7 @@ var UiChatRunCoordinator = class {
 `);
   }
   loadPersistedRuns() {
-    if (!existsSync7(RUNS_DIR)) {
+    if (!existsSync8(RUNS_DIR)) {
       return;
     }
     for (const entry of readdirSync2(RUNS_DIR, { withFileTypes: true })) {
@@ -4084,7 +5373,7 @@ var UiChatRunCoordinator = class {
       }
       const path = join4(RUNS_DIR, entry.name);
       try {
-        const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+        const parsed = JSON.parse(readFileSync8(path, "utf-8"));
         const runId = readOptionalString(parsed.runId);
         const sessionKey = readOptionalString(parsed.sessionKey);
         if (!runId || !sessionKey) {
@@ -4147,7 +5436,7 @@ var {
   getDataDir: getDataDir6,
   getProvider,
   getProviderName,
-  getWorkspacePath: getWorkspacePath5,
+  getWorkspacePath: getWorkspacePath6,
   HeartbeatService,
   LiteLLMProvider,
   loadConfig: loadConfig6,
@@ -4211,7 +5500,7 @@ function buildMarketplaceSkillInstallArgs(params) {
 function resolveCliSubcommandEntry(params) {
   const argvEntry = params.argvEntry?.trim();
   if (argvEntry) {
-    return resolve7(argvEntry);
+    return resolve8(argvEntry);
   }
   return fileURLToPath2(new URL("../index.js", params.importMetaUrl));
 }
@@ -4222,7 +5511,7 @@ var ServiceCommands = class {
   async startGateway(options = {}) {
     const runtimeConfigPath = getConfigPath3();
     const config2 = resolveConfigSecrets2(loadConfig6(), { configPath: runtimeConfigPath });
-    const workspace = getWorkspacePath5(config2.agents.defaults.workspace);
+    const workspace = getWorkspacePath6(config2.agents.defaults.workspace);
     let pluginRegistry = loadPluginRegistry(config2, workspace);
     let extensionRegistry = toExtensionRegistry(pluginRegistry);
     logPluginDiagnostics(pluginRegistry);
@@ -4313,7 +5602,7 @@ var ServiceCommands = class {
     });
     reloader.setApplyAgentRuntimeConfig((nextConfig) => runtimePool.applyRuntimeConfig(nextConfig));
     reloader.setReloadPlugins(async (nextConfig) => {
-      const nextWorkspace = getWorkspacePath5(nextConfig.agents.defaults.workspace);
+      const nextWorkspace = getWorkspacePath6(nextConfig.agents.defaults.workspace);
       const nextPluginRegistry = loadPluginRegistry(nextConfig, nextWorkspace);
       const nextExtensionRegistry = toExtensionRegistry(nextPluginRegistry);
       logPluginDiagnostics(nextPluginRegistry);
@@ -4405,19 +5694,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(loadConfig6(), { configPath: runtimeConfigPath }),
+      () => extensionRegistry,
+      ({ channel, accountId }) => resolvePluginChannelMessageToolHints({
+        registry: pluginRegistry,
+        channel,
+        cfg: resolveConfigSecrets2(loadConfig6(), { 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 = resolve8(getConfigPath3());
     const watcher = chokidar.watch(configPath, {
       ignoreInitial: true,
       awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
     });
     watcher.on("all", (event, changedPath) => {
-      if (resolve7(changedPath) !== configPath) {
+      if (resolve8(changedPath) !== configPath) {
         return;
       }
       if (event === "add") {
@@ -4509,7 +5815,7 @@ var ServiceCommands = class {
     if (!sentinel) {
       return;
     }
-    await new Promise((resolve10) => setTimeout(resolve10, 750));
+    await new Promise((resolve11) => setTimeout(resolve11, 750));
     const payload = sentinel.payload;
     const summary = formatRestartSentinelMessage(payload);
     const sentinelSessionKey = this.normalizeOptionalString(payload.sessionKey);
@@ -4616,8 +5922,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 = resolve8(logPath, "..");
     mkdirSync5(logDir, { recursive: true });
     const logFd = openSync(logPath, "a");
     const readinessTimeoutMs = this.resolveStartupTimeoutMs(options.startupTimeoutMs);
@@ -4645,13 +5962,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 +6082,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((resolve11) => setTimeout(resolve11, 200));
         continue;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, 300));
+      await new Promise((resolve11) => setTimeout(resolve11, 300));
       if (isProcessRunning(params.pid)) {
         return { ready: true, lastProbeError: null };
       }
-      await new Promise((resolve10) => setTimeout(resolve10, 200));
+      await new Promise((resolve11) => setTimeout(resolve11, 200));
     }
     return { ready: false, lastProbeError };
   }
@@ -4810,6 +6126,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((resolve11) => {
+      const server = createNetServer2();
+      server.once("error", (error) => {
+        resolve11({
+          available: false,
+          detail: `bind failed on ${params.host}:${params.port} (${String(error)})`
+        });
+      });
+      server.listen(params.port, params.host, () => {
+        server.close(() => {
+          resolve11({
+            available: true,
+            detail: `bind ok on ${params.host}:${params.port}`
+          });
+        });
+      });
+    });
+  }
   getHeaderValue(headers, key) {
     const value = headers[key];
     if (typeof value === "string") {
@@ -4838,7 +6206,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((resolve11) => {
       const req = requestImpl(
         {
           protocol: parsed.protocol,
@@ -4874,19 +6242,19 @@ var ServiceCommands = class {
               if (bodySnippet) {
                 details.push(`body=${bodySnippet}`);
               }
-              resolve10({ healthy: false, error: details.join("; ") });
+              resolve11({ 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" });
+                resolve11({ healthy: false, error: "health payload not ok" });
                 return;
               }
-              resolve10({ healthy: true, error: null });
+              resolve11({ healthy: true, error: null });
             } catch {
-              resolve10({ healthy: false, error: "invalid health JSON response" });
+              resolve11({ healthy: false, error: "invalid health JSON response" });
             }
           });
         }
@@ -4895,7 +6263,7 @@ var ServiceCommands = class {
         req.destroy(new Error("probe timeout"));
       });
       req.on("error", (error) => {
-        resolve10({ healthy: false, error: error.message || String(error) });
+        resolve11({ healthy: false, error: error.message || String(error) });
       });
       req.end();
     });
@@ -4945,13 +6313,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;
     }
@@ -5022,6 +6399,19 @@ 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
+      })
+    });
     const uiServer = startUiServer({
       host: uiConfig.host,
       port: uiConfig.port,
@@ -5040,6 +6430,7 @@ var ServiceCommands = class {
           uninstallSkill: (slug) => this.uninstallMarketplaceSkill(slug)
         }
       },
+      ncpAgent,
       chatRuntime: {
         listSessionTypes: async () => {
           const options = runtimePool.listAvailableEngineKinds().map((value) => ({
@@ -5134,7 +6525,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 = getWorkspacePath6(loadConfig6().agents.defaults.workspace);
     const args = buildMarketplaceSkillInstallArgs({
       slug: params.slug,
       workspace,
@@ -5168,9 +6559,9 @@ var ServiceCommands = class {
     return { message: summary };
   }
   async uninstallMarketplaceSkill(slug) {
-    const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
+    const workspace = getWorkspacePath6(loadConfig6().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 +6570,10 @@ var ServiceCommands = class {
     };
   }
   installBuiltinMarketplaceSkill(slug, force) {
-    const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
+    const workspace = getWorkspacePath6(loadConfig6().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 +6581,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 +6648,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 { 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 } from "module";
-import { dirname as dirname3, join as join6, resolve as resolve8 } from "path";
+import { dirname as dirname3, join as join6, resolve as resolve9 } 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 +6681,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 +6723,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 {
@@ -5353,13 +6744,13 @@ var WorkspaceManager = class {
     try {
       const require2 = createRequire(import.meta.url);
       const entry = require2.resolve("@nextclaw/core");
-      const pkgRoot = resolve8(dirname3(entry), "..");
+      const pkgRoot = resolve9(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 +6763,11 @@ var WorkspaceManager = class {
     if (override) {
       return override;
     }
-    const cliDir = resolve8(fileURLToPath3(new URL(".", import.meta.url)));
-    const pkgRoot = resolve8(cliDir, "..", "..");
+    const cliDir = resolve9(fileURLToPath3(new URL(".", import.meta.url)));
+    const pkgRoot = resolve9(cliDir, "..", "..");
     const candidates = [join6(pkgRoot, "templates")];
     for (const candidate of candidates) {
-      if (existsSync9(candidate)) {
+      if (existsSync10(candidate)) {
         return candidate;
       }
     }
@@ -5384,21 +6775,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 = resolve9(fileURLToPath3(new URL(".", import.meta.url)));
+    const pkgRoot = resolve9(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 +6797,8 @@ var WorkspaceManager = class {
       process.exit(1);
     }
     console.log(`${this.logo} Setting up bridge...`);
-    mkdirSync6(resolve8(userBridge, ".."), { recursive: true });
-    if (existsSync9(userBridge)) {
+    mkdirSync6(resolve9(userBridge, ".."), { recursive: true });
+    if (existsSync10(userBridge)) {
       rmSync5(userBridge, { recursive: true, force: true });
     }
     cpSync3(source, userBridge, {
@@ -5443,7 +6834,7 @@ function resolveSkillsInstallWorkdir(params) {
   if (params.explicitWorkdir) {
     return expandHome2(params.explicitWorkdir);
   }
-  return getWorkspacePath6(params.configuredWorkspace);
+  return getWorkspacePath7(params.configuredWorkspace);
 }
 var CliRuntime = class {
   logo;
@@ -5542,7 +6933,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 = resolve10(getDataDir8(), "run", "service.json");
     const helperScript = [
       'const { spawnSync } = require("node:child_process");',
       'const { readFileSync } = require("node:fs");',
@@ -5672,7 +7063,7 @@ 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;
@@ -5680,7 +7071,7 @@ var CliRuntime = class {
     const config2 = loadConfig7();
     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,
@@ -5871,7 +7262,7 @@ ${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 workspace = getWorkspacePath7(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspace);
     const extensionRegistry = toExtensionRegistry(pluginRegistry);
     logPluginDiagnostics(pluginRegistry);
@@ -5939,9 +7330,9 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
 `
       );
       const historyFile = join7(getDataDir8(), "history", "cli_history");
-      const historyDir = resolve9(historyFile, "..");
+      const historyDir = resolve10(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
@@ -6118,6 +7509,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 +7523,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 +7566,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));